1#![allow(clippy::useless_conversion)]
2use crate::meta::*;
3impl serde::Serialize for ActivateWorkerNodeRequest {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.host.is_some() {
12 len += 1;
13 }
14 if self.node_id != 0 {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
18 if let Some(v) = self.host.as_ref() {
19 struct_ser.serialize_field("host", v)?;
20 }
21 if self.node_id != 0 {
22 struct_ser.serialize_field("nodeId", &self.node_id)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "host",
35 "node_id",
36 "nodeId",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 Host,
42 NodeId,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "host" => Ok(GeneratedField::Host),
65 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = ActivateWorkerNodeRequest;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct meta.ActivateWorkerNodeRequest")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut host__ = None;
86 let mut node_id__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::Host => {
90 if host__.is_some() {
91 return Err(serde::de::Error::duplicate_field("host"));
92 }
93 host__ = map_.next_value()?;
94 }
95 GeneratedField::NodeId => {
96 if node_id__.is_some() {
97 return Err(serde::de::Error::duplicate_field("nodeId"));
98 }
99 node_id__ =
100 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
101 ;
102 }
103 }
104 }
105 Ok(ActivateWorkerNodeRequest {
106 host: host__,
107 node_id: node_id__.unwrap_or_default(),
108 })
109 }
110 }
111 deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
112 }
113}
114impl serde::Serialize for ActivateWorkerNodeResponse {
115 #[allow(deprecated)]
116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
117 where
118 S: serde::Serializer,
119 {
120 use serde::ser::SerializeStruct;
121 let mut len = 0;
122 if self.status.is_some() {
123 len += 1;
124 }
125 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
126 if let Some(v) = self.status.as_ref() {
127 struct_ser.serialize_field("status", v)?;
128 }
129 struct_ser.end()
130 }
131}
132impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
133 #[allow(deprecated)]
134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
135 where
136 D: serde::Deserializer<'de>,
137 {
138 const FIELDS: &[&str] = &[
139 "status",
140 ];
141
142 #[allow(clippy::enum_variant_names)]
143 enum GeneratedField {
144 Status,
145 }
146 impl<'de> serde::Deserialize<'de> for GeneratedField {
147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
148 where
149 D: serde::Deserializer<'de>,
150 {
151 struct GeneratedVisitor;
152
153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
154 type Value = GeneratedField;
155
156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
157 write!(formatter, "expected one of: {:?}", &FIELDS)
158 }
159
160 #[allow(unused_variables)]
161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
162 where
163 E: serde::de::Error,
164 {
165 match value {
166 "status" => Ok(GeneratedField::Status),
167 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
168 }
169 }
170 }
171 deserializer.deserialize_identifier(GeneratedVisitor)
172 }
173 }
174 struct GeneratedVisitor;
175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
176 type Value = ActivateWorkerNodeResponse;
177
178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
179 formatter.write_str("struct meta.ActivateWorkerNodeResponse")
180 }
181
182 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
183 where
184 V: serde::de::MapAccess<'de>,
185 {
186 let mut status__ = None;
187 while let Some(k) = map_.next_key()? {
188 match k {
189 GeneratedField::Status => {
190 if status__.is_some() {
191 return Err(serde::de::Error::duplicate_field("status"));
192 }
193 status__ = map_.next_value()?;
194 }
195 }
196 }
197 Ok(ActivateWorkerNodeResponse {
198 status: status__,
199 })
200 }
201 }
202 deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
203 }
204}
205impl serde::Serialize for ActorCountPerParallelism {
206 #[allow(deprecated)]
207 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
208 where
209 S: serde::Serializer,
210 {
211 use serde::ser::SerializeStruct;
212 let mut len = 0;
213 if !self.worker_id_to_actor_count.is_empty() {
214 len += 1;
215 }
216 if self.hard_limit != 0 {
217 len += 1;
218 }
219 if self.soft_limit != 0 {
220 len += 1;
221 }
222 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
223 if !self.worker_id_to_actor_count.is_empty() {
224 struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
225 }
226 if self.hard_limit != 0 {
227 #[allow(clippy::needless_borrow)]
228 #[allow(clippy::needless_borrows_for_generic_args)]
229 struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
230 }
231 if self.soft_limit != 0 {
232 #[allow(clippy::needless_borrow)]
233 #[allow(clippy::needless_borrows_for_generic_args)]
234 struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
235 }
236 struct_ser.end()
237 }
238}
239impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
240 #[allow(deprecated)]
241 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
242 where
243 D: serde::Deserializer<'de>,
244 {
245 const FIELDS: &[&str] = &[
246 "worker_id_to_actor_count",
247 "workerIdToActorCount",
248 "hard_limit",
249 "hardLimit",
250 "soft_limit",
251 "softLimit",
252 ];
253
254 #[allow(clippy::enum_variant_names)]
255 enum GeneratedField {
256 WorkerIdToActorCount,
257 HardLimit,
258 SoftLimit,
259 }
260 impl<'de> serde::Deserialize<'de> for GeneratedField {
261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
262 where
263 D: serde::Deserializer<'de>,
264 {
265 struct GeneratedVisitor;
266
267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
268 type Value = GeneratedField;
269
270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
271 write!(formatter, "expected one of: {:?}", &FIELDS)
272 }
273
274 #[allow(unused_variables)]
275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
276 where
277 E: serde::de::Error,
278 {
279 match value {
280 "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
281 "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
282 "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
284 }
285 }
286 }
287 deserializer.deserialize_identifier(GeneratedVisitor)
288 }
289 }
290 struct GeneratedVisitor;
291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
292 type Value = ActorCountPerParallelism;
293
294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
295 formatter.write_str("struct meta.ActorCountPerParallelism")
296 }
297
298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
299 where
300 V: serde::de::MapAccess<'de>,
301 {
302 let mut worker_id_to_actor_count__ = None;
303 let mut hard_limit__ = None;
304 let mut soft_limit__ = None;
305 while let Some(k) = map_.next_key()? {
306 match k {
307 GeneratedField::WorkerIdToActorCount => {
308 if worker_id_to_actor_count__.is_some() {
309 return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
310 }
311 worker_id_to_actor_count__ = Some(
312 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
313 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
314 );
315 }
316 GeneratedField::HardLimit => {
317 if hard_limit__.is_some() {
318 return Err(serde::de::Error::duplicate_field("hardLimit"));
319 }
320 hard_limit__ =
321 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
322 ;
323 }
324 GeneratedField::SoftLimit => {
325 if soft_limit__.is_some() {
326 return Err(serde::de::Error::duplicate_field("softLimit"));
327 }
328 soft_limit__ =
329 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
330 ;
331 }
332 }
333 }
334 Ok(ActorCountPerParallelism {
335 worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
336 hard_limit: hard_limit__.unwrap_or_default(),
337 soft_limit: soft_limit__.unwrap_or_default(),
338 })
339 }
340 }
341 deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
342 }
343}
344impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
345 #[allow(deprecated)]
346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
347 where
348 S: serde::Serializer,
349 {
350 use serde::ser::SerializeStruct;
351 let mut len = 0;
352 if self.actor_count != 0 {
353 len += 1;
354 }
355 if self.parallelism != 0 {
356 len += 1;
357 }
358 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
359 if self.actor_count != 0 {
360 #[allow(clippy::needless_borrow)]
361 #[allow(clippy::needless_borrows_for_generic_args)]
362 struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
363 }
364 if self.parallelism != 0 {
365 #[allow(clippy::needless_borrow)]
366 #[allow(clippy::needless_borrows_for_generic_args)]
367 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
368 }
369 struct_ser.end()
370 }
371}
372impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
373 #[allow(deprecated)]
374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
375 where
376 D: serde::Deserializer<'de>,
377 {
378 const FIELDS: &[&str] = &[
379 "actor_count",
380 "actorCount",
381 "parallelism",
382 ];
383
384 #[allow(clippy::enum_variant_names)]
385 enum GeneratedField {
386 ActorCount,
387 Parallelism,
388 }
389 impl<'de> serde::Deserialize<'de> for GeneratedField {
390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
391 where
392 D: serde::Deserializer<'de>,
393 {
394 struct GeneratedVisitor;
395
396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
397 type Value = GeneratedField;
398
399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
400 write!(formatter, "expected one of: {:?}", &FIELDS)
401 }
402
403 #[allow(unused_variables)]
404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
405 where
406 E: serde::de::Error,
407 {
408 match value {
409 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
410 "parallelism" => Ok(GeneratedField::Parallelism),
411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
412 }
413 }
414 }
415 deserializer.deserialize_identifier(GeneratedVisitor)
416 }
417 }
418 struct GeneratedVisitor;
419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
420 type Value = actor_count_per_parallelism::WorkerActorCount;
421
422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
423 formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
424 }
425
426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
427 where
428 V: serde::de::MapAccess<'de>,
429 {
430 let mut actor_count__ = None;
431 let mut parallelism__ = None;
432 while let Some(k) = map_.next_key()? {
433 match k {
434 GeneratedField::ActorCount => {
435 if actor_count__.is_some() {
436 return Err(serde::de::Error::duplicate_field("actorCount"));
437 }
438 actor_count__ =
439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
440 ;
441 }
442 GeneratedField::Parallelism => {
443 if parallelism__.is_some() {
444 return Err(serde::de::Error::duplicate_field("parallelism"));
445 }
446 parallelism__ =
447 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
448 ;
449 }
450 }
451 }
452 Ok(actor_count_per_parallelism::WorkerActorCount {
453 actor_count: actor_count__.unwrap_or_default(),
454 parallelism: parallelism__.unwrap_or_default(),
455 })
456 }
457 }
458 deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
459 }
460}
461impl serde::Serialize for ActorIds {
462 #[allow(deprecated)]
463 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
464 where
465 S: serde::Serializer,
466 {
467 use serde::ser::SerializeStruct;
468 let mut len = 0;
469 if !self.ids.is_empty() {
470 len += 1;
471 }
472 let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
473 if !self.ids.is_empty() {
474 struct_ser.serialize_field("ids", &self.ids)?;
475 }
476 struct_ser.end()
477 }
478}
479impl<'de> serde::Deserialize<'de> for ActorIds {
480 #[allow(deprecated)]
481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
482 where
483 D: serde::Deserializer<'de>,
484 {
485 const FIELDS: &[&str] = &[
486 "ids",
487 ];
488
489 #[allow(clippy::enum_variant_names)]
490 enum GeneratedField {
491 Ids,
492 }
493 impl<'de> serde::Deserialize<'de> for GeneratedField {
494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
495 where
496 D: serde::Deserializer<'de>,
497 {
498 struct GeneratedVisitor;
499
500 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
501 type Value = GeneratedField;
502
503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
504 write!(formatter, "expected one of: {:?}", &FIELDS)
505 }
506
507 #[allow(unused_variables)]
508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
509 where
510 E: serde::de::Error,
511 {
512 match value {
513 "ids" => Ok(GeneratedField::Ids),
514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
515 }
516 }
517 }
518 deserializer.deserialize_identifier(GeneratedVisitor)
519 }
520 }
521 struct GeneratedVisitor;
522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
523 type Value = ActorIds;
524
525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
526 formatter.write_str("struct meta.ActorIds")
527 }
528
529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
530 where
531 V: serde::de::MapAccess<'de>,
532 {
533 let mut ids__ = None;
534 while let Some(k) = map_.next_key()? {
535 match k {
536 GeneratedField::Ids => {
537 if ids__.is_some() {
538 return Err(serde::de::Error::duplicate_field("ids"));
539 }
540 ids__ =
541 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
542 .into_iter().map(|x| x.0).collect())
543 ;
544 }
545 }
546 }
547 Ok(ActorIds {
548 ids: ids__.unwrap_or_default(),
549 })
550 }
551 }
552 deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
553 }
554}
555impl serde::Serialize for ActorLocation {
556 #[allow(deprecated)]
557 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
558 where
559 S: serde::Serializer,
560 {
561 use serde::ser::SerializeStruct;
562 let mut len = 0;
563 if self.node.is_some() {
564 len += 1;
565 }
566 if !self.actors.is_empty() {
567 len += 1;
568 }
569 let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
570 if let Some(v) = self.node.as_ref() {
571 struct_ser.serialize_field("node", v)?;
572 }
573 if !self.actors.is_empty() {
574 struct_ser.serialize_field("actors", &self.actors)?;
575 }
576 struct_ser.end()
577 }
578}
579impl<'de> serde::Deserialize<'de> for ActorLocation {
580 #[allow(deprecated)]
581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
582 where
583 D: serde::Deserializer<'de>,
584 {
585 const FIELDS: &[&str] = &[
586 "node",
587 "actors",
588 ];
589
590 #[allow(clippy::enum_variant_names)]
591 enum GeneratedField {
592 Node,
593 Actors,
594 }
595 impl<'de> serde::Deserialize<'de> for GeneratedField {
596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
597 where
598 D: serde::Deserializer<'de>,
599 {
600 struct GeneratedVisitor;
601
602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
603 type Value = GeneratedField;
604
605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
606 write!(formatter, "expected one of: {:?}", &FIELDS)
607 }
608
609 #[allow(unused_variables)]
610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
611 where
612 E: serde::de::Error,
613 {
614 match value {
615 "node" => Ok(GeneratedField::Node),
616 "actors" => Ok(GeneratedField::Actors),
617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
618 }
619 }
620 }
621 deserializer.deserialize_identifier(GeneratedVisitor)
622 }
623 }
624 struct GeneratedVisitor;
625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
626 type Value = ActorLocation;
627
628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
629 formatter.write_str("struct meta.ActorLocation")
630 }
631
632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
633 where
634 V: serde::de::MapAccess<'de>,
635 {
636 let mut node__ = None;
637 let mut actors__ = None;
638 while let Some(k) = map_.next_key()? {
639 match k {
640 GeneratedField::Node => {
641 if node__.is_some() {
642 return Err(serde::de::Error::duplicate_field("node"));
643 }
644 node__ = map_.next_value()?;
645 }
646 GeneratedField::Actors => {
647 if actors__.is_some() {
648 return Err(serde::de::Error::duplicate_field("actors"));
649 }
650 actors__ = Some(map_.next_value()?);
651 }
652 }
653 }
654 Ok(ActorLocation {
655 node: node__,
656 actors: actors__.unwrap_or_default(),
657 })
658 }
659 }
660 deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
661 }
662}
663impl serde::Serialize for AddEventLogRequest {
664 #[allow(deprecated)]
665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
666 where
667 S: serde::Serializer,
668 {
669 use serde::ser::SerializeStruct;
670 let mut len = 0;
671 if self.event.is_some() {
672 len += 1;
673 }
674 let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
675 if let Some(v) = self.event.as_ref() {
676 match v {
677 add_event_log_request::Event::WorkerNodePanic(v) => {
678 struct_ser.serialize_field("workerNodePanic", v)?;
679 }
680 add_event_log_request::Event::SinkFail(v) => {
681 struct_ser.serialize_field("sinkFail", v)?;
682 }
683 add_event_log_request::Event::AutoSchemaChangeFail(v) => {
684 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
685 }
686 }
687 }
688 struct_ser.end()
689 }
690}
691impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
692 #[allow(deprecated)]
693 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
694 where
695 D: serde::Deserializer<'de>,
696 {
697 const FIELDS: &[&str] = &[
698 "worker_node_panic",
699 "workerNodePanic",
700 "sink_fail",
701 "sinkFail",
702 "auto_schema_change_fail",
703 "autoSchemaChangeFail",
704 ];
705
706 #[allow(clippy::enum_variant_names)]
707 enum GeneratedField {
708 WorkerNodePanic,
709 SinkFail,
710 AutoSchemaChangeFail,
711 }
712 impl<'de> serde::Deserialize<'de> for GeneratedField {
713 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
714 where
715 D: serde::Deserializer<'de>,
716 {
717 struct GeneratedVisitor;
718
719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
720 type Value = GeneratedField;
721
722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
723 write!(formatter, "expected one of: {:?}", &FIELDS)
724 }
725
726 #[allow(unused_variables)]
727 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
728 where
729 E: serde::de::Error,
730 {
731 match value {
732 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
733 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
734 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
735 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
736 }
737 }
738 }
739 deserializer.deserialize_identifier(GeneratedVisitor)
740 }
741 }
742 struct GeneratedVisitor;
743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
744 type Value = AddEventLogRequest;
745
746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
747 formatter.write_str("struct meta.AddEventLogRequest")
748 }
749
750 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
751 where
752 V: serde::de::MapAccess<'de>,
753 {
754 let mut event__ = None;
755 while let Some(k) = map_.next_key()? {
756 match k {
757 GeneratedField::WorkerNodePanic => {
758 if event__.is_some() {
759 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
760 }
761 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
762;
763 }
764 GeneratedField::SinkFail => {
765 if event__.is_some() {
766 return Err(serde::de::Error::duplicate_field("sinkFail"));
767 }
768 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
769;
770 }
771 GeneratedField::AutoSchemaChangeFail => {
772 if event__.is_some() {
773 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
774 }
775 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::AutoSchemaChangeFail)
776;
777 }
778 }
779 }
780 Ok(AddEventLogRequest {
781 event: event__,
782 })
783 }
784 }
785 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
786 }
787}
788impl serde::Serialize for AddEventLogResponse {
789 #[allow(deprecated)]
790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
791 where
792 S: serde::Serializer,
793 {
794 use serde::ser::SerializeStruct;
795 let len = 0;
796 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
797 struct_ser.end()
798 }
799}
800impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
801 #[allow(deprecated)]
802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
803 where
804 D: serde::Deserializer<'de>,
805 {
806 const FIELDS: &[&str] = &[
807 ];
808
809 #[allow(clippy::enum_variant_names)]
810 enum GeneratedField {
811 }
812 impl<'de> serde::Deserialize<'de> for GeneratedField {
813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
814 where
815 D: serde::Deserializer<'de>,
816 {
817 struct GeneratedVisitor;
818
819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
820 type Value = GeneratedField;
821
822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823 write!(formatter, "expected one of: {:?}", &FIELDS)
824 }
825
826 #[allow(unused_variables)]
827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
828 where
829 E: serde::de::Error,
830 {
831 Err(serde::de::Error::unknown_field(value, FIELDS))
832 }
833 }
834 deserializer.deserialize_identifier(GeneratedVisitor)
835 }
836 }
837 struct GeneratedVisitor;
838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
839 type Value = AddEventLogResponse;
840
841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
842 formatter.write_str("struct meta.AddEventLogResponse")
843 }
844
845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
846 where
847 V: serde::de::MapAccess<'de>,
848 {
849 while map_.next_key::<GeneratedField>()?.is_some() {
850 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
851 }
852 Ok(AddEventLogResponse {
853 })
854 }
855 }
856 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
857 }
858}
859impl serde::Serialize for AddWorkerNodeRequest {
860 #[allow(deprecated)]
861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
862 where
863 S: serde::Serializer,
864 {
865 use serde::ser::SerializeStruct;
866 let mut len = 0;
867 if self.worker_type != 0 {
868 len += 1;
869 }
870 if self.host.is_some() {
871 len += 1;
872 }
873 if self.resource.is_some() {
874 len += 1;
875 }
876 if self.property.is_some() {
877 len += 1;
878 }
879 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
880 if self.worker_type != 0 {
881 let v = super::common::WorkerType::try_from(self.worker_type)
882 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
883 struct_ser.serialize_field("workerType", &v)?;
884 }
885 if let Some(v) = self.host.as_ref() {
886 struct_ser.serialize_field("host", v)?;
887 }
888 if let Some(v) = self.resource.as_ref() {
889 struct_ser.serialize_field("resource", v)?;
890 }
891 if let Some(v) = self.property.as_ref() {
892 struct_ser.serialize_field("property", v)?;
893 }
894 struct_ser.end()
895 }
896}
897impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
898 #[allow(deprecated)]
899 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
900 where
901 D: serde::Deserializer<'de>,
902 {
903 const FIELDS: &[&str] = &[
904 "worker_type",
905 "workerType",
906 "host",
907 "resource",
908 "property",
909 ];
910
911 #[allow(clippy::enum_variant_names)]
912 enum GeneratedField {
913 WorkerType,
914 Host,
915 Resource,
916 Property,
917 }
918 impl<'de> serde::Deserialize<'de> for GeneratedField {
919 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
920 where
921 D: serde::Deserializer<'de>,
922 {
923 struct GeneratedVisitor;
924
925 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
926 type Value = GeneratedField;
927
928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
929 write!(formatter, "expected one of: {:?}", &FIELDS)
930 }
931
932 #[allow(unused_variables)]
933 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
934 where
935 E: serde::de::Error,
936 {
937 match value {
938 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
939 "host" => Ok(GeneratedField::Host),
940 "resource" => Ok(GeneratedField::Resource),
941 "property" => Ok(GeneratedField::Property),
942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
943 }
944 }
945 }
946 deserializer.deserialize_identifier(GeneratedVisitor)
947 }
948 }
949 struct GeneratedVisitor;
950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
951 type Value = AddWorkerNodeRequest;
952
953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
954 formatter.write_str("struct meta.AddWorkerNodeRequest")
955 }
956
957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
958 where
959 V: serde::de::MapAccess<'de>,
960 {
961 let mut worker_type__ = None;
962 let mut host__ = None;
963 let mut resource__ = None;
964 let mut property__ = None;
965 while let Some(k) = map_.next_key()? {
966 match k {
967 GeneratedField::WorkerType => {
968 if worker_type__.is_some() {
969 return Err(serde::de::Error::duplicate_field("workerType"));
970 }
971 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
972 }
973 GeneratedField::Host => {
974 if host__.is_some() {
975 return Err(serde::de::Error::duplicate_field("host"));
976 }
977 host__ = map_.next_value()?;
978 }
979 GeneratedField::Resource => {
980 if resource__.is_some() {
981 return Err(serde::de::Error::duplicate_field("resource"));
982 }
983 resource__ = map_.next_value()?;
984 }
985 GeneratedField::Property => {
986 if property__.is_some() {
987 return Err(serde::de::Error::duplicate_field("property"));
988 }
989 property__ = map_.next_value()?;
990 }
991 }
992 }
993 Ok(AddWorkerNodeRequest {
994 worker_type: worker_type__.unwrap_or_default(),
995 host: host__,
996 resource: resource__,
997 property: property__,
998 })
999 }
1000 }
1001 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
1002 }
1003}
1004impl serde::Serialize for AddWorkerNodeResponse {
1005 #[allow(deprecated)]
1006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1007 where
1008 S: serde::Serializer,
1009 {
1010 use serde::ser::SerializeStruct;
1011 let mut len = 0;
1012 if self.node_id.is_some() {
1013 len += 1;
1014 }
1015 if !self.cluster_id.is_empty() {
1016 len += 1;
1017 }
1018 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1019 if let Some(v) = self.node_id.as_ref() {
1020 struct_ser.serialize_field("nodeId", v)?;
1021 }
1022 if !self.cluster_id.is_empty() {
1023 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1024 }
1025 struct_ser.end()
1026 }
1027}
1028impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1029 #[allow(deprecated)]
1030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1031 where
1032 D: serde::Deserializer<'de>,
1033 {
1034 const FIELDS: &[&str] = &[
1035 "node_id",
1036 "nodeId",
1037 "cluster_id",
1038 "clusterId",
1039 ];
1040
1041 #[allow(clippy::enum_variant_names)]
1042 enum GeneratedField {
1043 NodeId,
1044 ClusterId,
1045 }
1046 impl<'de> serde::Deserialize<'de> for GeneratedField {
1047 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1048 where
1049 D: serde::Deserializer<'de>,
1050 {
1051 struct GeneratedVisitor;
1052
1053 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1054 type Value = GeneratedField;
1055
1056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1057 write!(formatter, "expected one of: {:?}", &FIELDS)
1058 }
1059
1060 #[allow(unused_variables)]
1061 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1062 where
1063 E: serde::de::Error,
1064 {
1065 match value {
1066 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1067 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1069 }
1070 }
1071 }
1072 deserializer.deserialize_identifier(GeneratedVisitor)
1073 }
1074 }
1075 struct GeneratedVisitor;
1076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1077 type Value = AddWorkerNodeResponse;
1078
1079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1080 formatter.write_str("struct meta.AddWorkerNodeResponse")
1081 }
1082
1083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1084 where
1085 V: serde::de::MapAccess<'de>,
1086 {
1087 let mut node_id__ = None;
1088 let mut cluster_id__ = None;
1089 while let Some(k) = map_.next_key()? {
1090 match k {
1091 GeneratedField::NodeId => {
1092 if node_id__.is_some() {
1093 return Err(serde::de::Error::duplicate_field("nodeId"));
1094 }
1095 node_id__ =
1096 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1097 ;
1098 }
1099 GeneratedField::ClusterId => {
1100 if cluster_id__.is_some() {
1101 return Err(serde::de::Error::duplicate_field("clusterId"));
1102 }
1103 cluster_id__ = Some(map_.next_value()?);
1104 }
1105 }
1106 }
1107 Ok(AddWorkerNodeResponse {
1108 node_id: node_id__,
1109 cluster_id: cluster_id__.unwrap_or_default(),
1110 })
1111 }
1112 }
1113 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1114 }
1115}
1116impl serde::Serialize for AlterConnectorPropsRequest {
1117 #[allow(deprecated)]
1118 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1119 where
1120 S: serde::Serializer,
1121 {
1122 use serde::ser::SerializeStruct;
1123 let mut len = 0;
1124 if self.object_id != 0 {
1125 len += 1;
1126 }
1127 if !self.changed_props.is_empty() {
1128 len += 1;
1129 }
1130 if !self.changed_secret_refs.is_empty() {
1131 len += 1;
1132 }
1133 if self.connector_conn_ref.is_some() {
1134 len += 1;
1135 }
1136 if self.object_type != 0 {
1137 len += 1;
1138 }
1139 if self.extra_options.is_some() {
1140 len += 1;
1141 }
1142 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1143 if self.object_id != 0 {
1144 struct_ser.serialize_field("objectId", &self.object_id)?;
1145 }
1146 if !self.changed_props.is_empty() {
1147 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1148 }
1149 if !self.changed_secret_refs.is_empty() {
1150 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1151 }
1152 if let Some(v) = self.connector_conn_ref.as_ref() {
1153 struct_ser.serialize_field("connectorConnRef", v)?;
1154 }
1155 if self.object_type != 0 {
1156 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1157 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1158 struct_ser.serialize_field("objectType", &v)?;
1159 }
1160 if let Some(v) = self.extra_options.as_ref() {
1161 match v {
1162 alter_connector_props_request::ExtraOptions::AlterIcebergTableIds(v) => {
1163 struct_ser.serialize_field("alterIcebergTableIds", v)?;
1164 }
1165 }
1166 }
1167 struct_ser.end()
1168 }
1169}
1170impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1171 #[allow(deprecated)]
1172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1173 where
1174 D: serde::Deserializer<'de>,
1175 {
1176 const FIELDS: &[&str] = &[
1177 "object_id",
1178 "objectId",
1179 "changed_props",
1180 "changedProps",
1181 "changed_secret_refs",
1182 "changedSecretRefs",
1183 "connector_conn_ref",
1184 "connectorConnRef",
1185 "object_type",
1186 "objectType",
1187 "alter_iceberg_table_ids",
1188 "alterIcebergTableIds",
1189 ];
1190
1191 #[allow(clippy::enum_variant_names)]
1192 enum GeneratedField {
1193 ObjectId,
1194 ChangedProps,
1195 ChangedSecretRefs,
1196 ConnectorConnRef,
1197 ObjectType,
1198 AlterIcebergTableIds,
1199 }
1200 impl<'de> serde::Deserialize<'de> for GeneratedField {
1201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1202 where
1203 D: serde::Deserializer<'de>,
1204 {
1205 struct GeneratedVisitor;
1206
1207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1208 type Value = GeneratedField;
1209
1210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1211 write!(formatter, "expected one of: {:?}", &FIELDS)
1212 }
1213
1214 #[allow(unused_variables)]
1215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1216 where
1217 E: serde::de::Error,
1218 {
1219 match value {
1220 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1221 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1222 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1223 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1224 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1225 "alterIcebergTableIds" | "alter_iceberg_table_ids" => Ok(GeneratedField::AlterIcebergTableIds),
1226 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1227 }
1228 }
1229 }
1230 deserializer.deserialize_identifier(GeneratedVisitor)
1231 }
1232 }
1233 struct GeneratedVisitor;
1234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1235 type Value = AlterConnectorPropsRequest;
1236
1237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1238 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1239 }
1240
1241 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1242 where
1243 V: serde::de::MapAccess<'de>,
1244 {
1245 let mut object_id__ = None;
1246 let mut changed_props__ = None;
1247 let mut changed_secret_refs__ = None;
1248 let mut connector_conn_ref__ = None;
1249 let mut object_type__ = None;
1250 let mut extra_options__ = None;
1251 while let Some(k) = map_.next_key()? {
1252 match k {
1253 GeneratedField::ObjectId => {
1254 if object_id__.is_some() {
1255 return Err(serde::de::Error::duplicate_field("objectId"));
1256 }
1257 object_id__ =
1258 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1259 ;
1260 }
1261 GeneratedField::ChangedProps => {
1262 if changed_props__.is_some() {
1263 return Err(serde::de::Error::duplicate_field("changedProps"));
1264 }
1265 changed_props__ = Some(
1266 map_.next_value::<std::collections::HashMap<_, _>>()?
1267 );
1268 }
1269 GeneratedField::ChangedSecretRefs => {
1270 if changed_secret_refs__.is_some() {
1271 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1272 }
1273 changed_secret_refs__ = Some(
1274 map_.next_value::<std::collections::HashMap<_, _>>()?
1275 );
1276 }
1277 GeneratedField::ConnectorConnRef => {
1278 if connector_conn_ref__.is_some() {
1279 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1280 }
1281 connector_conn_ref__ =
1282 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1283 ;
1284 }
1285 GeneratedField::ObjectType => {
1286 if object_type__.is_some() {
1287 return Err(serde::de::Error::duplicate_field("objectType"));
1288 }
1289 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1290 }
1291 GeneratedField::AlterIcebergTableIds => {
1292 if extra_options__.is_some() {
1293 return Err(serde::de::Error::duplicate_field("alterIcebergTableIds"));
1294 }
1295 extra_options__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_connector_props_request::ExtraOptions::AlterIcebergTableIds)
1296;
1297 }
1298 }
1299 }
1300 Ok(AlterConnectorPropsRequest {
1301 object_id: object_id__.unwrap_or_default(),
1302 changed_props: changed_props__.unwrap_or_default(),
1303 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1304 connector_conn_ref: connector_conn_ref__,
1305 object_type: object_type__.unwrap_or_default(),
1306 extra_options: extra_options__,
1307 })
1308 }
1309 }
1310 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1311 }
1312}
1313impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1314 #[allow(deprecated)]
1315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1316 where
1317 S: serde::Serializer,
1318 {
1319 let variant = match self {
1320 Self::Unspecified => "UNSPECIFIED",
1321 Self::Source => "SOURCE",
1322 Self::Sink => "SINK",
1323 Self::Connection => "CONNECTION",
1324 Self::IcebergTable => "ICEBERG_TABLE",
1325 };
1326 serializer.serialize_str(variant)
1327 }
1328}
1329impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1330 #[allow(deprecated)]
1331 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1332 where
1333 D: serde::Deserializer<'de>,
1334 {
1335 const FIELDS: &[&str] = &[
1336 "UNSPECIFIED",
1337 "SOURCE",
1338 "SINK",
1339 "CONNECTION",
1340 "ICEBERG_TABLE",
1341 ];
1342
1343 struct GeneratedVisitor;
1344
1345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1346 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1347
1348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1349 write!(formatter, "expected one of: {:?}", &FIELDS)
1350 }
1351
1352 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1353 where
1354 E: serde::de::Error,
1355 {
1356 i32::try_from(v)
1357 .ok()
1358 .and_then(|x| x.try_into().ok())
1359 .ok_or_else(|| {
1360 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1361 })
1362 }
1363
1364 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1365 where
1366 E: serde::de::Error,
1367 {
1368 i32::try_from(v)
1369 .ok()
1370 .and_then(|x| x.try_into().ok())
1371 .ok_or_else(|| {
1372 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1373 })
1374 }
1375
1376 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1377 where
1378 E: serde::de::Error,
1379 {
1380 match value {
1381 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1382 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1383 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1384 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1385 "ICEBERG_TABLE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::IcebergTable),
1386 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1387 }
1388 }
1389 }
1390 deserializer.deserialize_any(GeneratedVisitor)
1391 }
1392}
1393impl serde::Serialize for alter_connector_props_request::AlterIcebergTableIds {
1394 #[allow(deprecated)]
1395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1396 where
1397 S: serde::Serializer,
1398 {
1399 use serde::ser::SerializeStruct;
1400 let mut len = 0;
1401 if self.source_id != 0 {
1402 len += 1;
1403 }
1404 if self.sink_id != 0 {
1405 len += 1;
1406 }
1407 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", len)?;
1408 if self.source_id != 0 {
1409 struct_ser.serialize_field("sourceId", &self.source_id)?;
1410 }
1411 if self.sink_id != 0 {
1412 struct_ser.serialize_field("sinkId", &self.sink_id)?;
1413 }
1414 struct_ser.end()
1415 }
1416}
1417impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterIcebergTableIds {
1418 #[allow(deprecated)]
1419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1420 where
1421 D: serde::Deserializer<'de>,
1422 {
1423 const FIELDS: &[&str] = &[
1424 "source_id",
1425 "sourceId",
1426 "sink_id",
1427 "sinkId",
1428 ];
1429
1430 #[allow(clippy::enum_variant_names)]
1431 enum GeneratedField {
1432 SourceId,
1433 SinkId,
1434 }
1435 impl<'de> serde::Deserialize<'de> for GeneratedField {
1436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1437 where
1438 D: serde::Deserializer<'de>,
1439 {
1440 struct GeneratedVisitor;
1441
1442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1443 type Value = GeneratedField;
1444
1445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1446 write!(formatter, "expected one of: {:?}", &FIELDS)
1447 }
1448
1449 #[allow(unused_variables)]
1450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1451 where
1452 E: serde::de::Error,
1453 {
1454 match value {
1455 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1456 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1457 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1458 }
1459 }
1460 }
1461 deserializer.deserialize_identifier(GeneratedVisitor)
1462 }
1463 }
1464 struct GeneratedVisitor;
1465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1466 type Value = alter_connector_props_request::AlterIcebergTableIds;
1467
1468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1469 formatter.write_str("struct meta.AlterConnectorPropsRequest.AlterIcebergTableIds")
1470 }
1471
1472 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_connector_props_request::AlterIcebergTableIds, V::Error>
1473 where
1474 V: serde::de::MapAccess<'de>,
1475 {
1476 let mut source_id__ = None;
1477 let mut sink_id__ = None;
1478 while let Some(k) = map_.next_key()? {
1479 match k {
1480 GeneratedField::SourceId => {
1481 if source_id__.is_some() {
1482 return Err(serde::de::Error::duplicate_field("sourceId"));
1483 }
1484 source_id__ =
1485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1486 ;
1487 }
1488 GeneratedField::SinkId => {
1489 if sink_id__.is_some() {
1490 return Err(serde::de::Error::duplicate_field("sinkId"));
1491 }
1492 sink_id__ =
1493 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1494 ;
1495 }
1496 }
1497 }
1498 Ok(alter_connector_props_request::AlterIcebergTableIds {
1499 source_id: source_id__.unwrap_or_default(),
1500 sink_id: sink_id__.unwrap_or_default(),
1501 })
1502 }
1503 }
1504 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", FIELDS, GeneratedVisitor)
1505 }
1506}
1507impl serde::Serialize for AlterConnectorPropsResponse {
1508 #[allow(deprecated)]
1509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1510 where
1511 S: serde::Serializer,
1512 {
1513 use serde::ser::SerializeStruct;
1514 let len = 0;
1515 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1516 struct_ser.end()
1517 }
1518}
1519impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1520 #[allow(deprecated)]
1521 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1522 where
1523 D: serde::Deserializer<'de>,
1524 {
1525 const FIELDS: &[&str] = &[
1526 ];
1527
1528 #[allow(clippy::enum_variant_names)]
1529 enum GeneratedField {
1530 }
1531 impl<'de> serde::Deserialize<'de> for GeneratedField {
1532 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1533 where
1534 D: serde::Deserializer<'de>,
1535 {
1536 struct GeneratedVisitor;
1537
1538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1539 type Value = GeneratedField;
1540
1541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1542 write!(formatter, "expected one of: {:?}", &FIELDS)
1543 }
1544
1545 #[allow(unused_variables)]
1546 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1547 where
1548 E: serde::de::Error,
1549 {
1550 Err(serde::de::Error::unknown_field(value, FIELDS))
1551 }
1552 }
1553 deserializer.deserialize_identifier(GeneratedVisitor)
1554 }
1555 }
1556 struct GeneratedVisitor;
1557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1558 type Value = AlterConnectorPropsResponse;
1559
1560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1561 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1562 }
1563
1564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1565 where
1566 V: serde::de::MapAccess<'de>,
1567 {
1568 while map_.next_key::<GeneratedField>()?.is_some() {
1569 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1570 }
1571 Ok(AlterConnectorPropsResponse {
1572 })
1573 }
1574 }
1575 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1576 }
1577}
1578impl serde::Serialize for ApplyThrottleRequest {
1579 #[allow(deprecated)]
1580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1581 where
1582 S: serde::Serializer,
1583 {
1584 use serde::ser::SerializeStruct;
1585 let mut len = 0;
1586 if self.kind != 0 {
1587 len += 1;
1588 }
1589 if self.id != 0 {
1590 len += 1;
1591 }
1592 if self.rate.is_some() {
1593 len += 1;
1594 }
1595 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1596 if self.kind != 0 {
1597 let v = ThrottleTarget::try_from(self.kind)
1598 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1599 struct_ser.serialize_field("kind", &v)?;
1600 }
1601 if self.id != 0 {
1602 struct_ser.serialize_field("id", &self.id)?;
1603 }
1604 if let Some(v) = self.rate.as_ref() {
1605 struct_ser.serialize_field("rate", v)?;
1606 }
1607 struct_ser.end()
1608 }
1609}
1610impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1611 #[allow(deprecated)]
1612 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1613 where
1614 D: serde::Deserializer<'de>,
1615 {
1616 const FIELDS: &[&str] = &[
1617 "kind",
1618 "id",
1619 "rate",
1620 ];
1621
1622 #[allow(clippy::enum_variant_names)]
1623 enum GeneratedField {
1624 Kind,
1625 Id,
1626 Rate,
1627 }
1628 impl<'de> serde::Deserialize<'de> for GeneratedField {
1629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1630 where
1631 D: serde::Deserializer<'de>,
1632 {
1633 struct GeneratedVisitor;
1634
1635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1636 type Value = GeneratedField;
1637
1638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1639 write!(formatter, "expected one of: {:?}", &FIELDS)
1640 }
1641
1642 #[allow(unused_variables)]
1643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1644 where
1645 E: serde::de::Error,
1646 {
1647 match value {
1648 "kind" => Ok(GeneratedField::Kind),
1649 "id" => Ok(GeneratedField::Id),
1650 "rate" => Ok(GeneratedField::Rate),
1651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1652 }
1653 }
1654 }
1655 deserializer.deserialize_identifier(GeneratedVisitor)
1656 }
1657 }
1658 struct GeneratedVisitor;
1659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1660 type Value = ApplyThrottleRequest;
1661
1662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1663 formatter.write_str("struct meta.ApplyThrottleRequest")
1664 }
1665
1666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1667 where
1668 V: serde::de::MapAccess<'de>,
1669 {
1670 let mut kind__ = None;
1671 let mut id__ = None;
1672 let mut rate__ = None;
1673 while let Some(k) = map_.next_key()? {
1674 match k {
1675 GeneratedField::Kind => {
1676 if kind__.is_some() {
1677 return Err(serde::de::Error::duplicate_field("kind"));
1678 }
1679 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1680 }
1681 GeneratedField::Id => {
1682 if id__.is_some() {
1683 return Err(serde::de::Error::duplicate_field("id"));
1684 }
1685 id__ =
1686 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1687 ;
1688 }
1689 GeneratedField::Rate => {
1690 if rate__.is_some() {
1691 return Err(serde::de::Error::duplicate_field("rate"));
1692 }
1693 rate__ =
1694 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1695 ;
1696 }
1697 }
1698 }
1699 Ok(ApplyThrottleRequest {
1700 kind: kind__.unwrap_or_default(),
1701 id: id__.unwrap_or_default(),
1702 rate: rate__,
1703 })
1704 }
1705 }
1706 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1707 }
1708}
1709impl serde::Serialize for ApplyThrottleResponse {
1710 #[allow(deprecated)]
1711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1712 where
1713 S: serde::Serializer,
1714 {
1715 use serde::ser::SerializeStruct;
1716 let mut len = 0;
1717 if self.status.is_some() {
1718 len += 1;
1719 }
1720 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1721 if let Some(v) = self.status.as_ref() {
1722 struct_ser.serialize_field("status", v)?;
1723 }
1724 struct_ser.end()
1725 }
1726}
1727impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1728 #[allow(deprecated)]
1729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1730 where
1731 D: serde::Deserializer<'de>,
1732 {
1733 const FIELDS: &[&str] = &[
1734 "status",
1735 ];
1736
1737 #[allow(clippy::enum_variant_names)]
1738 enum GeneratedField {
1739 Status,
1740 }
1741 impl<'de> serde::Deserialize<'de> for GeneratedField {
1742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1743 where
1744 D: serde::Deserializer<'de>,
1745 {
1746 struct GeneratedVisitor;
1747
1748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1749 type Value = GeneratedField;
1750
1751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1752 write!(formatter, "expected one of: {:?}", &FIELDS)
1753 }
1754
1755 #[allow(unused_variables)]
1756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1757 where
1758 E: serde::de::Error,
1759 {
1760 match value {
1761 "status" => Ok(GeneratedField::Status),
1762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1763 }
1764 }
1765 }
1766 deserializer.deserialize_identifier(GeneratedVisitor)
1767 }
1768 }
1769 struct GeneratedVisitor;
1770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1771 type Value = ApplyThrottleResponse;
1772
1773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1774 formatter.write_str("struct meta.ApplyThrottleResponse")
1775 }
1776
1777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1778 where
1779 V: serde::de::MapAccess<'de>,
1780 {
1781 let mut status__ = None;
1782 while let Some(k) = map_.next_key()? {
1783 match k {
1784 GeneratedField::Status => {
1785 if status__.is_some() {
1786 return Err(serde::de::Error::duplicate_field("status"));
1787 }
1788 status__ = map_.next_value()?;
1789 }
1790 }
1791 }
1792 Ok(ApplyThrottleResponse {
1793 status: status__,
1794 })
1795 }
1796 }
1797 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1798 }
1799}
1800impl serde::Serialize for CancelCreatingJobsRequest {
1801 #[allow(deprecated)]
1802 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1803 where
1804 S: serde::Serializer,
1805 {
1806 use serde::ser::SerializeStruct;
1807 let mut len = 0;
1808 if self.jobs.is_some() {
1809 len += 1;
1810 }
1811 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1812 if let Some(v) = self.jobs.as_ref() {
1813 match v {
1814 cancel_creating_jobs_request::Jobs::Infos(v) => {
1815 struct_ser.serialize_field("infos", v)?;
1816 }
1817 cancel_creating_jobs_request::Jobs::Ids(v) => {
1818 struct_ser.serialize_field("ids", v)?;
1819 }
1820 }
1821 }
1822 struct_ser.end()
1823 }
1824}
1825impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1826 #[allow(deprecated)]
1827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1828 where
1829 D: serde::Deserializer<'de>,
1830 {
1831 const FIELDS: &[&str] = &[
1832 "infos",
1833 "ids",
1834 ];
1835
1836 #[allow(clippy::enum_variant_names)]
1837 enum GeneratedField {
1838 Infos,
1839 Ids,
1840 }
1841 impl<'de> serde::Deserialize<'de> for GeneratedField {
1842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1843 where
1844 D: serde::Deserializer<'de>,
1845 {
1846 struct GeneratedVisitor;
1847
1848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1849 type Value = GeneratedField;
1850
1851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1852 write!(formatter, "expected one of: {:?}", &FIELDS)
1853 }
1854
1855 #[allow(unused_variables)]
1856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1857 where
1858 E: serde::de::Error,
1859 {
1860 match value {
1861 "infos" => Ok(GeneratedField::Infos),
1862 "ids" => Ok(GeneratedField::Ids),
1863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1864 }
1865 }
1866 }
1867 deserializer.deserialize_identifier(GeneratedVisitor)
1868 }
1869 }
1870 struct GeneratedVisitor;
1871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1872 type Value = CancelCreatingJobsRequest;
1873
1874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1875 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1876 }
1877
1878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1879 where
1880 V: serde::de::MapAccess<'de>,
1881 {
1882 let mut jobs__ = None;
1883 while let Some(k) = map_.next_key()? {
1884 match k {
1885 GeneratedField::Infos => {
1886 if jobs__.is_some() {
1887 return Err(serde::de::Error::duplicate_field("infos"));
1888 }
1889 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1890;
1891 }
1892 GeneratedField::Ids => {
1893 if jobs__.is_some() {
1894 return Err(serde::de::Error::duplicate_field("ids"));
1895 }
1896 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1897;
1898 }
1899 }
1900 }
1901 Ok(CancelCreatingJobsRequest {
1902 jobs: jobs__,
1903 })
1904 }
1905 }
1906 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1907 }
1908}
1909impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1910 #[allow(deprecated)]
1911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1912 where
1913 S: serde::Serializer,
1914 {
1915 use serde::ser::SerializeStruct;
1916 let mut len = 0;
1917 if !self.job_ids.is_empty() {
1918 len += 1;
1919 }
1920 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1921 if !self.job_ids.is_empty() {
1922 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1923 }
1924 struct_ser.end()
1925 }
1926}
1927impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1928 #[allow(deprecated)]
1929 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1930 where
1931 D: serde::Deserializer<'de>,
1932 {
1933 const FIELDS: &[&str] = &[
1934 "job_ids",
1935 "jobIds",
1936 ];
1937
1938 #[allow(clippy::enum_variant_names)]
1939 enum GeneratedField {
1940 JobIds,
1941 }
1942 impl<'de> serde::Deserialize<'de> for GeneratedField {
1943 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1944 where
1945 D: serde::Deserializer<'de>,
1946 {
1947 struct GeneratedVisitor;
1948
1949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1950 type Value = GeneratedField;
1951
1952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1953 write!(formatter, "expected one of: {:?}", &FIELDS)
1954 }
1955
1956 #[allow(unused_variables)]
1957 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1958 where
1959 E: serde::de::Error,
1960 {
1961 match value {
1962 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1963 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1964 }
1965 }
1966 }
1967 deserializer.deserialize_identifier(GeneratedVisitor)
1968 }
1969 }
1970 struct GeneratedVisitor;
1971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1972 type Value = cancel_creating_jobs_request::CreatingJobIds;
1973
1974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1975 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1976 }
1977
1978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1979 where
1980 V: serde::de::MapAccess<'de>,
1981 {
1982 let mut job_ids__ = None;
1983 while let Some(k) = map_.next_key()? {
1984 match k {
1985 GeneratedField::JobIds => {
1986 if job_ids__.is_some() {
1987 return Err(serde::de::Error::duplicate_field("jobIds"));
1988 }
1989 job_ids__ =
1990 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1991 .into_iter().map(|x| x.0).collect())
1992 ;
1993 }
1994 }
1995 }
1996 Ok(cancel_creating_jobs_request::CreatingJobIds {
1997 job_ids: job_ids__.unwrap_or_default(),
1998 })
1999 }
2000 }
2001 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2002 }
2003}
2004impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
2005 #[allow(deprecated)]
2006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2007 where
2008 S: serde::Serializer,
2009 {
2010 use serde::ser::SerializeStruct;
2011 let mut len = 0;
2012 if self.database_id != 0 {
2013 len += 1;
2014 }
2015 if self.schema_id != 0 {
2016 len += 1;
2017 }
2018 if !self.name.is_empty() {
2019 len += 1;
2020 }
2021 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2022 if self.database_id != 0 {
2023 struct_ser.serialize_field("databaseId", &self.database_id)?;
2024 }
2025 if self.schema_id != 0 {
2026 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2027 }
2028 if !self.name.is_empty() {
2029 struct_ser.serialize_field("name", &self.name)?;
2030 }
2031 struct_ser.end()
2032 }
2033}
2034impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2035 #[allow(deprecated)]
2036 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2037 where
2038 D: serde::Deserializer<'de>,
2039 {
2040 const FIELDS: &[&str] = &[
2041 "database_id",
2042 "databaseId",
2043 "schema_id",
2044 "schemaId",
2045 "name",
2046 ];
2047
2048 #[allow(clippy::enum_variant_names)]
2049 enum GeneratedField {
2050 DatabaseId,
2051 SchemaId,
2052 Name,
2053 }
2054 impl<'de> serde::Deserialize<'de> for GeneratedField {
2055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2056 where
2057 D: serde::Deserializer<'de>,
2058 {
2059 struct GeneratedVisitor;
2060
2061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2062 type Value = GeneratedField;
2063
2064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2065 write!(formatter, "expected one of: {:?}", &FIELDS)
2066 }
2067
2068 #[allow(unused_variables)]
2069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2070 where
2071 E: serde::de::Error,
2072 {
2073 match value {
2074 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2075 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2076 "name" => Ok(GeneratedField::Name),
2077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2078 }
2079 }
2080 }
2081 deserializer.deserialize_identifier(GeneratedVisitor)
2082 }
2083 }
2084 struct GeneratedVisitor;
2085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2086 type Value = cancel_creating_jobs_request::CreatingJobInfo;
2087
2088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2089 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2090 }
2091
2092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2093 where
2094 V: serde::de::MapAccess<'de>,
2095 {
2096 let mut database_id__ = None;
2097 let mut schema_id__ = None;
2098 let mut name__ = None;
2099 while let Some(k) = map_.next_key()? {
2100 match k {
2101 GeneratedField::DatabaseId => {
2102 if database_id__.is_some() {
2103 return Err(serde::de::Error::duplicate_field("databaseId"));
2104 }
2105 database_id__ =
2106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2107 ;
2108 }
2109 GeneratedField::SchemaId => {
2110 if schema_id__.is_some() {
2111 return Err(serde::de::Error::duplicate_field("schemaId"));
2112 }
2113 schema_id__ =
2114 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2115 ;
2116 }
2117 GeneratedField::Name => {
2118 if name__.is_some() {
2119 return Err(serde::de::Error::duplicate_field("name"));
2120 }
2121 name__ = Some(map_.next_value()?);
2122 }
2123 }
2124 }
2125 Ok(cancel_creating_jobs_request::CreatingJobInfo {
2126 database_id: database_id__.unwrap_or_default(),
2127 schema_id: schema_id__.unwrap_or_default(),
2128 name: name__.unwrap_or_default(),
2129 })
2130 }
2131 }
2132 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2133 }
2134}
2135impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2136 #[allow(deprecated)]
2137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2138 where
2139 S: serde::Serializer,
2140 {
2141 use serde::ser::SerializeStruct;
2142 let mut len = 0;
2143 if !self.infos.is_empty() {
2144 len += 1;
2145 }
2146 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2147 if !self.infos.is_empty() {
2148 struct_ser.serialize_field("infos", &self.infos)?;
2149 }
2150 struct_ser.end()
2151 }
2152}
2153impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2154 #[allow(deprecated)]
2155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2156 where
2157 D: serde::Deserializer<'de>,
2158 {
2159 const FIELDS: &[&str] = &[
2160 "infos",
2161 ];
2162
2163 #[allow(clippy::enum_variant_names)]
2164 enum GeneratedField {
2165 Infos,
2166 }
2167 impl<'de> serde::Deserialize<'de> for GeneratedField {
2168 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2169 where
2170 D: serde::Deserializer<'de>,
2171 {
2172 struct GeneratedVisitor;
2173
2174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2175 type Value = GeneratedField;
2176
2177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2178 write!(formatter, "expected one of: {:?}", &FIELDS)
2179 }
2180
2181 #[allow(unused_variables)]
2182 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2183 where
2184 E: serde::de::Error,
2185 {
2186 match value {
2187 "infos" => Ok(GeneratedField::Infos),
2188 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2189 }
2190 }
2191 }
2192 deserializer.deserialize_identifier(GeneratedVisitor)
2193 }
2194 }
2195 struct GeneratedVisitor;
2196 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2197 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2198
2199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2200 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2201 }
2202
2203 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2204 where
2205 V: serde::de::MapAccess<'de>,
2206 {
2207 let mut infos__ = None;
2208 while let Some(k) = map_.next_key()? {
2209 match k {
2210 GeneratedField::Infos => {
2211 if infos__.is_some() {
2212 return Err(serde::de::Error::duplicate_field("infos"));
2213 }
2214 infos__ = Some(map_.next_value()?);
2215 }
2216 }
2217 }
2218 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2219 infos: infos__.unwrap_or_default(),
2220 })
2221 }
2222 }
2223 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2224 }
2225}
2226impl serde::Serialize for CancelCreatingJobsResponse {
2227 #[allow(deprecated)]
2228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2229 where
2230 S: serde::Serializer,
2231 {
2232 use serde::ser::SerializeStruct;
2233 let mut len = 0;
2234 if self.status.is_some() {
2235 len += 1;
2236 }
2237 if !self.canceled_jobs.is_empty() {
2238 len += 1;
2239 }
2240 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2241 if let Some(v) = self.status.as_ref() {
2242 struct_ser.serialize_field("status", v)?;
2243 }
2244 if !self.canceled_jobs.is_empty() {
2245 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2246 }
2247 struct_ser.end()
2248 }
2249}
2250impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2251 #[allow(deprecated)]
2252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2253 where
2254 D: serde::Deserializer<'de>,
2255 {
2256 const FIELDS: &[&str] = &[
2257 "status",
2258 "canceled_jobs",
2259 "canceledJobs",
2260 ];
2261
2262 #[allow(clippy::enum_variant_names)]
2263 enum GeneratedField {
2264 Status,
2265 CanceledJobs,
2266 }
2267 impl<'de> serde::Deserialize<'de> for GeneratedField {
2268 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2269 where
2270 D: serde::Deserializer<'de>,
2271 {
2272 struct GeneratedVisitor;
2273
2274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2275 type Value = GeneratedField;
2276
2277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2278 write!(formatter, "expected one of: {:?}", &FIELDS)
2279 }
2280
2281 #[allow(unused_variables)]
2282 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2283 where
2284 E: serde::de::Error,
2285 {
2286 match value {
2287 "status" => Ok(GeneratedField::Status),
2288 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2290 }
2291 }
2292 }
2293 deserializer.deserialize_identifier(GeneratedVisitor)
2294 }
2295 }
2296 struct GeneratedVisitor;
2297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2298 type Value = CancelCreatingJobsResponse;
2299
2300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2301 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2302 }
2303
2304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2305 where
2306 V: serde::de::MapAccess<'de>,
2307 {
2308 let mut status__ = None;
2309 let mut canceled_jobs__ = None;
2310 while let Some(k) = map_.next_key()? {
2311 match k {
2312 GeneratedField::Status => {
2313 if status__.is_some() {
2314 return Err(serde::de::Error::duplicate_field("status"));
2315 }
2316 status__ = map_.next_value()?;
2317 }
2318 GeneratedField::CanceledJobs => {
2319 if canceled_jobs__.is_some() {
2320 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2321 }
2322 canceled_jobs__ =
2323 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2324 .into_iter().map(|x| x.0).collect())
2325 ;
2326 }
2327 }
2328 }
2329 Ok(CancelCreatingJobsResponse {
2330 status: status__,
2331 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2332 })
2333 }
2334 }
2335 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2336 }
2337}
2338impl serde::Serialize for ClusterLimit {
2339 #[allow(deprecated)]
2340 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2341 where
2342 S: serde::Serializer,
2343 {
2344 use serde::ser::SerializeStruct;
2345 let mut len = 0;
2346 if self.limit.is_some() {
2347 len += 1;
2348 }
2349 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2350 if let Some(v) = self.limit.as_ref() {
2351 match v {
2352 cluster_limit::Limit::ActorCount(v) => {
2353 struct_ser.serialize_field("actorCount", v)?;
2354 }
2355 }
2356 }
2357 struct_ser.end()
2358 }
2359}
2360impl<'de> serde::Deserialize<'de> for ClusterLimit {
2361 #[allow(deprecated)]
2362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2363 where
2364 D: serde::Deserializer<'de>,
2365 {
2366 const FIELDS: &[&str] = &[
2367 "actor_count",
2368 "actorCount",
2369 ];
2370
2371 #[allow(clippy::enum_variant_names)]
2372 enum GeneratedField {
2373 ActorCount,
2374 }
2375 impl<'de> serde::Deserialize<'de> for GeneratedField {
2376 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2377 where
2378 D: serde::Deserializer<'de>,
2379 {
2380 struct GeneratedVisitor;
2381
2382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2383 type Value = GeneratedField;
2384
2385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2386 write!(formatter, "expected one of: {:?}", &FIELDS)
2387 }
2388
2389 #[allow(unused_variables)]
2390 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2391 where
2392 E: serde::de::Error,
2393 {
2394 match value {
2395 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2396 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2397 }
2398 }
2399 }
2400 deserializer.deserialize_identifier(GeneratedVisitor)
2401 }
2402 }
2403 struct GeneratedVisitor;
2404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2405 type Value = ClusterLimit;
2406
2407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2408 formatter.write_str("struct meta.ClusterLimit")
2409 }
2410
2411 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2412 where
2413 V: serde::de::MapAccess<'de>,
2414 {
2415 let mut limit__ = None;
2416 while let Some(k) = map_.next_key()? {
2417 match k {
2418 GeneratedField::ActorCount => {
2419 if limit__.is_some() {
2420 return Err(serde::de::Error::duplicate_field("actorCount"));
2421 }
2422 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2423;
2424 }
2425 }
2426 }
2427 Ok(ClusterLimit {
2428 limit: limit__,
2429 })
2430 }
2431 }
2432 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2433 }
2434}
2435impl serde::Serialize for DeleteWorkerNodeRequest {
2436 #[allow(deprecated)]
2437 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2438 where
2439 S: serde::Serializer,
2440 {
2441 use serde::ser::SerializeStruct;
2442 let mut len = 0;
2443 if self.host.is_some() {
2444 len += 1;
2445 }
2446 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2447 if let Some(v) = self.host.as_ref() {
2448 struct_ser.serialize_field("host", v)?;
2449 }
2450 struct_ser.end()
2451 }
2452}
2453impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2454 #[allow(deprecated)]
2455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2456 where
2457 D: serde::Deserializer<'de>,
2458 {
2459 const FIELDS: &[&str] = &[
2460 "host",
2461 ];
2462
2463 #[allow(clippy::enum_variant_names)]
2464 enum GeneratedField {
2465 Host,
2466 }
2467 impl<'de> serde::Deserialize<'de> for GeneratedField {
2468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2469 where
2470 D: serde::Deserializer<'de>,
2471 {
2472 struct GeneratedVisitor;
2473
2474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2475 type Value = GeneratedField;
2476
2477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2478 write!(formatter, "expected one of: {:?}", &FIELDS)
2479 }
2480
2481 #[allow(unused_variables)]
2482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2483 where
2484 E: serde::de::Error,
2485 {
2486 match value {
2487 "host" => Ok(GeneratedField::Host),
2488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2489 }
2490 }
2491 }
2492 deserializer.deserialize_identifier(GeneratedVisitor)
2493 }
2494 }
2495 struct GeneratedVisitor;
2496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2497 type Value = DeleteWorkerNodeRequest;
2498
2499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2500 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2501 }
2502
2503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2504 where
2505 V: serde::de::MapAccess<'de>,
2506 {
2507 let mut host__ = None;
2508 while let Some(k) = map_.next_key()? {
2509 match k {
2510 GeneratedField::Host => {
2511 if host__.is_some() {
2512 return Err(serde::de::Error::duplicate_field("host"));
2513 }
2514 host__ = map_.next_value()?;
2515 }
2516 }
2517 }
2518 Ok(DeleteWorkerNodeRequest {
2519 host: host__,
2520 })
2521 }
2522 }
2523 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2524 }
2525}
2526impl serde::Serialize for DeleteWorkerNodeResponse {
2527 #[allow(deprecated)]
2528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2529 where
2530 S: serde::Serializer,
2531 {
2532 use serde::ser::SerializeStruct;
2533 let mut len = 0;
2534 if self.status.is_some() {
2535 len += 1;
2536 }
2537 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2538 if let Some(v) = self.status.as_ref() {
2539 struct_ser.serialize_field("status", v)?;
2540 }
2541 struct_ser.end()
2542 }
2543}
2544impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2545 #[allow(deprecated)]
2546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2547 where
2548 D: serde::Deserializer<'de>,
2549 {
2550 const FIELDS: &[&str] = &[
2551 "status",
2552 ];
2553
2554 #[allow(clippy::enum_variant_names)]
2555 enum GeneratedField {
2556 Status,
2557 }
2558 impl<'de> serde::Deserialize<'de> for GeneratedField {
2559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2560 where
2561 D: serde::Deserializer<'de>,
2562 {
2563 struct GeneratedVisitor;
2564
2565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2566 type Value = GeneratedField;
2567
2568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2569 write!(formatter, "expected one of: {:?}", &FIELDS)
2570 }
2571
2572 #[allow(unused_variables)]
2573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2574 where
2575 E: serde::de::Error,
2576 {
2577 match value {
2578 "status" => Ok(GeneratedField::Status),
2579 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2580 }
2581 }
2582 }
2583 deserializer.deserialize_identifier(GeneratedVisitor)
2584 }
2585 }
2586 struct GeneratedVisitor;
2587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2588 type Value = DeleteWorkerNodeResponse;
2589
2590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2591 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2592 }
2593
2594 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2595 where
2596 V: serde::de::MapAccess<'de>,
2597 {
2598 let mut status__ = None;
2599 while let Some(k) = map_.next_key()? {
2600 match k {
2601 GeneratedField::Status => {
2602 if status__.is_some() {
2603 return Err(serde::de::Error::duplicate_field("status"));
2604 }
2605 status__ = map_.next_value()?;
2606 }
2607 }
2608 }
2609 Ok(DeleteWorkerNodeResponse {
2610 status: status__,
2611 })
2612 }
2613 }
2614 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2615 }
2616}
2617impl serde::Serialize for EventLog {
2618 #[allow(deprecated)]
2619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2620 where
2621 S: serde::Serializer,
2622 {
2623 use serde::ser::SerializeStruct;
2624 let mut len = 0;
2625 if self.unique_id.is_some() {
2626 len += 1;
2627 }
2628 if self.timestamp.is_some() {
2629 len += 1;
2630 }
2631 if self.event.is_some() {
2632 len += 1;
2633 }
2634 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2635 if let Some(v) = self.unique_id.as_ref() {
2636 struct_ser.serialize_field("uniqueId", v)?;
2637 }
2638 if let Some(v) = self.timestamp.as_ref() {
2639 #[allow(clippy::needless_borrow)]
2640 #[allow(clippy::needless_borrows_for_generic_args)]
2641 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2642 }
2643 if let Some(v) = self.event.as_ref() {
2644 match v {
2645 event_log::Event::CreateStreamJobFail(v) => {
2646 struct_ser.serialize_field("createStreamJobFail", v)?;
2647 }
2648 event_log::Event::DirtyStreamJobClear(v) => {
2649 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2650 }
2651 event_log::Event::MetaNodeStart(v) => {
2652 struct_ser.serialize_field("metaNodeStart", v)?;
2653 }
2654 event_log::Event::BarrierComplete(v) => {
2655 struct_ser.serialize_field("barrierComplete", v)?;
2656 }
2657 event_log::Event::InjectBarrierFail(v) => {
2658 struct_ser.serialize_field("injectBarrierFail", v)?;
2659 }
2660 event_log::Event::CollectBarrierFail(v) => {
2661 struct_ser.serialize_field("collectBarrierFail", v)?;
2662 }
2663 event_log::Event::WorkerNodePanic(v) => {
2664 struct_ser.serialize_field("workerNodePanic", v)?;
2665 }
2666 event_log::Event::AutoSchemaChangeFail(v) => {
2667 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2668 }
2669 event_log::Event::SinkFail(v) => {
2670 struct_ser.serialize_field("sinkFail", v)?;
2671 }
2672 event_log::Event::Recovery(v) => {
2673 struct_ser.serialize_field("recovery", v)?;
2674 }
2675 }
2676 }
2677 struct_ser.end()
2678 }
2679}
2680impl<'de> serde::Deserialize<'de> for EventLog {
2681 #[allow(deprecated)]
2682 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2683 where
2684 D: serde::Deserializer<'de>,
2685 {
2686 const FIELDS: &[&str] = &[
2687 "unique_id",
2688 "uniqueId",
2689 "timestamp",
2690 "create_stream_job_fail",
2691 "createStreamJobFail",
2692 "dirty_stream_job_clear",
2693 "dirtyStreamJobClear",
2694 "meta_node_start",
2695 "metaNodeStart",
2696 "barrier_complete",
2697 "barrierComplete",
2698 "inject_barrier_fail",
2699 "injectBarrierFail",
2700 "collect_barrier_fail",
2701 "collectBarrierFail",
2702 "worker_node_panic",
2703 "workerNodePanic",
2704 "auto_schema_change_fail",
2705 "autoSchemaChangeFail",
2706 "sink_fail",
2707 "sinkFail",
2708 "recovery",
2709 ];
2710
2711 #[allow(clippy::enum_variant_names)]
2712 enum GeneratedField {
2713 UniqueId,
2714 Timestamp,
2715 CreateStreamJobFail,
2716 DirtyStreamJobClear,
2717 MetaNodeStart,
2718 BarrierComplete,
2719 InjectBarrierFail,
2720 CollectBarrierFail,
2721 WorkerNodePanic,
2722 AutoSchemaChangeFail,
2723 SinkFail,
2724 Recovery,
2725 }
2726 impl<'de> serde::Deserialize<'de> for GeneratedField {
2727 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2728 where
2729 D: serde::Deserializer<'de>,
2730 {
2731 struct GeneratedVisitor;
2732
2733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2734 type Value = GeneratedField;
2735
2736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2737 write!(formatter, "expected one of: {:?}", &FIELDS)
2738 }
2739
2740 #[allow(unused_variables)]
2741 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2742 where
2743 E: serde::de::Error,
2744 {
2745 match value {
2746 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2747 "timestamp" => Ok(GeneratedField::Timestamp),
2748 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2749 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2750 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2751 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2752 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2753 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2754 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2755 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2756 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2757 "recovery" => Ok(GeneratedField::Recovery),
2758 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2759 }
2760 }
2761 }
2762 deserializer.deserialize_identifier(GeneratedVisitor)
2763 }
2764 }
2765 struct GeneratedVisitor;
2766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2767 type Value = EventLog;
2768
2769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2770 formatter.write_str("struct meta.EventLog")
2771 }
2772
2773 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2774 where
2775 V: serde::de::MapAccess<'de>,
2776 {
2777 let mut unique_id__ = None;
2778 let mut timestamp__ = None;
2779 let mut event__ = None;
2780 while let Some(k) = map_.next_key()? {
2781 match k {
2782 GeneratedField::UniqueId => {
2783 if unique_id__.is_some() {
2784 return Err(serde::de::Error::duplicate_field("uniqueId"));
2785 }
2786 unique_id__ = map_.next_value()?;
2787 }
2788 GeneratedField::Timestamp => {
2789 if timestamp__.is_some() {
2790 return Err(serde::de::Error::duplicate_field("timestamp"));
2791 }
2792 timestamp__ =
2793 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2794 ;
2795 }
2796 GeneratedField::CreateStreamJobFail => {
2797 if event__.is_some() {
2798 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2799 }
2800 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2801;
2802 }
2803 GeneratedField::DirtyStreamJobClear => {
2804 if event__.is_some() {
2805 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2806 }
2807 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2808;
2809 }
2810 GeneratedField::MetaNodeStart => {
2811 if event__.is_some() {
2812 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2813 }
2814 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2815;
2816 }
2817 GeneratedField::BarrierComplete => {
2818 if event__.is_some() {
2819 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2820 }
2821 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2822;
2823 }
2824 GeneratedField::InjectBarrierFail => {
2825 if event__.is_some() {
2826 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2827 }
2828 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2829;
2830 }
2831 GeneratedField::CollectBarrierFail => {
2832 if event__.is_some() {
2833 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2834 }
2835 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2836;
2837 }
2838 GeneratedField::WorkerNodePanic => {
2839 if event__.is_some() {
2840 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2841 }
2842 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2843;
2844 }
2845 GeneratedField::AutoSchemaChangeFail => {
2846 if event__.is_some() {
2847 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2848 }
2849 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2850;
2851 }
2852 GeneratedField::SinkFail => {
2853 if event__.is_some() {
2854 return Err(serde::de::Error::duplicate_field("sinkFail"));
2855 }
2856 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2857;
2858 }
2859 GeneratedField::Recovery => {
2860 if event__.is_some() {
2861 return Err(serde::de::Error::duplicate_field("recovery"));
2862 }
2863 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2864;
2865 }
2866 }
2867 }
2868 Ok(EventLog {
2869 unique_id: unique_id__,
2870 timestamp: timestamp__,
2871 event: event__,
2872 })
2873 }
2874 }
2875 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2876 }
2877}
2878impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2879 #[allow(deprecated)]
2880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2881 where
2882 S: serde::Serializer,
2883 {
2884 use serde::ser::SerializeStruct;
2885 let mut len = 0;
2886 if self.table_id != 0 {
2887 len += 1;
2888 }
2889 if !self.table_name.is_empty() {
2890 len += 1;
2891 }
2892 if !self.cdc_table_id.is_empty() {
2893 len += 1;
2894 }
2895 if !self.upstream_ddl.is_empty() {
2896 len += 1;
2897 }
2898 if !self.fail_info.is_empty() {
2899 len += 1;
2900 }
2901 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2902 if self.table_id != 0 {
2903 struct_ser.serialize_field("tableId", &self.table_id)?;
2904 }
2905 if !self.table_name.is_empty() {
2906 struct_ser.serialize_field("tableName", &self.table_name)?;
2907 }
2908 if !self.cdc_table_id.is_empty() {
2909 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2910 }
2911 if !self.upstream_ddl.is_empty() {
2912 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2913 }
2914 if !self.fail_info.is_empty() {
2915 struct_ser.serialize_field("failInfo", &self.fail_info)?;
2916 }
2917 struct_ser.end()
2918 }
2919}
2920impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2921 #[allow(deprecated)]
2922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2923 where
2924 D: serde::Deserializer<'de>,
2925 {
2926 const FIELDS: &[&str] = &[
2927 "table_id",
2928 "tableId",
2929 "table_name",
2930 "tableName",
2931 "cdc_table_id",
2932 "cdcTableId",
2933 "upstream_ddl",
2934 "upstreamDdl",
2935 "fail_info",
2936 "failInfo",
2937 ];
2938
2939 #[allow(clippy::enum_variant_names)]
2940 enum GeneratedField {
2941 TableId,
2942 TableName,
2943 CdcTableId,
2944 UpstreamDdl,
2945 FailInfo,
2946 }
2947 impl<'de> serde::Deserialize<'de> for GeneratedField {
2948 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2949 where
2950 D: serde::Deserializer<'de>,
2951 {
2952 struct GeneratedVisitor;
2953
2954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2955 type Value = GeneratedField;
2956
2957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2958 write!(formatter, "expected one of: {:?}", &FIELDS)
2959 }
2960
2961 #[allow(unused_variables)]
2962 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2963 where
2964 E: serde::de::Error,
2965 {
2966 match value {
2967 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2968 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2969 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2970 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2971 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
2972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2973 }
2974 }
2975 }
2976 deserializer.deserialize_identifier(GeneratedVisitor)
2977 }
2978 }
2979 struct GeneratedVisitor;
2980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2981 type Value = event_log::EventAutoSchemaChangeFail;
2982
2983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2984 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2985 }
2986
2987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2988 where
2989 V: serde::de::MapAccess<'de>,
2990 {
2991 let mut table_id__ = None;
2992 let mut table_name__ = None;
2993 let mut cdc_table_id__ = None;
2994 let mut upstream_ddl__ = None;
2995 let mut fail_info__ = None;
2996 while let Some(k) = map_.next_key()? {
2997 match k {
2998 GeneratedField::TableId => {
2999 if table_id__.is_some() {
3000 return Err(serde::de::Error::duplicate_field("tableId"));
3001 }
3002 table_id__ =
3003 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3004 ;
3005 }
3006 GeneratedField::TableName => {
3007 if table_name__.is_some() {
3008 return Err(serde::de::Error::duplicate_field("tableName"));
3009 }
3010 table_name__ = Some(map_.next_value()?);
3011 }
3012 GeneratedField::CdcTableId => {
3013 if cdc_table_id__.is_some() {
3014 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3015 }
3016 cdc_table_id__ = Some(map_.next_value()?);
3017 }
3018 GeneratedField::UpstreamDdl => {
3019 if upstream_ddl__.is_some() {
3020 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3021 }
3022 upstream_ddl__ = Some(map_.next_value()?);
3023 }
3024 GeneratedField::FailInfo => {
3025 if fail_info__.is_some() {
3026 return Err(serde::de::Error::duplicate_field("failInfo"));
3027 }
3028 fail_info__ = Some(map_.next_value()?);
3029 }
3030 }
3031 }
3032 Ok(event_log::EventAutoSchemaChangeFail {
3033 table_id: table_id__.unwrap_or_default(),
3034 table_name: table_name__.unwrap_or_default(),
3035 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3036 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3037 fail_info: fail_info__.unwrap_or_default(),
3038 })
3039 }
3040 }
3041 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3042 }
3043}
3044impl serde::Serialize for event_log::EventBarrierComplete {
3045 #[allow(deprecated)]
3046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3047 where
3048 S: serde::Serializer,
3049 {
3050 use serde::ser::SerializeStruct;
3051 let mut len = 0;
3052 if self.prev_epoch != 0 {
3053 len += 1;
3054 }
3055 if self.cur_epoch != 0 {
3056 len += 1;
3057 }
3058 if self.duration_sec != 0. {
3059 len += 1;
3060 }
3061 if !self.command.is_empty() {
3062 len += 1;
3063 }
3064 if !self.barrier_kind.is_empty() {
3065 len += 1;
3066 }
3067 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3068 if self.prev_epoch != 0 {
3069 #[allow(clippy::needless_borrow)]
3070 #[allow(clippy::needless_borrows_for_generic_args)]
3071 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3072 }
3073 if self.cur_epoch != 0 {
3074 #[allow(clippy::needless_borrow)]
3075 #[allow(clippy::needless_borrows_for_generic_args)]
3076 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3077 }
3078 if self.duration_sec != 0. {
3079 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3080 }
3081 if !self.command.is_empty() {
3082 struct_ser.serialize_field("command", &self.command)?;
3083 }
3084 if !self.barrier_kind.is_empty() {
3085 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3086 }
3087 struct_ser.end()
3088 }
3089}
3090impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3091 #[allow(deprecated)]
3092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3093 where
3094 D: serde::Deserializer<'de>,
3095 {
3096 const FIELDS: &[&str] = &[
3097 "prev_epoch",
3098 "prevEpoch",
3099 "cur_epoch",
3100 "curEpoch",
3101 "duration_sec",
3102 "durationSec",
3103 "command",
3104 "barrier_kind",
3105 "barrierKind",
3106 ];
3107
3108 #[allow(clippy::enum_variant_names)]
3109 enum GeneratedField {
3110 PrevEpoch,
3111 CurEpoch,
3112 DurationSec,
3113 Command,
3114 BarrierKind,
3115 }
3116 impl<'de> serde::Deserialize<'de> for GeneratedField {
3117 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3118 where
3119 D: serde::Deserializer<'de>,
3120 {
3121 struct GeneratedVisitor;
3122
3123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3124 type Value = GeneratedField;
3125
3126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3127 write!(formatter, "expected one of: {:?}", &FIELDS)
3128 }
3129
3130 #[allow(unused_variables)]
3131 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3132 where
3133 E: serde::de::Error,
3134 {
3135 match value {
3136 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3137 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3138 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3139 "command" => Ok(GeneratedField::Command),
3140 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3142 }
3143 }
3144 }
3145 deserializer.deserialize_identifier(GeneratedVisitor)
3146 }
3147 }
3148 struct GeneratedVisitor;
3149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3150 type Value = event_log::EventBarrierComplete;
3151
3152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3153 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3154 }
3155
3156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3157 where
3158 V: serde::de::MapAccess<'de>,
3159 {
3160 let mut prev_epoch__ = None;
3161 let mut cur_epoch__ = None;
3162 let mut duration_sec__ = None;
3163 let mut command__ = None;
3164 let mut barrier_kind__ = None;
3165 while let Some(k) = map_.next_key()? {
3166 match k {
3167 GeneratedField::PrevEpoch => {
3168 if prev_epoch__.is_some() {
3169 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3170 }
3171 prev_epoch__ =
3172 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3173 ;
3174 }
3175 GeneratedField::CurEpoch => {
3176 if cur_epoch__.is_some() {
3177 return Err(serde::de::Error::duplicate_field("curEpoch"));
3178 }
3179 cur_epoch__ =
3180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3181 ;
3182 }
3183 GeneratedField::DurationSec => {
3184 if duration_sec__.is_some() {
3185 return Err(serde::de::Error::duplicate_field("durationSec"));
3186 }
3187 duration_sec__ =
3188 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3189 ;
3190 }
3191 GeneratedField::Command => {
3192 if command__.is_some() {
3193 return Err(serde::de::Error::duplicate_field("command"));
3194 }
3195 command__ = Some(map_.next_value()?);
3196 }
3197 GeneratedField::BarrierKind => {
3198 if barrier_kind__.is_some() {
3199 return Err(serde::de::Error::duplicate_field("barrierKind"));
3200 }
3201 barrier_kind__ = Some(map_.next_value()?);
3202 }
3203 }
3204 }
3205 Ok(event_log::EventBarrierComplete {
3206 prev_epoch: prev_epoch__.unwrap_or_default(),
3207 cur_epoch: cur_epoch__.unwrap_or_default(),
3208 duration_sec: duration_sec__.unwrap_or_default(),
3209 command: command__.unwrap_or_default(),
3210 barrier_kind: barrier_kind__.unwrap_or_default(),
3211 })
3212 }
3213 }
3214 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3215 }
3216}
3217impl serde::Serialize for event_log::EventCollectBarrierFail {
3218 #[allow(deprecated)]
3219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3220 where
3221 S: serde::Serializer,
3222 {
3223 use serde::ser::SerializeStruct;
3224 let mut len = 0;
3225 if !self.error.is_empty() {
3226 len += 1;
3227 }
3228 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3229 if !self.error.is_empty() {
3230 struct_ser.serialize_field("error", &self.error)?;
3231 }
3232 struct_ser.end()
3233 }
3234}
3235impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3236 #[allow(deprecated)]
3237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3238 where
3239 D: serde::Deserializer<'de>,
3240 {
3241 const FIELDS: &[&str] = &[
3242 "error",
3243 ];
3244
3245 #[allow(clippy::enum_variant_names)]
3246 enum GeneratedField {
3247 Error,
3248 }
3249 impl<'de> serde::Deserialize<'de> for GeneratedField {
3250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3251 where
3252 D: serde::Deserializer<'de>,
3253 {
3254 struct GeneratedVisitor;
3255
3256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3257 type Value = GeneratedField;
3258
3259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3260 write!(formatter, "expected one of: {:?}", &FIELDS)
3261 }
3262
3263 #[allow(unused_variables)]
3264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3265 where
3266 E: serde::de::Error,
3267 {
3268 match value {
3269 "error" => Ok(GeneratedField::Error),
3270 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3271 }
3272 }
3273 }
3274 deserializer.deserialize_identifier(GeneratedVisitor)
3275 }
3276 }
3277 struct GeneratedVisitor;
3278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3279 type Value = event_log::EventCollectBarrierFail;
3280
3281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3282 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3283 }
3284
3285 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3286 where
3287 V: serde::de::MapAccess<'de>,
3288 {
3289 let mut error__ = None;
3290 while let Some(k) = map_.next_key()? {
3291 match k {
3292 GeneratedField::Error => {
3293 if error__.is_some() {
3294 return Err(serde::de::Error::duplicate_field("error"));
3295 }
3296 error__ = Some(map_.next_value()?);
3297 }
3298 }
3299 }
3300 Ok(event_log::EventCollectBarrierFail {
3301 error: error__.unwrap_or_default(),
3302 })
3303 }
3304 }
3305 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3306 }
3307}
3308impl serde::Serialize for event_log::EventCreateStreamJobFail {
3309 #[allow(deprecated)]
3310 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3311 where
3312 S: serde::Serializer,
3313 {
3314 use serde::ser::SerializeStruct;
3315 let mut len = 0;
3316 if self.id != 0 {
3317 len += 1;
3318 }
3319 if !self.name.is_empty() {
3320 len += 1;
3321 }
3322 if !self.definition.is_empty() {
3323 len += 1;
3324 }
3325 if !self.error.is_empty() {
3326 len += 1;
3327 }
3328 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3329 if self.id != 0 {
3330 struct_ser.serialize_field("id", &self.id)?;
3331 }
3332 if !self.name.is_empty() {
3333 struct_ser.serialize_field("name", &self.name)?;
3334 }
3335 if !self.definition.is_empty() {
3336 struct_ser.serialize_field("definition", &self.definition)?;
3337 }
3338 if !self.error.is_empty() {
3339 struct_ser.serialize_field("error", &self.error)?;
3340 }
3341 struct_ser.end()
3342 }
3343}
3344impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3345 #[allow(deprecated)]
3346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3347 where
3348 D: serde::Deserializer<'de>,
3349 {
3350 const FIELDS: &[&str] = &[
3351 "id",
3352 "name",
3353 "definition",
3354 "error",
3355 ];
3356
3357 #[allow(clippy::enum_variant_names)]
3358 enum GeneratedField {
3359 Id,
3360 Name,
3361 Definition,
3362 Error,
3363 }
3364 impl<'de> serde::Deserialize<'de> for GeneratedField {
3365 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3366 where
3367 D: serde::Deserializer<'de>,
3368 {
3369 struct GeneratedVisitor;
3370
3371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3372 type Value = GeneratedField;
3373
3374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3375 write!(formatter, "expected one of: {:?}", &FIELDS)
3376 }
3377
3378 #[allow(unused_variables)]
3379 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3380 where
3381 E: serde::de::Error,
3382 {
3383 match value {
3384 "id" => Ok(GeneratedField::Id),
3385 "name" => Ok(GeneratedField::Name),
3386 "definition" => Ok(GeneratedField::Definition),
3387 "error" => Ok(GeneratedField::Error),
3388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3389 }
3390 }
3391 }
3392 deserializer.deserialize_identifier(GeneratedVisitor)
3393 }
3394 }
3395 struct GeneratedVisitor;
3396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3397 type Value = event_log::EventCreateStreamJobFail;
3398
3399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3400 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3401 }
3402
3403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3404 where
3405 V: serde::de::MapAccess<'de>,
3406 {
3407 let mut id__ = None;
3408 let mut name__ = None;
3409 let mut definition__ = None;
3410 let mut error__ = None;
3411 while let Some(k) = map_.next_key()? {
3412 match k {
3413 GeneratedField::Id => {
3414 if id__.is_some() {
3415 return Err(serde::de::Error::duplicate_field("id"));
3416 }
3417 id__ =
3418 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3419 ;
3420 }
3421 GeneratedField::Name => {
3422 if name__.is_some() {
3423 return Err(serde::de::Error::duplicate_field("name"));
3424 }
3425 name__ = Some(map_.next_value()?);
3426 }
3427 GeneratedField::Definition => {
3428 if definition__.is_some() {
3429 return Err(serde::de::Error::duplicate_field("definition"));
3430 }
3431 definition__ = Some(map_.next_value()?);
3432 }
3433 GeneratedField::Error => {
3434 if error__.is_some() {
3435 return Err(serde::de::Error::duplicate_field("error"));
3436 }
3437 error__ = Some(map_.next_value()?);
3438 }
3439 }
3440 }
3441 Ok(event_log::EventCreateStreamJobFail {
3442 id: id__.unwrap_or_default(),
3443 name: name__.unwrap_or_default(),
3444 definition: definition__.unwrap_or_default(),
3445 error: error__.unwrap_or_default(),
3446 })
3447 }
3448 }
3449 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3450 }
3451}
3452impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3453 #[allow(deprecated)]
3454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3455 where
3456 S: serde::Serializer,
3457 {
3458 use serde::ser::SerializeStruct;
3459 let mut len = 0;
3460 if self.id != 0 {
3461 len += 1;
3462 }
3463 if !self.name.is_empty() {
3464 len += 1;
3465 }
3466 if !self.definition.is_empty() {
3467 len += 1;
3468 }
3469 if !self.error.is_empty() {
3470 len += 1;
3471 }
3472 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3473 if self.id != 0 {
3474 struct_ser.serialize_field("id", &self.id)?;
3475 }
3476 if !self.name.is_empty() {
3477 struct_ser.serialize_field("name", &self.name)?;
3478 }
3479 if !self.definition.is_empty() {
3480 struct_ser.serialize_field("definition", &self.definition)?;
3481 }
3482 if !self.error.is_empty() {
3483 struct_ser.serialize_field("error", &self.error)?;
3484 }
3485 struct_ser.end()
3486 }
3487}
3488impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3489 #[allow(deprecated)]
3490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3491 where
3492 D: serde::Deserializer<'de>,
3493 {
3494 const FIELDS: &[&str] = &[
3495 "id",
3496 "name",
3497 "definition",
3498 "error",
3499 ];
3500
3501 #[allow(clippy::enum_variant_names)]
3502 enum GeneratedField {
3503 Id,
3504 Name,
3505 Definition,
3506 Error,
3507 }
3508 impl<'de> serde::Deserialize<'de> for GeneratedField {
3509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3510 where
3511 D: serde::Deserializer<'de>,
3512 {
3513 struct GeneratedVisitor;
3514
3515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3516 type Value = GeneratedField;
3517
3518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3519 write!(formatter, "expected one of: {:?}", &FIELDS)
3520 }
3521
3522 #[allow(unused_variables)]
3523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3524 where
3525 E: serde::de::Error,
3526 {
3527 match value {
3528 "id" => Ok(GeneratedField::Id),
3529 "name" => Ok(GeneratedField::Name),
3530 "definition" => Ok(GeneratedField::Definition),
3531 "error" => Ok(GeneratedField::Error),
3532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3533 }
3534 }
3535 }
3536 deserializer.deserialize_identifier(GeneratedVisitor)
3537 }
3538 }
3539 struct GeneratedVisitor;
3540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3541 type Value = event_log::EventDirtyStreamJobClear;
3542
3543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3544 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3545 }
3546
3547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3548 where
3549 V: serde::de::MapAccess<'de>,
3550 {
3551 let mut id__ = None;
3552 let mut name__ = None;
3553 let mut definition__ = None;
3554 let mut error__ = None;
3555 while let Some(k) = map_.next_key()? {
3556 match k {
3557 GeneratedField::Id => {
3558 if id__.is_some() {
3559 return Err(serde::de::Error::duplicate_field("id"));
3560 }
3561 id__ =
3562 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3563 ;
3564 }
3565 GeneratedField::Name => {
3566 if name__.is_some() {
3567 return Err(serde::de::Error::duplicate_field("name"));
3568 }
3569 name__ = Some(map_.next_value()?);
3570 }
3571 GeneratedField::Definition => {
3572 if definition__.is_some() {
3573 return Err(serde::de::Error::duplicate_field("definition"));
3574 }
3575 definition__ = Some(map_.next_value()?);
3576 }
3577 GeneratedField::Error => {
3578 if error__.is_some() {
3579 return Err(serde::de::Error::duplicate_field("error"));
3580 }
3581 error__ = Some(map_.next_value()?);
3582 }
3583 }
3584 }
3585 Ok(event_log::EventDirtyStreamJobClear {
3586 id: id__.unwrap_or_default(),
3587 name: name__.unwrap_or_default(),
3588 definition: definition__.unwrap_or_default(),
3589 error: error__.unwrap_or_default(),
3590 })
3591 }
3592 }
3593 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3594 }
3595}
3596impl serde::Serialize for event_log::EventInjectBarrierFail {
3597 #[allow(deprecated)]
3598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3599 where
3600 S: serde::Serializer,
3601 {
3602 use serde::ser::SerializeStruct;
3603 let mut len = 0;
3604 if self.prev_epoch != 0 {
3605 len += 1;
3606 }
3607 if self.cur_epoch != 0 {
3608 len += 1;
3609 }
3610 if !self.error.is_empty() {
3611 len += 1;
3612 }
3613 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3614 if self.prev_epoch != 0 {
3615 #[allow(clippy::needless_borrow)]
3616 #[allow(clippy::needless_borrows_for_generic_args)]
3617 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3618 }
3619 if self.cur_epoch != 0 {
3620 #[allow(clippy::needless_borrow)]
3621 #[allow(clippy::needless_borrows_for_generic_args)]
3622 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3623 }
3624 if !self.error.is_empty() {
3625 struct_ser.serialize_field("error", &self.error)?;
3626 }
3627 struct_ser.end()
3628 }
3629}
3630impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3631 #[allow(deprecated)]
3632 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3633 where
3634 D: serde::Deserializer<'de>,
3635 {
3636 const FIELDS: &[&str] = &[
3637 "prev_epoch",
3638 "prevEpoch",
3639 "cur_epoch",
3640 "curEpoch",
3641 "error",
3642 ];
3643
3644 #[allow(clippy::enum_variant_names)]
3645 enum GeneratedField {
3646 PrevEpoch,
3647 CurEpoch,
3648 Error,
3649 }
3650 impl<'de> serde::Deserialize<'de> for GeneratedField {
3651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3652 where
3653 D: serde::Deserializer<'de>,
3654 {
3655 struct GeneratedVisitor;
3656
3657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3658 type Value = GeneratedField;
3659
3660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3661 write!(formatter, "expected one of: {:?}", &FIELDS)
3662 }
3663
3664 #[allow(unused_variables)]
3665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3666 where
3667 E: serde::de::Error,
3668 {
3669 match value {
3670 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3671 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3672 "error" => Ok(GeneratedField::Error),
3673 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3674 }
3675 }
3676 }
3677 deserializer.deserialize_identifier(GeneratedVisitor)
3678 }
3679 }
3680 struct GeneratedVisitor;
3681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3682 type Value = event_log::EventInjectBarrierFail;
3683
3684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3685 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3686 }
3687
3688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3689 where
3690 V: serde::de::MapAccess<'de>,
3691 {
3692 let mut prev_epoch__ = None;
3693 let mut cur_epoch__ = None;
3694 let mut error__ = None;
3695 while let Some(k) = map_.next_key()? {
3696 match k {
3697 GeneratedField::PrevEpoch => {
3698 if prev_epoch__.is_some() {
3699 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3700 }
3701 prev_epoch__ =
3702 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3703 ;
3704 }
3705 GeneratedField::CurEpoch => {
3706 if cur_epoch__.is_some() {
3707 return Err(serde::de::Error::duplicate_field("curEpoch"));
3708 }
3709 cur_epoch__ =
3710 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3711 ;
3712 }
3713 GeneratedField::Error => {
3714 if error__.is_some() {
3715 return Err(serde::de::Error::duplicate_field("error"));
3716 }
3717 error__ = Some(map_.next_value()?);
3718 }
3719 }
3720 }
3721 Ok(event_log::EventInjectBarrierFail {
3722 prev_epoch: prev_epoch__.unwrap_or_default(),
3723 cur_epoch: cur_epoch__.unwrap_or_default(),
3724 error: error__.unwrap_or_default(),
3725 })
3726 }
3727 }
3728 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3729 }
3730}
3731impl serde::Serialize for event_log::EventMetaNodeStart {
3732 #[allow(deprecated)]
3733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3734 where
3735 S: serde::Serializer,
3736 {
3737 use serde::ser::SerializeStruct;
3738 let mut len = 0;
3739 if !self.advertise_addr.is_empty() {
3740 len += 1;
3741 }
3742 if !self.listen_addr.is_empty() {
3743 len += 1;
3744 }
3745 if !self.opts.is_empty() {
3746 len += 1;
3747 }
3748 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3749 if !self.advertise_addr.is_empty() {
3750 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3751 }
3752 if !self.listen_addr.is_empty() {
3753 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3754 }
3755 if !self.opts.is_empty() {
3756 struct_ser.serialize_field("opts", &self.opts)?;
3757 }
3758 struct_ser.end()
3759 }
3760}
3761impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3762 #[allow(deprecated)]
3763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3764 where
3765 D: serde::Deserializer<'de>,
3766 {
3767 const FIELDS: &[&str] = &[
3768 "advertise_addr",
3769 "advertiseAddr",
3770 "listen_addr",
3771 "listenAddr",
3772 "opts",
3773 ];
3774
3775 #[allow(clippy::enum_variant_names)]
3776 enum GeneratedField {
3777 AdvertiseAddr,
3778 ListenAddr,
3779 Opts,
3780 }
3781 impl<'de> serde::Deserialize<'de> for GeneratedField {
3782 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3783 where
3784 D: serde::Deserializer<'de>,
3785 {
3786 struct GeneratedVisitor;
3787
3788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3789 type Value = GeneratedField;
3790
3791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3792 write!(formatter, "expected one of: {:?}", &FIELDS)
3793 }
3794
3795 #[allow(unused_variables)]
3796 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3797 where
3798 E: serde::de::Error,
3799 {
3800 match value {
3801 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3802 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3803 "opts" => Ok(GeneratedField::Opts),
3804 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3805 }
3806 }
3807 }
3808 deserializer.deserialize_identifier(GeneratedVisitor)
3809 }
3810 }
3811 struct GeneratedVisitor;
3812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3813 type Value = event_log::EventMetaNodeStart;
3814
3815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3816 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3817 }
3818
3819 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3820 where
3821 V: serde::de::MapAccess<'de>,
3822 {
3823 let mut advertise_addr__ = None;
3824 let mut listen_addr__ = None;
3825 let mut opts__ = None;
3826 while let Some(k) = map_.next_key()? {
3827 match k {
3828 GeneratedField::AdvertiseAddr => {
3829 if advertise_addr__.is_some() {
3830 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3831 }
3832 advertise_addr__ = Some(map_.next_value()?);
3833 }
3834 GeneratedField::ListenAddr => {
3835 if listen_addr__.is_some() {
3836 return Err(serde::de::Error::duplicate_field("listenAddr"));
3837 }
3838 listen_addr__ = Some(map_.next_value()?);
3839 }
3840 GeneratedField::Opts => {
3841 if opts__.is_some() {
3842 return Err(serde::de::Error::duplicate_field("opts"));
3843 }
3844 opts__ = Some(map_.next_value()?);
3845 }
3846 }
3847 }
3848 Ok(event_log::EventMetaNodeStart {
3849 advertise_addr: advertise_addr__.unwrap_or_default(),
3850 listen_addr: listen_addr__.unwrap_or_default(),
3851 opts: opts__.unwrap_or_default(),
3852 })
3853 }
3854 }
3855 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3856 }
3857}
3858impl serde::Serialize for event_log::EventRecovery {
3859 #[allow(deprecated)]
3860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3861 where
3862 S: serde::Serializer,
3863 {
3864 use serde::ser::SerializeStruct;
3865 let mut len = 0;
3866 if self.recovery_event.is_some() {
3867 len += 1;
3868 }
3869 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3870 if let Some(v) = self.recovery_event.as_ref() {
3871 match v {
3872 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3873 struct_ser.serialize_field("globalStart", v)?;
3874 }
3875 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3876 struct_ser.serialize_field("globalSuccess", v)?;
3877 }
3878 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3879 struct_ser.serialize_field("globalFailure", v)?;
3880 }
3881 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3882 struct_ser.serialize_field("databaseStart", v)?;
3883 }
3884 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3885 struct_ser.serialize_field("databaseFailure", v)?;
3886 }
3887 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3888 struct_ser.serialize_field("databaseSuccess", v)?;
3889 }
3890 }
3891 }
3892 struct_ser.end()
3893 }
3894}
3895impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3896 #[allow(deprecated)]
3897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3898 where
3899 D: serde::Deserializer<'de>,
3900 {
3901 const FIELDS: &[&str] = &[
3902 "global_start",
3903 "globalStart",
3904 "global_success",
3905 "globalSuccess",
3906 "global_failure",
3907 "globalFailure",
3908 "database_start",
3909 "databaseStart",
3910 "database_failure",
3911 "databaseFailure",
3912 "database_success",
3913 "databaseSuccess",
3914 ];
3915
3916 #[allow(clippy::enum_variant_names)]
3917 enum GeneratedField {
3918 GlobalStart,
3919 GlobalSuccess,
3920 GlobalFailure,
3921 DatabaseStart,
3922 DatabaseFailure,
3923 DatabaseSuccess,
3924 }
3925 impl<'de> serde::Deserialize<'de> for GeneratedField {
3926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3927 where
3928 D: serde::Deserializer<'de>,
3929 {
3930 struct GeneratedVisitor;
3931
3932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3933 type Value = GeneratedField;
3934
3935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3936 write!(formatter, "expected one of: {:?}", &FIELDS)
3937 }
3938
3939 #[allow(unused_variables)]
3940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3941 where
3942 E: serde::de::Error,
3943 {
3944 match value {
3945 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3946 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3947 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3948 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3949 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3950 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3952 }
3953 }
3954 }
3955 deserializer.deserialize_identifier(GeneratedVisitor)
3956 }
3957 }
3958 struct GeneratedVisitor;
3959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3960 type Value = event_log::EventRecovery;
3961
3962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3963 formatter.write_str("struct meta.EventLog.EventRecovery")
3964 }
3965
3966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3967 where
3968 V: serde::de::MapAccess<'de>,
3969 {
3970 let mut recovery_event__ = None;
3971 while let Some(k) = map_.next_key()? {
3972 match k {
3973 GeneratedField::GlobalStart => {
3974 if recovery_event__.is_some() {
3975 return Err(serde::de::Error::duplicate_field("globalStart"));
3976 }
3977 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3978;
3979 }
3980 GeneratedField::GlobalSuccess => {
3981 if recovery_event__.is_some() {
3982 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3983 }
3984 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3985;
3986 }
3987 GeneratedField::GlobalFailure => {
3988 if recovery_event__.is_some() {
3989 return Err(serde::de::Error::duplicate_field("globalFailure"));
3990 }
3991 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3992;
3993 }
3994 GeneratedField::DatabaseStart => {
3995 if recovery_event__.is_some() {
3996 return Err(serde::de::Error::duplicate_field("databaseStart"));
3997 }
3998 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3999;
4000 }
4001 GeneratedField::DatabaseFailure => {
4002 if recovery_event__.is_some() {
4003 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4004 }
4005 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4006;
4007 }
4008 GeneratedField::DatabaseSuccess => {
4009 if recovery_event__.is_some() {
4010 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4011 }
4012 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4013;
4014 }
4015 }
4016 }
4017 Ok(event_log::EventRecovery {
4018 recovery_event: recovery_event__,
4019 })
4020 }
4021 }
4022 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4023 }
4024}
4025impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4026 #[allow(deprecated)]
4027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4028 where
4029 S: serde::Serializer,
4030 {
4031 use serde::ser::SerializeStruct;
4032 let mut len = 0;
4033 if self.database_id != 0 {
4034 len += 1;
4035 }
4036 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4037 if self.database_id != 0 {
4038 struct_ser.serialize_field("databaseId", &self.database_id)?;
4039 }
4040 struct_ser.end()
4041 }
4042}
4043impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4044 #[allow(deprecated)]
4045 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4046 where
4047 D: serde::Deserializer<'de>,
4048 {
4049 const FIELDS: &[&str] = &[
4050 "database_id",
4051 "databaseId",
4052 ];
4053
4054 #[allow(clippy::enum_variant_names)]
4055 enum GeneratedField {
4056 DatabaseId,
4057 }
4058 impl<'de> serde::Deserialize<'de> for GeneratedField {
4059 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4060 where
4061 D: serde::Deserializer<'de>,
4062 {
4063 struct GeneratedVisitor;
4064
4065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4066 type Value = GeneratedField;
4067
4068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4069 write!(formatter, "expected one of: {:?}", &FIELDS)
4070 }
4071
4072 #[allow(unused_variables)]
4073 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4074 where
4075 E: serde::de::Error,
4076 {
4077 match value {
4078 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4080 }
4081 }
4082 }
4083 deserializer.deserialize_identifier(GeneratedVisitor)
4084 }
4085 }
4086 struct GeneratedVisitor;
4087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4088 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4089
4090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4091 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4092 }
4093
4094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4095 where
4096 V: serde::de::MapAccess<'de>,
4097 {
4098 let mut database_id__ = None;
4099 while let Some(k) = map_.next_key()? {
4100 match k {
4101 GeneratedField::DatabaseId => {
4102 if database_id__.is_some() {
4103 return Err(serde::de::Error::duplicate_field("databaseId"));
4104 }
4105 database_id__ =
4106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4107 ;
4108 }
4109 }
4110 }
4111 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4112 database_id: database_id__.unwrap_or_default(),
4113 })
4114 }
4115 }
4116 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4117 }
4118}
4119impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4120 #[allow(deprecated)]
4121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4122 where
4123 S: serde::Serializer,
4124 {
4125 use serde::ser::SerializeStruct;
4126 let mut len = 0;
4127 if self.database_id != 0 {
4128 len += 1;
4129 }
4130 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4131 if self.database_id != 0 {
4132 struct_ser.serialize_field("databaseId", &self.database_id)?;
4133 }
4134 struct_ser.end()
4135 }
4136}
4137impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4138 #[allow(deprecated)]
4139 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4140 where
4141 D: serde::Deserializer<'de>,
4142 {
4143 const FIELDS: &[&str] = &[
4144 "database_id",
4145 "databaseId",
4146 ];
4147
4148 #[allow(clippy::enum_variant_names)]
4149 enum GeneratedField {
4150 DatabaseId,
4151 }
4152 impl<'de> serde::Deserialize<'de> for GeneratedField {
4153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4154 where
4155 D: serde::Deserializer<'de>,
4156 {
4157 struct GeneratedVisitor;
4158
4159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4160 type Value = GeneratedField;
4161
4162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4163 write!(formatter, "expected one of: {:?}", &FIELDS)
4164 }
4165
4166 #[allow(unused_variables)]
4167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4168 where
4169 E: serde::de::Error,
4170 {
4171 match value {
4172 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4174 }
4175 }
4176 }
4177 deserializer.deserialize_identifier(GeneratedVisitor)
4178 }
4179 }
4180 struct GeneratedVisitor;
4181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4182 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4183
4184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4185 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4186 }
4187
4188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4189 where
4190 V: serde::de::MapAccess<'de>,
4191 {
4192 let mut database_id__ = None;
4193 while let Some(k) = map_.next_key()? {
4194 match k {
4195 GeneratedField::DatabaseId => {
4196 if database_id__.is_some() {
4197 return Err(serde::de::Error::duplicate_field("databaseId"));
4198 }
4199 database_id__ =
4200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4201 ;
4202 }
4203 }
4204 }
4205 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4206 database_id: database_id__.unwrap_or_default(),
4207 })
4208 }
4209 }
4210 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4211 }
4212}
4213impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4214 #[allow(deprecated)]
4215 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4216 where
4217 S: serde::Serializer,
4218 {
4219 use serde::ser::SerializeStruct;
4220 let mut len = 0;
4221 if self.database_id != 0 {
4222 len += 1;
4223 }
4224 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4225 if self.database_id != 0 {
4226 struct_ser.serialize_field("databaseId", &self.database_id)?;
4227 }
4228 struct_ser.end()
4229 }
4230}
4231impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4232 #[allow(deprecated)]
4233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4234 where
4235 D: serde::Deserializer<'de>,
4236 {
4237 const FIELDS: &[&str] = &[
4238 "database_id",
4239 "databaseId",
4240 ];
4241
4242 #[allow(clippy::enum_variant_names)]
4243 enum GeneratedField {
4244 DatabaseId,
4245 }
4246 impl<'de> serde::Deserialize<'de> for GeneratedField {
4247 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4248 where
4249 D: serde::Deserializer<'de>,
4250 {
4251 struct GeneratedVisitor;
4252
4253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4254 type Value = GeneratedField;
4255
4256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4257 write!(formatter, "expected one of: {:?}", &FIELDS)
4258 }
4259
4260 #[allow(unused_variables)]
4261 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4262 where
4263 E: serde::de::Error,
4264 {
4265 match value {
4266 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4267 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4268 }
4269 }
4270 }
4271 deserializer.deserialize_identifier(GeneratedVisitor)
4272 }
4273 }
4274 struct GeneratedVisitor;
4275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4276 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4277
4278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4279 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4280 }
4281
4282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4283 where
4284 V: serde::de::MapAccess<'de>,
4285 {
4286 let mut database_id__ = None;
4287 while let Some(k) = map_.next_key()? {
4288 match k {
4289 GeneratedField::DatabaseId => {
4290 if database_id__.is_some() {
4291 return Err(serde::de::Error::duplicate_field("databaseId"));
4292 }
4293 database_id__ =
4294 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4295 ;
4296 }
4297 }
4298 }
4299 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4300 database_id: database_id__.unwrap_or_default(),
4301 })
4302 }
4303 }
4304 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4305 }
4306}
4307impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4308 #[allow(deprecated)]
4309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4310 where
4311 S: serde::Serializer,
4312 {
4313 use serde::ser::SerializeStruct;
4314 let mut len = 0;
4315 if !self.reason.is_empty() {
4316 len += 1;
4317 }
4318 if !self.error.is_empty() {
4319 len += 1;
4320 }
4321 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4322 if !self.reason.is_empty() {
4323 struct_ser.serialize_field("reason", &self.reason)?;
4324 }
4325 if !self.error.is_empty() {
4326 struct_ser.serialize_field("error", &self.error)?;
4327 }
4328 struct_ser.end()
4329 }
4330}
4331impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4332 #[allow(deprecated)]
4333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4334 where
4335 D: serde::Deserializer<'de>,
4336 {
4337 const FIELDS: &[&str] = &[
4338 "reason",
4339 "error",
4340 ];
4341
4342 #[allow(clippy::enum_variant_names)]
4343 enum GeneratedField {
4344 Reason,
4345 Error,
4346 }
4347 impl<'de> serde::Deserialize<'de> for GeneratedField {
4348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4349 where
4350 D: serde::Deserializer<'de>,
4351 {
4352 struct GeneratedVisitor;
4353
4354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4355 type Value = GeneratedField;
4356
4357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4358 write!(formatter, "expected one of: {:?}", &FIELDS)
4359 }
4360
4361 #[allow(unused_variables)]
4362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4363 where
4364 E: serde::de::Error,
4365 {
4366 match value {
4367 "reason" => Ok(GeneratedField::Reason),
4368 "error" => Ok(GeneratedField::Error),
4369 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4370 }
4371 }
4372 }
4373 deserializer.deserialize_identifier(GeneratedVisitor)
4374 }
4375 }
4376 struct GeneratedVisitor;
4377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4378 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4379
4380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4381 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4382 }
4383
4384 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4385 where
4386 V: serde::de::MapAccess<'de>,
4387 {
4388 let mut reason__ = None;
4389 let mut error__ = None;
4390 while let Some(k) = map_.next_key()? {
4391 match k {
4392 GeneratedField::Reason => {
4393 if reason__.is_some() {
4394 return Err(serde::de::Error::duplicate_field("reason"));
4395 }
4396 reason__ = Some(map_.next_value()?);
4397 }
4398 GeneratedField::Error => {
4399 if error__.is_some() {
4400 return Err(serde::de::Error::duplicate_field("error"));
4401 }
4402 error__ = Some(map_.next_value()?);
4403 }
4404 }
4405 }
4406 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4407 reason: reason__.unwrap_or_default(),
4408 error: error__.unwrap_or_default(),
4409 })
4410 }
4411 }
4412 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4413 }
4414}
4415impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4416 #[allow(deprecated)]
4417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4418 where
4419 S: serde::Serializer,
4420 {
4421 use serde::ser::SerializeStruct;
4422 let mut len = 0;
4423 if !self.reason.is_empty() {
4424 len += 1;
4425 }
4426 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4427 if !self.reason.is_empty() {
4428 struct_ser.serialize_field("reason", &self.reason)?;
4429 }
4430 struct_ser.end()
4431 }
4432}
4433impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4434 #[allow(deprecated)]
4435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4436 where
4437 D: serde::Deserializer<'de>,
4438 {
4439 const FIELDS: &[&str] = &[
4440 "reason",
4441 ];
4442
4443 #[allow(clippy::enum_variant_names)]
4444 enum GeneratedField {
4445 Reason,
4446 }
4447 impl<'de> serde::Deserialize<'de> for GeneratedField {
4448 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4449 where
4450 D: serde::Deserializer<'de>,
4451 {
4452 struct GeneratedVisitor;
4453
4454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4455 type Value = GeneratedField;
4456
4457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4458 write!(formatter, "expected one of: {:?}", &FIELDS)
4459 }
4460
4461 #[allow(unused_variables)]
4462 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4463 where
4464 E: serde::de::Error,
4465 {
4466 match value {
4467 "reason" => Ok(GeneratedField::Reason),
4468 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4469 }
4470 }
4471 }
4472 deserializer.deserialize_identifier(GeneratedVisitor)
4473 }
4474 }
4475 struct GeneratedVisitor;
4476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4477 type Value = event_log::event_recovery::GlobalRecoveryStart;
4478
4479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4480 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4481 }
4482
4483 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4484 where
4485 V: serde::de::MapAccess<'de>,
4486 {
4487 let mut reason__ = None;
4488 while let Some(k) = map_.next_key()? {
4489 match k {
4490 GeneratedField::Reason => {
4491 if reason__.is_some() {
4492 return Err(serde::de::Error::duplicate_field("reason"));
4493 }
4494 reason__ = Some(map_.next_value()?);
4495 }
4496 }
4497 }
4498 Ok(event_log::event_recovery::GlobalRecoveryStart {
4499 reason: reason__.unwrap_or_default(),
4500 })
4501 }
4502 }
4503 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4504 }
4505}
4506impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4507 #[allow(deprecated)]
4508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4509 where
4510 S: serde::Serializer,
4511 {
4512 use serde::ser::SerializeStruct;
4513 let mut len = 0;
4514 if !self.reason.is_empty() {
4515 len += 1;
4516 }
4517 if self.duration_secs != 0. {
4518 len += 1;
4519 }
4520 if !self.running_database_ids.is_empty() {
4521 len += 1;
4522 }
4523 if !self.recovering_database_ids.is_empty() {
4524 len += 1;
4525 }
4526 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4527 if !self.reason.is_empty() {
4528 struct_ser.serialize_field("reason", &self.reason)?;
4529 }
4530 if self.duration_secs != 0. {
4531 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4532 }
4533 if !self.running_database_ids.is_empty() {
4534 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4535 }
4536 if !self.recovering_database_ids.is_empty() {
4537 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4538 }
4539 struct_ser.end()
4540 }
4541}
4542impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4543 #[allow(deprecated)]
4544 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4545 where
4546 D: serde::Deserializer<'de>,
4547 {
4548 const FIELDS: &[&str] = &[
4549 "reason",
4550 "duration_secs",
4551 "durationSecs",
4552 "running_database_ids",
4553 "runningDatabaseIds",
4554 "recovering_database_ids",
4555 "recoveringDatabaseIds",
4556 ];
4557
4558 #[allow(clippy::enum_variant_names)]
4559 enum GeneratedField {
4560 Reason,
4561 DurationSecs,
4562 RunningDatabaseIds,
4563 RecoveringDatabaseIds,
4564 }
4565 impl<'de> serde::Deserialize<'de> for GeneratedField {
4566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4567 where
4568 D: serde::Deserializer<'de>,
4569 {
4570 struct GeneratedVisitor;
4571
4572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4573 type Value = GeneratedField;
4574
4575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4576 write!(formatter, "expected one of: {:?}", &FIELDS)
4577 }
4578
4579 #[allow(unused_variables)]
4580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4581 where
4582 E: serde::de::Error,
4583 {
4584 match value {
4585 "reason" => Ok(GeneratedField::Reason),
4586 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4587 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4588 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4589 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4590 }
4591 }
4592 }
4593 deserializer.deserialize_identifier(GeneratedVisitor)
4594 }
4595 }
4596 struct GeneratedVisitor;
4597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4598 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4599
4600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4601 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4602 }
4603
4604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4605 where
4606 V: serde::de::MapAccess<'de>,
4607 {
4608 let mut reason__ = None;
4609 let mut duration_secs__ = None;
4610 let mut running_database_ids__ = None;
4611 let mut recovering_database_ids__ = None;
4612 while let Some(k) = map_.next_key()? {
4613 match k {
4614 GeneratedField::Reason => {
4615 if reason__.is_some() {
4616 return Err(serde::de::Error::duplicate_field("reason"));
4617 }
4618 reason__ = Some(map_.next_value()?);
4619 }
4620 GeneratedField::DurationSecs => {
4621 if duration_secs__.is_some() {
4622 return Err(serde::de::Error::duplicate_field("durationSecs"));
4623 }
4624 duration_secs__ =
4625 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4626 ;
4627 }
4628 GeneratedField::RunningDatabaseIds => {
4629 if running_database_ids__.is_some() {
4630 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4631 }
4632 running_database_ids__ =
4633 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4634 .into_iter().map(|x| x.0).collect())
4635 ;
4636 }
4637 GeneratedField::RecoveringDatabaseIds => {
4638 if recovering_database_ids__.is_some() {
4639 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4640 }
4641 recovering_database_ids__ =
4642 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4643 .into_iter().map(|x| x.0).collect())
4644 ;
4645 }
4646 }
4647 }
4648 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4649 reason: reason__.unwrap_or_default(),
4650 duration_secs: duration_secs__.unwrap_or_default(),
4651 running_database_ids: running_database_ids__.unwrap_or_default(),
4652 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4653 })
4654 }
4655 }
4656 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4657 }
4658}
4659impl serde::Serialize for event_log::EventSinkFail {
4660 #[allow(deprecated)]
4661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4662 where
4663 S: serde::Serializer,
4664 {
4665 use serde::ser::SerializeStruct;
4666 let mut len = 0;
4667 if self.sink_id != 0 {
4668 len += 1;
4669 }
4670 if !self.sink_name.is_empty() {
4671 len += 1;
4672 }
4673 if !self.connector.is_empty() {
4674 len += 1;
4675 }
4676 if !self.error.is_empty() {
4677 len += 1;
4678 }
4679 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4680 if self.sink_id != 0 {
4681 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4682 }
4683 if !self.sink_name.is_empty() {
4684 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4685 }
4686 if !self.connector.is_empty() {
4687 struct_ser.serialize_field("connector", &self.connector)?;
4688 }
4689 if !self.error.is_empty() {
4690 struct_ser.serialize_field("error", &self.error)?;
4691 }
4692 struct_ser.end()
4693 }
4694}
4695impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4696 #[allow(deprecated)]
4697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4698 where
4699 D: serde::Deserializer<'de>,
4700 {
4701 const FIELDS: &[&str] = &[
4702 "sink_id",
4703 "sinkId",
4704 "sink_name",
4705 "sinkName",
4706 "connector",
4707 "error",
4708 ];
4709
4710 #[allow(clippy::enum_variant_names)]
4711 enum GeneratedField {
4712 SinkId,
4713 SinkName,
4714 Connector,
4715 Error,
4716 }
4717 impl<'de> serde::Deserialize<'de> for GeneratedField {
4718 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4719 where
4720 D: serde::Deserializer<'de>,
4721 {
4722 struct GeneratedVisitor;
4723
4724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4725 type Value = GeneratedField;
4726
4727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4728 write!(formatter, "expected one of: {:?}", &FIELDS)
4729 }
4730
4731 #[allow(unused_variables)]
4732 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4733 where
4734 E: serde::de::Error,
4735 {
4736 match value {
4737 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4738 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4739 "connector" => Ok(GeneratedField::Connector),
4740 "error" => Ok(GeneratedField::Error),
4741 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4742 }
4743 }
4744 }
4745 deserializer.deserialize_identifier(GeneratedVisitor)
4746 }
4747 }
4748 struct GeneratedVisitor;
4749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4750 type Value = event_log::EventSinkFail;
4751
4752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4753 formatter.write_str("struct meta.EventLog.EventSinkFail")
4754 }
4755
4756 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4757 where
4758 V: serde::de::MapAccess<'de>,
4759 {
4760 let mut sink_id__ = None;
4761 let mut sink_name__ = None;
4762 let mut connector__ = None;
4763 let mut error__ = None;
4764 while let Some(k) = map_.next_key()? {
4765 match k {
4766 GeneratedField::SinkId => {
4767 if sink_id__.is_some() {
4768 return Err(serde::de::Error::duplicate_field("sinkId"));
4769 }
4770 sink_id__ =
4771 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4772 ;
4773 }
4774 GeneratedField::SinkName => {
4775 if sink_name__.is_some() {
4776 return Err(serde::de::Error::duplicate_field("sinkName"));
4777 }
4778 sink_name__ = Some(map_.next_value()?);
4779 }
4780 GeneratedField::Connector => {
4781 if connector__.is_some() {
4782 return Err(serde::de::Error::duplicate_field("connector"));
4783 }
4784 connector__ = Some(map_.next_value()?);
4785 }
4786 GeneratedField::Error => {
4787 if error__.is_some() {
4788 return Err(serde::de::Error::duplicate_field("error"));
4789 }
4790 error__ = Some(map_.next_value()?);
4791 }
4792 }
4793 }
4794 Ok(event_log::EventSinkFail {
4795 sink_id: sink_id__.unwrap_or_default(),
4796 sink_name: sink_name__.unwrap_or_default(),
4797 connector: connector__.unwrap_or_default(),
4798 error: error__.unwrap_or_default(),
4799 })
4800 }
4801 }
4802 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4803 }
4804}
4805impl serde::Serialize for event_log::EventWorkerNodePanic {
4806 #[allow(deprecated)]
4807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4808 where
4809 S: serde::Serializer,
4810 {
4811 use serde::ser::SerializeStruct;
4812 let mut len = 0;
4813 if self.worker_id != 0 {
4814 len += 1;
4815 }
4816 if self.worker_type != 0 {
4817 len += 1;
4818 }
4819 if self.host_addr.is_some() {
4820 len += 1;
4821 }
4822 if !self.panic_info.is_empty() {
4823 len += 1;
4824 }
4825 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4826 if self.worker_id != 0 {
4827 struct_ser.serialize_field("workerId", &self.worker_id)?;
4828 }
4829 if self.worker_type != 0 {
4830 let v = super::common::WorkerType::try_from(self.worker_type)
4831 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4832 struct_ser.serialize_field("workerType", &v)?;
4833 }
4834 if let Some(v) = self.host_addr.as_ref() {
4835 struct_ser.serialize_field("hostAddr", v)?;
4836 }
4837 if !self.panic_info.is_empty() {
4838 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4839 }
4840 struct_ser.end()
4841 }
4842}
4843impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4844 #[allow(deprecated)]
4845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4846 where
4847 D: serde::Deserializer<'de>,
4848 {
4849 const FIELDS: &[&str] = &[
4850 "worker_id",
4851 "workerId",
4852 "worker_type",
4853 "workerType",
4854 "host_addr",
4855 "hostAddr",
4856 "panic_info",
4857 "panicInfo",
4858 ];
4859
4860 #[allow(clippy::enum_variant_names)]
4861 enum GeneratedField {
4862 WorkerId,
4863 WorkerType,
4864 HostAddr,
4865 PanicInfo,
4866 }
4867 impl<'de> serde::Deserialize<'de> for GeneratedField {
4868 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4869 where
4870 D: serde::Deserializer<'de>,
4871 {
4872 struct GeneratedVisitor;
4873
4874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4875 type Value = GeneratedField;
4876
4877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4878 write!(formatter, "expected one of: {:?}", &FIELDS)
4879 }
4880
4881 #[allow(unused_variables)]
4882 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4883 where
4884 E: serde::de::Error,
4885 {
4886 match value {
4887 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4888 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4889 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4890 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4891 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4892 }
4893 }
4894 }
4895 deserializer.deserialize_identifier(GeneratedVisitor)
4896 }
4897 }
4898 struct GeneratedVisitor;
4899 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4900 type Value = event_log::EventWorkerNodePanic;
4901
4902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4903 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4904 }
4905
4906 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4907 where
4908 V: serde::de::MapAccess<'de>,
4909 {
4910 let mut worker_id__ = None;
4911 let mut worker_type__ = None;
4912 let mut host_addr__ = None;
4913 let mut panic_info__ = None;
4914 while let Some(k) = map_.next_key()? {
4915 match k {
4916 GeneratedField::WorkerId => {
4917 if worker_id__.is_some() {
4918 return Err(serde::de::Error::duplicate_field("workerId"));
4919 }
4920 worker_id__ =
4921 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4922 ;
4923 }
4924 GeneratedField::WorkerType => {
4925 if worker_type__.is_some() {
4926 return Err(serde::de::Error::duplicate_field("workerType"));
4927 }
4928 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4929 }
4930 GeneratedField::HostAddr => {
4931 if host_addr__.is_some() {
4932 return Err(serde::de::Error::duplicate_field("hostAddr"));
4933 }
4934 host_addr__ = map_.next_value()?;
4935 }
4936 GeneratedField::PanicInfo => {
4937 if panic_info__.is_some() {
4938 return Err(serde::de::Error::duplicate_field("panicInfo"));
4939 }
4940 panic_info__ = Some(map_.next_value()?);
4941 }
4942 }
4943 }
4944 Ok(event_log::EventWorkerNodePanic {
4945 worker_id: worker_id__.unwrap_or_default(),
4946 worker_type: worker_type__.unwrap_or_default(),
4947 host_addr: host_addr__,
4948 panic_info: panic_info__.unwrap_or_default(),
4949 })
4950 }
4951 }
4952 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4953 }
4954}
4955impl serde::Serialize for FlushRequest {
4956 #[allow(deprecated)]
4957 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4958 where
4959 S: serde::Serializer,
4960 {
4961 use serde::ser::SerializeStruct;
4962 let mut len = 0;
4963 if self.database_id != 0 {
4964 len += 1;
4965 }
4966 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4967 if self.database_id != 0 {
4968 struct_ser.serialize_field("databaseId", &self.database_id)?;
4969 }
4970 struct_ser.end()
4971 }
4972}
4973impl<'de> serde::Deserialize<'de> for FlushRequest {
4974 #[allow(deprecated)]
4975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4976 where
4977 D: serde::Deserializer<'de>,
4978 {
4979 const FIELDS: &[&str] = &[
4980 "database_id",
4981 "databaseId",
4982 ];
4983
4984 #[allow(clippy::enum_variant_names)]
4985 enum GeneratedField {
4986 DatabaseId,
4987 }
4988 impl<'de> serde::Deserialize<'de> for GeneratedField {
4989 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4990 where
4991 D: serde::Deserializer<'de>,
4992 {
4993 struct GeneratedVisitor;
4994
4995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4996 type Value = GeneratedField;
4997
4998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4999 write!(formatter, "expected one of: {:?}", &FIELDS)
5000 }
5001
5002 #[allow(unused_variables)]
5003 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5004 where
5005 E: serde::de::Error,
5006 {
5007 match value {
5008 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5009 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5010 }
5011 }
5012 }
5013 deserializer.deserialize_identifier(GeneratedVisitor)
5014 }
5015 }
5016 struct GeneratedVisitor;
5017 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5018 type Value = FlushRequest;
5019
5020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5021 formatter.write_str("struct meta.FlushRequest")
5022 }
5023
5024 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5025 where
5026 V: serde::de::MapAccess<'de>,
5027 {
5028 let mut database_id__ = None;
5029 while let Some(k) = map_.next_key()? {
5030 match k {
5031 GeneratedField::DatabaseId => {
5032 if database_id__.is_some() {
5033 return Err(serde::de::Error::duplicate_field("databaseId"));
5034 }
5035 database_id__ =
5036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5037 ;
5038 }
5039 }
5040 }
5041 Ok(FlushRequest {
5042 database_id: database_id__.unwrap_or_default(),
5043 })
5044 }
5045 }
5046 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5047 }
5048}
5049impl serde::Serialize for FlushResponse {
5050 #[allow(deprecated)]
5051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5052 where
5053 S: serde::Serializer,
5054 {
5055 use serde::ser::SerializeStruct;
5056 let mut len = 0;
5057 if self.status.is_some() {
5058 len += 1;
5059 }
5060 if self.hummock_version_id != 0 {
5061 len += 1;
5062 }
5063 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5064 if let Some(v) = self.status.as_ref() {
5065 struct_ser.serialize_field("status", v)?;
5066 }
5067 if self.hummock_version_id != 0 {
5068 #[allow(clippy::needless_borrow)]
5069 #[allow(clippy::needless_borrows_for_generic_args)]
5070 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5071 }
5072 struct_ser.end()
5073 }
5074}
5075impl<'de> serde::Deserialize<'de> for FlushResponse {
5076 #[allow(deprecated)]
5077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5078 where
5079 D: serde::Deserializer<'de>,
5080 {
5081 const FIELDS: &[&str] = &[
5082 "status",
5083 "hummock_version_id",
5084 "hummockVersionId",
5085 ];
5086
5087 #[allow(clippy::enum_variant_names)]
5088 enum GeneratedField {
5089 Status,
5090 HummockVersionId,
5091 }
5092 impl<'de> serde::Deserialize<'de> for GeneratedField {
5093 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5094 where
5095 D: serde::Deserializer<'de>,
5096 {
5097 struct GeneratedVisitor;
5098
5099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5100 type Value = GeneratedField;
5101
5102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5103 write!(formatter, "expected one of: {:?}", &FIELDS)
5104 }
5105
5106 #[allow(unused_variables)]
5107 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5108 where
5109 E: serde::de::Error,
5110 {
5111 match value {
5112 "status" => Ok(GeneratedField::Status),
5113 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5114 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5115 }
5116 }
5117 }
5118 deserializer.deserialize_identifier(GeneratedVisitor)
5119 }
5120 }
5121 struct GeneratedVisitor;
5122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5123 type Value = FlushResponse;
5124
5125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5126 formatter.write_str("struct meta.FlushResponse")
5127 }
5128
5129 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5130 where
5131 V: serde::de::MapAccess<'de>,
5132 {
5133 let mut status__ = None;
5134 let mut hummock_version_id__ = None;
5135 while let Some(k) = map_.next_key()? {
5136 match k {
5137 GeneratedField::Status => {
5138 if status__.is_some() {
5139 return Err(serde::de::Error::duplicate_field("status"));
5140 }
5141 status__ = map_.next_value()?;
5142 }
5143 GeneratedField::HummockVersionId => {
5144 if hummock_version_id__.is_some() {
5145 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5146 }
5147 hummock_version_id__ =
5148 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5149 ;
5150 }
5151 }
5152 }
5153 Ok(FlushResponse {
5154 status: status__,
5155 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5156 })
5157 }
5158 }
5159 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5160 }
5161}
5162impl serde::Serialize for FragmentDistribution {
5163 #[allow(deprecated)]
5164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5165 where
5166 S: serde::Serializer,
5167 {
5168 use serde::ser::SerializeStruct;
5169 let mut len = 0;
5170 if self.fragment_id != 0 {
5171 len += 1;
5172 }
5173 if self.table_id != 0 {
5174 len += 1;
5175 }
5176 if self.distribution_type != 0 {
5177 len += 1;
5178 }
5179 if !self.state_table_ids.is_empty() {
5180 len += 1;
5181 }
5182 if !self.upstream_fragment_ids.is_empty() {
5183 len += 1;
5184 }
5185 if self.fragment_type_mask != 0 {
5186 len += 1;
5187 }
5188 if self.parallelism != 0 {
5189 len += 1;
5190 }
5191 if self.vnode_count != 0 {
5192 len += 1;
5193 }
5194 if self.node.is_some() {
5195 len += 1;
5196 }
5197 if !self.parallelism_policy.is_empty() {
5198 len += 1;
5199 }
5200 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5201 if self.fragment_id != 0 {
5202 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5203 }
5204 if self.table_id != 0 {
5205 struct_ser.serialize_field("tableId", &self.table_id)?;
5206 }
5207 if self.distribution_type != 0 {
5208 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5209 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5210 struct_ser.serialize_field("distributionType", &v)?;
5211 }
5212 if !self.state_table_ids.is_empty() {
5213 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5214 }
5215 if !self.upstream_fragment_ids.is_empty() {
5216 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5217 }
5218 if self.fragment_type_mask != 0 {
5219 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5220 }
5221 if self.parallelism != 0 {
5222 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5223 }
5224 if self.vnode_count != 0 {
5225 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5226 }
5227 if let Some(v) = self.node.as_ref() {
5228 struct_ser.serialize_field("node", v)?;
5229 }
5230 if !self.parallelism_policy.is_empty() {
5231 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5232 }
5233 struct_ser.end()
5234 }
5235}
5236impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5237 #[allow(deprecated)]
5238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5239 where
5240 D: serde::Deserializer<'de>,
5241 {
5242 const FIELDS: &[&str] = &[
5243 "fragment_id",
5244 "fragmentId",
5245 "table_id",
5246 "tableId",
5247 "distribution_type",
5248 "distributionType",
5249 "state_table_ids",
5250 "stateTableIds",
5251 "upstream_fragment_ids",
5252 "upstreamFragmentIds",
5253 "fragment_type_mask",
5254 "fragmentTypeMask",
5255 "parallelism",
5256 "vnode_count",
5257 "vnodeCount",
5258 "node",
5259 "parallelism_policy",
5260 "parallelismPolicy",
5261 ];
5262
5263 #[allow(clippy::enum_variant_names)]
5264 enum GeneratedField {
5265 FragmentId,
5266 TableId,
5267 DistributionType,
5268 StateTableIds,
5269 UpstreamFragmentIds,
5270 FragmentTypeMask,
5271 Parallelism,
5272 VnodeCount,
5273 Node,
5274 ParallelismPolicy,
5275 }
5276 impl<'de> serde::Deserialize<'de> for GeneratedField {
5277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5278 where
5279 D: serde::Deserializer<'de>,
5280 {
5281 struct GeneratedVisitor;
5282
5283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5284 type Value = GeneratedField;
5285
5286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5287 write!(formatter, "expected one of: {:?}", &FIELDS)
5288 }
5289
5290 #[allow(unused_variables)]
5291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5292 where
5293 E: serde::de::Error,
5294 {
5295 match value {
5296 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5297 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5298 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5299 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5300 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5301 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5302 "parallelism" => Ok(GeneratedField::Parallelism),
5303 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5304 "node" => Ok(GeneratedField::Node),
5305 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5307 }
5308 }
5309 }
5310 deserializer.deserialize_identifier(GeneratedVisitor)
5311 }
5312 }
5313 struct GeneratedVisitor;
5314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5315 type Value = FragmentDistribution;
5316
5317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5318 formatter.write_str("struct meta.FragmentDistribution")
5319 }
5320
5321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5322 where
5323 V: serde::de::MapAccess<'de>,
5324 {
5325 let mut fragment_id__ = None;
5326 let mut table_id__ = None;
5327 let mut distribution_type__ = None;
5328 let mut state_table_ids__ = None;
5329 let mut upstream_fragment_ids__ = None;
5330 let mut fragment_type_mask__ = None;
5331 let mut parallelism__ = None;
5332 let mut vnode_count__ = None;
5333 let mut node__ = None;
5334 let mut parallelism_policy__ = None;
5335 while let Some(k) = map_.next_key()? {
5336 match k {
5337 GeneratedField::FragmentId => {
5338 if fragment_id__.is_some() {
5339 return Err(serde::de::Error::duplicate_field("fragmentId"));
5340 }
5341 fragment_id__ =
5342 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5343 ;
5344 }
5345 GeneratedField::TableId => {
5346 if table_id__.is_some() {
5347 return Err(serde::de::Error::duplicate_field("tableId"));
5348 }
5349 table_id__ =
5350 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5351 ;
5352 }
5353 GeneratedField::DistributionType => {
5354 if distribution_type__.is_some() {
5355 return Err(serde::de::Error::duplicate_field("distributionType"));
5356 }
5357 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5358 }
5359 GeneratedField::StateTableIds => {
5360 if state_table_ids__.is_some() {
5361 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5362 }
5363 state_table_ids__ =
5364 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5365 .into_iter().map(|x| x.0).collect())
5366 ;
5367 }
5368 GeneratedField::UpstreamFragmentIds => {
5369 if upstream_fragment_ids__.is_some() {
5370 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5371 }
5372 upstream_fragment_ids__ =
5373 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5374 .into_iter().map(|x| x.0).collect())
5375 ;
5376 }
5377 GeneratedField::FragmentTypeMask => {
5378 if fragment_type_mask__.is_some() {
5379 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5380 }
5381 fragment_type_mask__ =
5382 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5383 ;
5384 }
5385 GeneratedField::Parallelism => {
5386 if parallelism__.is_some() {
5387 return Err(serde::de::Error::duplicate_field("parallelism"));
5388 }
5389 parallelism__ =
5390 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5391 ;
5392 }
5393 GeneratedField::VnodeCount => {
5394 if vnode_count__.is_some() {
5395 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5396 }
5397 vnode_count__ =
5398 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5399 ;
5400 }
5401 GeneratedField::Node => {
5402 if node__.is_some() {
5403 return Err(serde::de::Error::duplicate_field("node"));
5404 }
5405 node__ = map_.next_value()?;
5406 }
5407 GeneratedField::ParallelismPolicy => {
5408 if parallelism_policy__.is_some() {
5409 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5410 }
5411 parallelism_policy__ = Some(map_.next_value()?);
5412 }
5413 }
5414 }
5415 Ok(FragmentDistribution {
5416 fragment_id: fragment_id__.unwrap_or_default(),
5417 table_id: table_id__.unwrap_or_default(),
5418 distribution_type: distribution_type__.unwrap_or_default(),
5419 state_table_ids: state_table_ids__.unwrap_or_default(),
5420 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5421 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5422 parallelism: parallelism__.unwrap_or_default(),
5423 vnode_count: vnode_count__.unwrap_or_default(),
5424 node: node__,
5425 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5426 })
5427 }
5428 }
5429 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5430 }
5431}
5432impl serde::Serialize for FragmentIdToActorIdMap {
5433 #[allow(deprecated)]
5434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5435 where
5436 S: serde::Serializer,
5437 {
5438 use serde::ser::SerializeStruct;
5439 let mut len = 0;
5440 if !self.map.is_empty() {
5441 len += 1;
5442 }
5443 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5444 if !self.map.is_empty() {
5445 struct_ser.serialize_field("map", &self.map)?;
5446 }
5447 struct_ser.end()
5448 }
5449}
5450impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5451 #[allow(deprecated)]
5452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5453 where
5454 D: serde::Deserializer<'de>,
5455 {
5456 const FIELDS: &[&str] = &[
5457 "map",
5458 ];
5459
5460 #[allow(clippy::enum_variant_names)]
5461 enum GeneratedField {
5462 Map,
5463 }
5464 impl<'de> serde::Deserialize<'de> for GeneratedField {
5465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5466 where
5467 D: serde::Deserializer<'de>,
5468 {
5469 struct GeneratedVisitor;
5470
5471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5472 type Value = GeneratedField;
5473
5474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5475 write!(formatter, "expected one of: {:?}", &FIELDS)
5476 }
5477
5478 #[allow(unused_variables)]
5479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5480 where
5481 E: serde::de::Error,
5482 {
5483 match value {
5484 "map" => Ok(GeneratedField::Map),
5485 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5486 }
5487 }
5488 }
5489 deserializer.deserialize_identifier(GeneratedVisitor)
5490 }
5491 }
5492 struct GeneratedVisitor;
5493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5494 type Value = FragmentIdToActorIdMap;
5495
5496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5497 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5498 }
5499
5500 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5501 where
5502 V: serde::de::MapAccess<'de>,
5503 {
5504 let mut map__ = None;
5505 while let Some(k) = map_.next_key()? {
5506 match k {
5507 GeneratedField::Map => {
5508 if map__.is_some() {
5509 return Err(serde::de::Error::duplicate_field("map"));
5510 }
5511 map__ = Some(
5512 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5513 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5514 );
5515 }
5516 }
5517 }
5518 Ok(FragmentIdToActorIdMap {
5519 map: map__.unwrap_or_default(),
5520 })
5521 }
5522 }
5523 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5524 }
5525}
5526impl serde::Serialize for FragmentToRelationMap {
5527 #[allow(deprecated)]
5528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5529 where
5530 S: serde::Serializer,
5531 {
5532 use serde::ser::SerializeStruct;
5533 let mut len = 0;
5534 if !self.fragment_to_relation_map.is_empty() {
5535 len += 1;
5536 }
5537 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5538 if !self.fragment_to_relation_map.is_empty() {
5539 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5540 }
5541 struct_ser.end()
5542 }
5543}
5544impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5545 #[allow(deprecated)]
5546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5547 where
5548 D: serde::Deserializer<'de>,
5549 {
5550 const FIELDS: &[&str] = &[
5551 "fragment_to_relation_map",
5552 "fragmentToRelationMap",
5553 ];
5554
5555 #[allow(clippy::enum_variant_names)]
5556 enum GeneratedField {
5557 FragmentToRelationMap,
5558 }
5559 impl<'de> serde::Deserialize<'de> for GeneratedField {
5560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5561 where
5562 D: serde::Deserializer<'de>,
5563 {
5564 struct GeneratedVisitor;
5565
5566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5567 type Value = GeneratedField;
5568
5569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5570 write!(formatter, "expected one of: {:?}", &FIELDS)
5571 }
5572
5573 #[allow(unused_variables)]
5574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5575 where
5576 E: serde::de::Error,
5577 {
5578 match value {
5579 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5581 }
5582 }
5583 }
5584 deserializer.deserialize_identifier(GeneratedVisitor)
5585 }
5586 }
5587 struct GeneratedVisitor;
5588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5589 type Value = FragmentToRelationMap;
5590
5591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5592 formatter.write_str("struct meta.FragmentToRelationMap")
5593 }
5594
5595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5596 where
5597 V: serde::de::MapAccess<'de>,
5598 {
5599 let mut fragment_to_relation_map__ = None;
5600 while let Some(k) = map_.next_key()? {
5601 match k {
5602 GeneratedField::FragmentToRelationMap => {
5603 if fragment_to_relation_map__.is_some() {
5604 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5605 }
5606 fragment_to_relation_map__ = Some(
5607 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5608 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
5609 );
5610 }
5611 }
5612 }
5613 Ok(FragmentToRelationMap {
5614 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5615 })
5616 }
5617 }
5618 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5619 }
5620}
5621impl serde::Serialize for FragmentWorkerSlotMapping {
5622 #[allow(deprecated)]
5623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5624 where
5625 S: serde::Serializer,
5626 {
5627 use serde::ser::SerializeStruct;
5628 let mut len = 0;
5629 if self.fragment_id != 0 {
5630 len += 1;
5631 }
5632 if self.mapping.is_some() {
5633 len += 1;
5634 }
5635 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5636 if self.fragment_id != 0 {
5637 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5638 }
5639 if let Some(v) = self.mapping.as_ref() {
5640 struct_ser.serialize_field("mapping", v)?;
5641 }
5642 struct_ser.end()
5643 }
5644}
5645impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5646 #[allow(deprecated)]
5647 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5648 where
5649 D: serde::Deserializer<'de>,
5650 {
5651 const FIELDS: &[&str] = &[
5652 "fragment_id",
5653 "fragmentId",
5654 "mapping",
5655 ];
5656
5657 #[allow(clippy::enum_variant_names)]
5658 enum GeneratedField {
5659 FragmentId,
5660 Mapping,
5661 }
5662 impl<'de> serde::Deserialize<'de> for GeneratedField {
5663 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5664 where
5665 D: serde::Deserializer<'de>,
5666 {
5667 struct GeneratedVisitor;
5668
5669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5670 type Value = GeneratedField;
5671
5672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5673 write!(formatter, "expected one of: {:?}", &FIELDS)
5674 }
5675
5676 #[allow(unused_variables)]
5677 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5678 where
5679 E: serde::de::Error,
5680 {
5681 match value {
5682 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5683 "mapping" => Ok(GeneratedField::Mapping),
5684 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5685 }
5686 }
5687 }
5688 deserializer.deserialize_identifier(GeneratedVisitor)
5689 }
5690 }
5691 struct GeneratedVisitor;
5692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5693 type Value = FragmentWorkerSlotMapping;
5694
5695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5696 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5697 }
5698
5699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5700 where
5701 V: serde::de::MapAccess<'de>,
5702 {
5703 let mut fragment_id__ = None;
5704 let mut mapping__ = None;
5705 while let Some(k) = map_.next_key()? {
5706 match k {
5707 GeneratedField::FragmentId => {
5708 if fragment_id__.is_some() {
5709 return Err(serde::de::Error::duplicate_field("fragmentId"));
5710 }
5711 fragment_id__ =
5712 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5713 ;
5714 }
5715 GeneratedField::Mapping => {
5716 if mapping__.is_some() {
5717 return Err(serde::de::Error::duplicate_field("mapping"));
5718 }
5719 mapping__ = map_.next_value()?;
5720 }
5721 }
5722 }
5723 Ok(FragmentWorkerSlotMapping {
5724 fragment_id: fragment_id__.unwrap_or_default(),
5725 mapping: mapping__,
5726 })
5727 }
5728 }
5729 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5730 }
5731}
5732impl serde::Serialize for FragmentWorkerSlotMappings {
5733 #[allow(deprecated)]
5734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5735 where
5736 S: serde::Serializer,
5737 {
5738 use serde::ser::SerializeStruct;
5739 let mut len = 0;
5740 if !self.mappings.is_empty() {
5741 len += 1;
5742 }
5743 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5744 if !self.mappings.is_empty() {
5745 struct_ser.serialize_field("mappings", &self.mappings)?;
5746 }
5747 struct_ser.end()
5748 }
5749}
5750impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5751 #[allow(deprecated)]
5752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5753 where
5754 D: serde::Deserializer<'de>,
5755 {
5756 const FIELDS: &[&str] = &[
5757 "mappings",
5758 ];
5759
5760 #[allow(clippy::enum_variant_names)]
5761 enum GeneratedField {
5762 Mappings,
5763 }
5764 impl<'de> serde::Deserialize<'de> for GeneratedField {
5765 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5766 where
5767 D: serde::Deserializer<'de>,
5768 {
5769 struct GeneratedVisitor;
5770
5771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5772 type Value = GeneratedField;
5773
5774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5775 write!(formatter, "expected one of: {:?}", &FIELDS)
5776 }
5777
5778 #[allow(unused_variables)]
5779 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5780 where
5781 E: serde::de::Error,
5782 {
5783 match value {
5784 "mappings" => Ok(GeneratedField::Mappings),
5785 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5786 }
5787 }
5788 }
5789 deserializer.deserialize_identifier(GeneratedVisitor)
5790 }
5791 }
5792 struct GeneratedVisitor;
5793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5794 type Value = FragmentWorkerSlotMappings;
5795
5796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5797 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5798 }
5799
5800 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5801 where
5802 V: serde::de::MapAccess<'de>,
5803 {
5804 let mut mappings__ = None;
5805 while let Some(k) = map_.next_key()? {
5806 match k {
5807 GeneratedField::Mappings => {
5808 if mappings__.is_some() {
5809 return Err(serde::de::Error::duplicate_field("mappings"));
5810 }
5811 mappings__ = Some(map_.next_value()?);
5812 }
5813 }
5814 }
5815 Ok(FragmentWorkerSlotMappings {
5816 mappings: mappings__.unwrap_or_default(),
5817 })
5818 }
5819 }
5820 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5821 }
5822}
5823impl serde::Serialize for GetActorVnodesRequest {
5824 #[allow(deprecated)]
5825 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5826 where
5827 S: serde::Serializer,
5828 {
5829 use serde::ser::SerializeStruct;
5830 let mut len = 0;
5831 if self.actor_id != 0 {
5832 len += 1;
5833 }
5834 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesRequest", len)?;
5835 if self.actor_id != 0 {
5836 struct_ser.serialize_field("actorId", &self.actor_id)?;
5837 }
5838 struct_ser.end()
5839 }
5840}
5841impl<'de> serde::Deserialize<'de> for GetActorVnodesRequest {
5842 #[allow(deprecated)]
5843 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5844 where
5845 D: serde::Deserializer<'de>,
5846 {
5847 const FIELDS: &[&str] = &[
5848 "actor_id",
5849 "actorId",
5850 ];
5851
5852 #[allow(clippy::enum_variant_names)]
5853 enum GeneratedField {
5854 ActorId,
5855 }
5856 impl<'de> serde::Deserialize<'de> for GeneratedField {
5857 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5858 where
5859 D: serde::Deserializer<'de>,
5860 {
5861 struct GeneratedVisitor;
5862
5863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5864 type Value = GeneratedField;
5865
5866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5867 write!(formatter, "expected one of: {:?}", &FIELDS)
5868 }
5869
5870 #[allow(unused_variables)]
5871 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5872 where
5873 E: serde::de::Error,
5874 {
5875 match value {
5876 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
5877 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5878 }
5879 }
5880 }
5881 deserializer.deserialize_identifier(GeneratedVisitor)
5882 }
5883 }
5884 struct GeneratedVisitor;
5885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5886 type Value = GetActorVnodesRequest;
5887
5888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5889 formatter.write_str("struct meta.GetActorVnodesRequest")
5890 }
5891
5892 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesRequest, V::Error>
5893 where
5894 V: serde::de::MapAccess<'de>,
5895 {
5896 let mut actor_id__ = None;
5897 while let Some(k) = map_.next_key()? {
5898 match k {
5899 GeneratedField::ActorId => {
5900 if actor_id__.is_some() {
5901 return Err(serde::de::Error::duplicate_field("actorId"));
5902 }
5903 actor_id__ =
5904 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5905 ;
5906 }
5907 }
5908 }
5909 Ok(GetActorVnodesRequest {
5910 actor_id: actor_id__.unwrap_or_default(),
5911 })
5912 }
5913 }
5914 deserializer.deserialize_struct("meta.GetActorVnodesRequest", FIELDS, GeneratedVisitor)
5915 }
5916}
5917impl serde::Serialize for GetActorVnodesResponse {
5918 #[allow(deprecated)]
5919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5920 where
5921 S: serde::Serializer,
5922 {
5923 use serde::ser::SerializeStruct;
5924 let mut len = 0;
5925 if !self.vnode_indices.is_empty() {
5926 len += 1;
5927 }
5928 let mut struct_ser = serializer.serialize_struct("meta.GetActorVnodesResponse", len)?;
5929 if !self.vnode_indices.is_empty() {
5930 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
5931 }
5932 struct_ser.end()
5933 }
5934}
5935impl<'de> serde::Deserialize<'de> for GetActorVnodesResponse {
5936 #[allow(deprecated)]
5937 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5938 where
5939 D: serde::Deserializer<'de>,
5940 {
5941 const FIELDS: &[&str] = &[
5942 "vnode_indices",
5943 "vnodeIndices",
5944 ];
5945
5946 #[allow(clippy::enum_variant_names)]
5947 enum GeneratedField {
5948 VnodeIndices,
5949 }
5950 impl<'de> serde::Deserialize<'de> for GeneratedField {
5951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5952 where
5953 D: serde::Deserializer<'de>,
5954 {
5955 struct GeneratedVisitor;
5956
5957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5958 type Value = GeneratedField;
5959
5960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5961 write!(formatter, "expected one of: {:?}", &FIELDS)
5962 }
5963
5964 #[allow(unused_variables)]
5965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5966 where
5967 E: serde::de::Error,
5968 {
5969 match value {
5970 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
5971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5972 }
5973 }
5974 }
5975 deserializer.deserialize_identifier(GeneratedVisitor)
5976 }
5977 }
5978 struct GeneratedVisitor;
5979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5980 type Value = GetActorVnodesResponse;
5981
5982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5983 formatter.write_str("struct meta.GetActorVnodesResponse")
5984 }
5985
5986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetActorVnodesResponse, V::Error>
5987 where
5988 V: serde::de::MapAccess<'de>,
5989 {
5990 let mut vnode_indices__ = None;
5991 while let Some(k) = map_.next_key()? {
5992 match k {
5993 GeneratedField::VnodeIndices => {
5994 if vnode_indices__.is_some() {
5995 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
5996 }
5997 vnode_indices__ =
5998 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5999 .into_iter().map(|x| x.0).collect())
6000 ;
6001 }
6002 }
6003 }
6004 Ok(GetActorVnodesResponse {
6005 vnode_indices: vnode_indices__.unwrap_or_default(),
6006 })
6007 }
6008 }
6009 deserializer.deserialize_struct("meta.GetActorVnodesResponse", FIELDS, GeneratedVisitor)
6010 }
6011}
6012impl serde::Serialize for GetClusterInfoRequest {
6013 #[allow(deprecated)]
6014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6015 where
6016 S: serde::Serializer,
6017 {
6018 use serde::ser::SerializeStruct;
6019 let len = 0;
6020 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
6021 struct_ser.end()
6022 }
6023}
6024impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
6025 #[allow(deprecated)]
6026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6027 where
6028 D: serde::Deserializer<'de>,
6029 {
6030 const FIELDS: &[&str] = &[
6031 ];
6032
6033 #[allow(clippy::enum_variant_names)]
6034 enum GeneratedField {
6035 }
6036 impl<'de> serde::Deserialize<'de> for GeneratedField {
6037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6038 where
6039 D: serde::Deserializer<'de>,
6040 {
6041 struct GeneratedVisitor;
6042
6043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6044 type Value = GeneratedField;
6045
6046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6047 write!(formatter, "expected one of: {:?}", &FIELDS)
6048 }
6049
6050 #[allow(unused_variables)]
6051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6052 where
6053 E: serde::de::Error,
6054 {
6055 Err(serde::de::Error::unknown_field(value, FIELDS))
6056 }
6057 }
6058 deserializer.deserialize_identifier(GeneratedVisitor)
6059 }
6060 }
6061 struct GeneratedVisitor;
6062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6063 type Value = GetClusterInfoRequest;
6064
6065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6066 formatter.write_str("struct meta.GetClusterInfoRequest")
6067 }
6068
6069 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
6070 where
6071 V: serde::de::MapAccess<'de>,
6072 {
6073 while map_.next_key::<GeneratedField>()?.is_some() {
6074 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6075 }
6076 Ok(GetClusterInfoRequest {
6077 })
6078 }
6079 }
6080 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
6081 }
6082}
6083impl serde::Serialize for GetClusterInfoResponse {
6084 #[allow(deprecated)]
6085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6086 where
6087 S: serde::Serializer,
6088 {
6089 use serde::ser::SerializeStruct;
6090 let mut len = 0;
6091 if !self.worker_nodes.is_empty() {
6092 len += 1;
6093 }
6094 if !self.table_fragments.is_empty() {
6095 len += 1;
6096 }
6097 if !self.actor_splits.is_empty() {
6098 len += 1;
6099 }
6100 if !self.source_infos.is_empty() {
6101 len += 1;
6102 }
6103 if self.revision != 0 {
6104 len += 1;
6105 }
6106 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
6107 if !self.worker_nodes.is_empty() {
6108 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
6109 }
6110 if !self.table_fragments.is_empty() {
6111 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
6112 }
6113 if !self.actor_splits.is_empty() {
6114 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
6115 }
6116 if !self.source_infos.is_empty() {
6117 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
6118 }
6119 if self.revision != 0 {
6120 #[allow(clippy::needless_borrow)]
6121 #[allow(clippy::needless_borrows_for_generic_args)]
6122 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
6123 }
6124 struct_ser.end()
6125 }
6126}
6127impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
6128 #[allow(deprecated)]
6129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6130 where
6131 D: serde::Deserializer<'de>,
6132 {
6133 const FIELDS: &[&str] = &[
6134 "worker_nodes",
6135 "workerNodes",
6136 "table_fragments",
6137 "tableFragments",
6138 "actor_splits",
6139 "actorSplits",
6140 "source_infos",
6141 "sourceInfos",
6142 "revision",
6143 ];
6144
6145 #[allow(clippy::enum_variant_names)]
6146 enum GeneratedField {
6147 WorkerNodes,
6148 TableFragments,
6149 ActorSplits,
6150 SourceInfos,
6151 Revision,
6152 }
6153 impl<'de> serde::Deserialize<'de> for GeneratedField {
6154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6155 where
6156 D: serde::Deserializer<'de>,
6157 {
6158 struct GeneratedVisitor;
6159
6160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6161 type Value = GeneratedField;
6162
6163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6164 write!(formatter, "expected one of: {:?}", &FIELDS)
6165 }
6166
6167 #[allow(unused_variables)]
6168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6169 where
6170 E: serde::de::Error,
6171 {
6172 match value {
6173 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
6174 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
6175 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
6176 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
6177 "revision" => Ok(GeneratedField::Revision),
6178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6179 }
6180 }
6181 }
6182 deserializer.deserialize_identifier(GeneratedVisitor)
6183 }
6184 }
6185 struct GeneratedVisitor;
6186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6187 type Value = GetClusterInfoResponse;
6188
6189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6190 formatter.write_str("struct meta.GetClusterInfoResponse")
6191 }
6192
6193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6194 where
6195 V: serde::de::MapAccess<'de>,
6196 {
6197 let mut worker_nodes__ = None;
6198 let mut table_fragments__ = None;
6199 let mut actor_splits__ = None;
6200 let mut source_infos__ = None;
6201 let mut revision__ = None;
6202 while let Some(k) = map_.next_key()? {
6203 match k {
6204 GeneratedField::WorkerNodes => {
6205 if worker_nodes__.is_some() {
6206 return Err(serde::de::Error::duplicate_field("workerNodes"));
6207 }
6208 worker_nodes__ = Some(map_.next_value()?);
6209 }
6210 GeneratedField::TableFragments => {
6211 if table_fragments__.is_some() {
6212 return Err(serde::de::Error::duplicate_field("tableFragments"));
6213 }
6214 table_fragments__ = Some(map_.next_value()?);
6215 }
6216 GeneratedField::ActorSplits => {
6217 if actor_splits__.is_some() {
6218 return Err(serde::de::Error::duplicate_field("actorSplits"));
6219 }
6220 actor_splits__ = Some(
6221 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6222 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6223 );
6224 }
6225 GeneratedField::SourceInfos => {
6226 if source_infos__.is_some() {
6227 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6228 }
6229 source_infos__ = Some(
6230 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6231 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6232 );
6233 }
6234 GeneratedField::Revision => {
6235 if revision__.is_some() {
6236 return Err(serde::de::Error::duplicate_field("revision"));
6237 }
6238 revision__ =
6239 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6240 ;
6241 }
6242 }
6243 }
6244 Ok(GetClusterInfoResponse {
6245 worker_nodes: worker_nodes__.unwrap_or_default(),
6246 table_fragments: table_fragments__.unwrap_or_default(),
6247 actor_splits: actor_splits__.unwrap_or_default(),
6248 source_infos: source_infos__.unwrap_or_default(),
6249 revision: revision__.unwrap_or_default(),
6250 })
6251 }
6252 }
6253 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6254 }
6255}
6256impl serde::Serialize for GetClusterLimitsRequest {
6257 #[allow(deprecated)]
6258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6259 where
6260 S: serde::Serializer,
6261 {
6262 use serde::ser::SerializeStruct;
6263 let len = 0;
6264 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6265 struct_ser.end()
6266 }
6267}
6268impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6269 #[allow(deprecated)]
6270 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6271 where
6272 D: serde::Deserializer<'de>,
6273 {
6274 const FIELDS: &[&str] = &[
6275 ];
6276
6277 #[allow(clippy::enum_variant_names)]
6278 enum GeneratedField {
6279 }
6280 impl<'de> serde::Deserialize<'de> for GeneratedField {
6281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6282 where
6283 D: serde::Deserializer<'de>,
6284 {
6285 struct GeneratedVisitor;
6286
6287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6288 type Value = GeneratedField;
6289
6290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6291 write!(formatter, "expected one of: {:?}", &FIELDS)
6292 }
6293
6294 #[allow(unused_variables)]
6295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6296 where
6297 E: serde::de::Error,
6298 {
6299 Err(serde::de::Error::unknown_field(value, FIELDS))
6300 }
6301 }
6302 deserializer.deserialize_identifier(GeneratedVisitor)
6303 }
6304 }
6305 struct GeneratedVisitor;
6306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6307 type Value = GetClusterLimitsRequest;
6308
6309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6310 formatter.write_str("struct meta.GetClusterLimitsRequest")
6311 }
6312
6313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6314 where
6315 V: serde::de::MapAccess<'de>,
6316 {
6317 while map_.next_key::<GeneratedField>()?.is_some() {
6318 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6319 }
6320 Ok(GetClusterLimitsRequest {
6321 })
6322 }
6323 }
6324 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6325 }
6326}
6327impl serde::Serialize for GetClusterLimitsResponse {
6328 #[allow(deprecated)]
6329 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6330 where
6331 S: serde::Serializer,
6332 {
6333 use serde::ser::SerializeStruct;
6334 let mut len = 0;
6335 if !self.active_limits.is_empty() {
6336 len += 1;
6337 }
6338 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6339 if !self.active_limits.is_empty() {
6340 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6341 }
6342 struct_ser.end()
6343 }
6344}
6345impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6346 #[allow(deprecated)]
6347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6348 where
6349 D: serde::Deserializer<'de>,
6350 {
6351 const FIELDS: &[&str] = &[
6352 "active_limits",
6353 "activeLimits",
6354 ];
6355
6356 #[allow(clippy::enum_variant_names)]
6357 enum GeneratedField {
6358 ActiveLimits,
6359 }
6360 impl<'de> serde::Deserialize<'de> for GeneratedField {
6361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6362 where
6363 D: serde::Deserializer<'de>,
6364 {
6365 struct GeneratedVisitor;
6366
6367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6368 type Value = GeneratedField;
6369
6370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6371 write!(formatter, "expected one of: {:?}", &FIELDS)
6372 }
6373
6374 #[allow(unused_variables)]
6375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6376 where
6377 E: serde::de::Error,
6378 {
6379 match value {
6380 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6382 }
6383 }
6384 }
6385 deserializer.deserialize_identifier(GeneratedVisitor)
6386 }
6387 }
6388 struct GeneratedVisitor;
6389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6390 type Value = GetClusterLimitsResponse;
6391
6392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6393 formatter.write_str("struct meta.GetClusterLimitsResponse")
6394 }
6395
6396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6397 where
6398 V: serde::de::MapAccess<'de>,
6399 {
6400 let mut active_limits__ = None;
6401 while let Some(k) = map_.next_key()? {
6402 match k {
6403 GeneratedField::ActiveLimits => {
6404 if active_limits__.is_some() {
6405 return Err(serde::de::Error::duplicate_field("activeLimits"));
6406 }
6407 active_limits__ = Some(map_.next_value()?);
6408 }
6409 }
6410 }
6411 Ok(GetClusterLimitsResponse {
6412 active_limits: active_limits__.unwrap_or_default(),
6413 })
6414 }
6415 }
6416 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6417 }
6418}
6419impl serde::Serialize for GetClusterRecoveryStatusRequest {
6420 #[allow(deprecated)]
6421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6422 where
6423 S: serde::Serializer,
6424 {
6425 use serde::ser::SerializeStruct;
6426 let len = 0;
6427 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6428 struct_ser.end()
6429 }
6430}
6431impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6432 #[allow(deprecated)]
6433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6434 where
6435 D: serde::Deserializer<'de>,
6436 {
6437 const FIELDS: &[&str] = &[
6438 ];
6439
6440 #[allow(clippy::enum_variant_names)]
6441 enum GeneratedField {
6442 }
6443 impl<'de> serde::Deserialize<'de> for GeneratedField {
6444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6445 where
6446 D: serde::Deserializer<'de>,
6447 {
6448 struct GeneratedVisitor;
6449
6450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6451 type Value = GeneratedField;
6452
6453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6454 write!(formatter, "expected one of: {:?}", &FIELDS)
6455 }
6456
6457 #[allow(unused_variables)]
6458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6459 where
6460 E: serde::de::Error,
6461 {
6462 Err(serde::de::Error::unknown_field(value, FIELDS))
6463 }
6464 }
6465 deserializer.deserialize_identifier(GeneratedVisitor)
6466 }
6467 }
6468 struct GeneratedVisitor;
6469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6470 type Value = GetClusterRecoveryStatusRequest;
6471
6472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6473 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6474 }
6475
6476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6477 where
6478 V: serde::de::MapAccess<'de>,
6479 {
6480 while map_.next_key::<GeneratedField>()?.is_some() {
6481 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6482 }
6483 Ok(GetClusterRecoveryStatusRequest {
6484 })
6485 }
6486 }
6487 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6488 }
6489}
6490impl serde::Serialize for GetClusterRecoveryStatusResponse {
6491 #[allow(deprecated)]
6492 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6493 where
6494 S: serde::Serializer,
6495 {
6496 use serde::ser::SerializeStruct;
6497 let mut len = 0;
6498 if self.status != 0 {
6499 len += 1;
6500 }
6501 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6502 if self.status != 0 {
6503 let v = RecoveryStatus::try_from(self.status)
6504 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6505 struct_ser.serialize_field("status", &v)?;
6506 }
6507 struct_ser.end()
6508 }
6509}
6510impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6511 #[allow(deprecated)]
6512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6513 where
6514 D: serde::Deserializer<'de>,
6515 {
6516 const FIELDS: &[&str] = &[
6517 "status",
6518 ];
6519
6520 #[allow(clippy::enum_variant_names)]
6521 enum GeneratedField {
6522 Status,
6523 }
6524 impl<'de> serde::Deserialize<'de> for GeneratedField {
6525 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6526 where
6527 D: serde::Deserializer<'de>,
6528 {
6529 struct GeneratedVisitor;
6530
6531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6532 type Value = GeneratedField;
6533
6534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6535 write!(formatter, "expected one of: {:?}", &FIELDS)
6536 }
6537
6538 #[allow(unused_variables)]
6539 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6540 where
6541 E: serde::de::Error,
6542 {
6543 match value {
6544 "status" => Ok(GeneratedField::Status),
6545 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6546 }
6547 }
6548 }
6549 deserializer.deserialize_identifier(GeneratedVisitor)
6550 }
6551 }
6552 struct GeneratedVisitor;
6553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6554 type Value = GetClusterRecoveryStatusResponse;
6555
6556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6557 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6558 }
6559
6560 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6561 where
6562 V: serde::de::MapAccess<'de>,
6563 {
6564 let mut status__ = None;
6565 while let Some(k) = map_.next_key()? {
6566 match k {
6567 GeneratedField::Status => {
6568 if status__.is_some() {
6569 return Err(serde::de::Error::duplicate_field("status"));
6570 }
6571 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6572 }
6573 }
6574 }
6575 Ok(GetClusterRecoveryStatusResponse {
6576 status: status__.unwrap_or_default(),
6577 })
6578 }
6579 }
6580 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6581 }
6582}
6583impl serde::Serialize for GetFragmentByIdRequest {
6584 #[allow(deprecated)]
6585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6586 where
6587 S: serde::Serializer,
6588 {
6589 use serde::ser::SerializeStruct;
6590 let mut len = 0;
6591 if self.fragment_id != 0 {
6592 len += 1;
6593 }
6594 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6595 if self.fragment_id != 0 {
6596 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6597 }
6598 struct_ser.end()
6599 }
6600}
6601impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6602 #[allow(deprecated)]
6603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6604 where
6605 D: serde::Deserializer<'de>,
6606 {
6607 const FIELDS: &[&str] = &[
6608 "fragment_id",
6609 "fragmentId",
6610 ];
6611
6612 #[allow(clippy::enum_variant_names)]
6613 enum GeneratedField {
6614 FragmentId,
6615 }
6616 impl<'de> serde::Deserialize<'de> for GeneratedField {
6617 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6618 where
6619 D: serde::Deserializer<'de>,
6620 {
6621 struct GeneratedVisitor;
6622
6623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6624 type Value = GeneratedField;
6625
6626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6627 write!(formatter, "expected one of: {:?}", &FIELDS)
6628 }
6629
6630 #[allow(unused_variables)]
6631 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6632 where
6633 E: serde::de::Error,
6634 {
6635 match value {
6636 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6638 }
6639 }
6640 }
6641 deserializer.deserialize_identifier(GeneratedVisitor)
6642 }
6643 }
6644 struct GeneratedVisitor;
6645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6646 type Value = GetFragmentByIdRequest;
6647
6648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6649 formatter.write_str("struct meta.GetFragmentByIdRequest")
6650 }
6651
6652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6653 where
6654 V: serde::de::MapAccess<'de>,
6655 {
6656 let mut fragment_id__ = None;
6657 while let Some(k) = map_.next_key()? {
6658 match k {
6659 GeneratedField::FragmentId => {
6660 if fragment_id__.is_some() {
6661 return Err(serde::de::Error::duplicate_field("fragmentId"));
6662 }
6663 fragment_id__ =
6664 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6665 ;
6666 }
6667 }
6668 }
6669 Ok(GetFragmentByIdRequest {
6670 fragment_id: fragment_id__.unwrap_or_default(),
6671 })
6672 }
6673 }
6674 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6675 }
6676}
6677impl serde::Serialize for GetFragmentByIdResponse {
6678 #[allow(deprecated)]
6679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6680 where
6681 S: serde::Serializer,
6682 {
6683 use serde::ser::SerializeStruct;
6684 let mut len = 0;
6685 if self.distribution.is_some() {
6686 len += 1;
6687 }
6688 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6689 if let Some(v) = self.distribution.as_ref() {
6690 struct_ser.serialize_field("distribution", v)?;
6691 }
6692 struct_ser.end()
6693 }
6694}
6695impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
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 "distribution",
6703 ];
6704
6705 #[allow(clippy::enum_variant_names)]
6706 enum GeneratedField {
6707 Distribution,
6708 }
6709 impl<'de> serde::Deserialize<'de> for GeneratedField {
6710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6711 where
6712 D: serde::Deserializer<'de>,
6713 {
6714 struct GeneratedVisitor;
6715
6716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6717 type Value = GeneratedField;
6718
6719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6720 write!(formatter, "expected one of: {:?}", &FIELDS)
6721 }
6722
6723 #[allow(unused_variables)]
6724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6725 where
6726 E: serde::de::Error,
6727 {
6728 match value {
6729 "distribution" => Ok(GeneratedField::Distribution),
6730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6731 }
6732 }
6733 }
6734 deserializer.deserialize_identifier(GeneratedVisitor)
6735 }
6736 }
6737 struct GeneratedVisitor;
6738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6739 type Value = GetFragmentByIdResponse;
6740
6741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6742 formatter.write_str("struct meta.GetFragmentByIdResponse")
6743 }
6744
6745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6746 where
6747 V: serde::de::MapAccess<'de>,
6748 {
6749 let mut distribution__ = None;
6750 while let Some(k) = map_.next_key()? {
6751 match k {
6752 GeneratedField::Distribution => {
6753 if distribution__.is_some() {
6754 return Err(serde::de::Error::duplicate_field("distribution"));
6755 }
6756 distribution__ = map_.next_value()?;
6757 }
6758 }
6759 }
6760 Ok(GetFragmentByIdResponse {
6761 distribution: distribution__,
6762 })
6763 }
6764 }
6765 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6766 }
6767}
6768impl serde::Serialize for GetFragmentVnodesRequest {
6769 #[allow(deprecated)]
6770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6771 where
6772 S: serde::Serializer,
6773 {
6774 use serde::ser::SerializeStruct;
6775 let mut len = 0;
6776 if self.fragment_id != 0 {
6777 len += 1;
6778 }
6779 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesRequest", len)?;
6780 if self.fragment_id != 0 {
6781 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6782 }
6783 struct_ser.end()
6784 }
6785}
6786impl<'de> serde::Deserialize<'de> for GetFragmentVnodesRequest {
6787 #[allow(deprecated)]
6788 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6789 where
6790 D: serde::Deserializer<'de>,
6791 {
6792 const FIELDS: &[&str] = &[
6793 "fragment_id",
6794 "fragmentId",
6795 ];
6796
6797 #[allow(clippy::enum_variant_names)]
6798 enum GeneratedField {
6799 FragmentId,
6800 }
6801 impl<'de> serde::Deserialize<'de> for GeneratedField {
6802 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6803 where
6804 D: serde::Deserializer<'de>,
6805 {
6806 struct GeneratedVisitor;
6807
6808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6809 type Value = GeneratedField;
6810
6811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6812 write!(formatter, "expected one of: {:?}", &FIELDS)
6813 }
6814
6815 #[allow(unused_variables)]
6816 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6817 where
6818 E: serde::de::Error,
6819 {
6820 match value {
6821 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6823 }
6824 }
6825 }
6826 deserializer.deserialize_identifier(GeneratedVisitor)
6827 }
6828 }
6829 struct GeneratedVisitor;
6830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6831 type Value = GetFragmentVnodesRequest;
6832
6833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6834 formatter.write_str("struct meta.GetFragmentVnodesRequest")
6835 }
6836
6837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesRequest, V::Error>
6838 where
6839 V: serde::de::MapAccess<'de>,
6840 {
6841 let mut fragment_id__ = None;
6842 while let Some(k) = map_.next_key()? {
6843 match k {
6844 GeneratedField::FragmentId => {
6845 if fragment_id__.is_some() {
6846 return Err(serde::de::Error::duplicate_field("fragmentId"));
6847 }
6848 fragment_id__ =
6849 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6850 ;
6851 }
6852 }
6853 }
6854 Ok(GetFragmentVnodesRequest {
6855 fragment_id: fragment_id__.unwrap_or_default(),
6856 })
6857 }
6858 }
6859 deserializer.deserialize_struct("meta.GetFragmentVnodesRequest", FIELDS, GeneratedVisitor)
6860 }
6861}
6862impl serde::Serialize for GetFragmentVnodesResponse {
6863 #[allow(deprecated)]
6864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6865 where
6866 S: serde::Serializer,
6867 {
6868 use serde::ser::SerializeStruct;
6869 let mut len = 0;
6870 if !self.actor_vnodes.is_empty() {
6871 len += 1;
6872 }
6873 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse", len)?;
6874 if !self.actor_vnodes.is_empty() {
6875 struct_ser.serialize_field("actorVnodes", &self.actor_vnodes)?;
6876 }
6877 struct_ser.end()
6878 }
6879}
6880impl<'de> serde::Deserialize<'de> for GetFragmentVnodesResponse {
6881 #[allow(deprecated)]
6882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6883 where
6884 D: serde::Deserializer<'de>,
6885 {
6886 const FIELDS: &[&str] = &[
6887 "actor_vnodes",
6888 "actorVnodes",
6889 ];
6890
6891 #[allow(clippy::enum_variant_names)]
6892 enum GeneratedField {
6893 ActorVnodes,
6894 }
6895 impl<'de> serde::Deserialize<'de> for GeneratedField {
6896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6897 where
6898 D: serde::Deserializer<'de>,
6899 {
6900 struct GeneratedVisitor;
6901
6902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6903 type Value = GeneratedField;
6904
6905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6906 write!(formatter, "expected one of: {:?}", &FIELDS)
6907 }
6908
6909 #[allow(unused_variables)]
6910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6911 where
6912 E: serde::de::Error,
6913 {
6914 match value {
6915 "actorVnodes" | "actor_vnodes" => Ok(GeneratedField::ActorVnodes),
6916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6917 }
6918 }
6919 }
6920 deserializer.deserialize_identifier(GeneratedVisitor)
6921 }
6922 }
6923 struct GeneratedVisitor;
6924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6925 type Value = GetFragmentVnodesResponse;
6926
6927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6928 formatter.write_str("struct meta.GetFragmentVnodesResponse")
6929 }
6930
6931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentVnodesResponse, V::Error>
6932 where
6933 V: serde::de::MapAccess<'de>,
6934 {
6935 let mut actor_vnodes__ = None;
6936 while let Some(k) = map_.next_key()? {
6937 match k {
6938 GeneratedField::ActorVnodes => {
6939 if actor_vnodes__.is_some() {
6940 return Err(serde::de::Error::duplicate_field("actorVnodes"));
6941 }
6942 actor_vnodes__ = Some(map_.next_value()?);
6943 }
6944 }
6945 }
6946 Ok(GetFragmentVnodesResponse {
6947 actor_vnodes: actor_vnodes__.unwrap_or_default(),
6948 })
6949 }
6950 }
6951 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse", FIELDS, GeneratedVisitor)
6952 }
6953}
6954impl serde::Serialize for get_fragment_vnodes_response::ActorVnodes {
6955 #[allow(deprecated)]
6956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6957 where
6958 S: serde::Serializer,
6959 {
6960 use serde::ser::SerializeStruct;
6961 let mut len = 0;
6962 if self.actor_id != 0 {
6963 len += 1;
6964 }
6965 if !self.vnode_indices.is_empty() {
6966 len += 1;
6967 }
6968 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", len)?;
6969 if self.actor_id != 0 {
6970 struct_ser.serialize_field("actorId", &self.actor_id)?;
6971 }
6972 if !self.vnode_indices.is_empty() {
6973 struct_ser.serialize_field("vnodeIndices", &self.vnode_indices)?;
6974 }
6975 struct_ser.end()
6976 }
6977}
6978impl<'de> serde::Deserialize<'de> for get_fragment_vnodes_response::ActorVnodes {
6979 #[allow(deprecated)]
6980 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6981 where
6982 D: serde::Deserializer<'de>,
6983 {
6984 const FIELDS: &[&str] = &[
6985 "actor_id",
6986 "actorId",
6987 "vnode_indices",
6988 "vnodeIndices",
6989 ];
6990
6991 #[allow(clippy::enum_variant_names)]
6992 enum GeneratedField {
6993 ActorId,
6994 VnodeIndices,
6995 }
6996 impl<'de> serde::Deserialize<'de> for GeneratedField {
6997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6998 where
6999 D: serde::Deserializer<'de>,
7000 {
7001 struct GeneratedVisitor;
7002
7003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7004 type Value = GeneratedField;
7005
7006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7007 write!(formatter, "expected one of: {:?}", &FIELDS)
7008 }
7009
7010 #[allow(unused_variables)]
7011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7012 where
7013 E: serde::de::Error,
7014 {
7015 match value {
7016 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7017 "vnodeIndices" | "vnode_indices" => Ok(GeneratedField::VnodeIndices),
7018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7019 }
7020 }
7021 }
7022 deserializer.deserialize_identifier(GeneratedVisitor)
7023 }
7024 }
7025 struct GeneratedVisitor;
7026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7027 type Value = get_fragment_vnodes_response::ActorVnodes;
7028
7029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7030 formatter.write_str("struct meta.GetFragmentVnodesResponse.ActorVnodes")
7031 }
7032
7033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_fragment_vnodes_response::ActorVnodes, V::Error>
7034 where
7035 V: serde::de::MapAccess<'de>,
7036 {
7037 let mut actor_id__ = None;
7038 let mut vnode_indices__ = None;
7039 while let Some(k) = map_.next_key()? {
7040 match k {
7041 GeneratedField::ActorId => {
7042 if actor_id__.is_some() {
7043 return Err(serde::de::Error::duplicate_field("actorId"));
7044 }
7045 actor_id__ =
7046 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7047 ;
7048 }
7049 GeneratedField::VnodeIndices => {
7050 if vnode_indices__.is_some() {
7051 return Err(serde::de::Error::duplicate_field("vnodeIndices"));
7052 }
7053 vnode_indices__ =
7054 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7055 .into_iter().map(|x| x.0).collect())
7056 ;
7057 }
7058 }
7059 }
7060 Ok(get_fragment_vnodes_response::ActorVnodes {
7061 actor_id: actor_id__.unwrap_or_default(),
7062 vnode_indices: vnode_indices__.unwrap_or_default(),
7063 })
7064 }
7065 }
7066 deserializer.deserialize_struct("meta.GetFragmentVnodesResponse.ActorVnodes", FIELDS, GeneratedVisitor)
7067 }
7068}
7069impl serde::Serialize for GetMetaStoreInfoRequest {
7070 #[allow(deprecated)]
7071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7072 where
7073 S: serde::Serializer,
7074 {
7075 use serde::ser::SerializeStruct;
7076 let len = 0;
7077 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
7078 struct_ser.end()
7079 }
7080}
7081impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
7082 #[allow(deprecated)]
7083 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7084 where
7085 D: serde::Deserializer<'de>,
7086 {
7087 const FIELDS: &[&str] = &[
7088 ];
7089
7090 #[allow(clippy::enum_variant_names)]
7091 enum GeneratedField {
7092 }
7093 impl<'de> serde::Deserialize<'de> for GeneratedField {
7094 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7095 where
7096 D: serde::Deserializer<'de>,
7097 {
7098 struct GeneratedVisitor;
7099
7100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7101 type Value = GeneratedField;
7102
7103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7104 write!(formatter, "expected one of: {:?}", &FIELDS)
7105 }
7106
7107 #[allow(unused_variables)]
7108 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7109 where
7110 E: serde::de::Error,
7111 {
7112 Err(serde::de::Error::unknown_field(value, FIELDS))
7113 }
7114 }
7115 deserializer.deserialize_identifier(GeneratedVisitor)
7116 }
7117 }
7118 struct GeneratedVisitor;
7119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7120 type Value = GetMetaStoreInfoRequest;
7121
7122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7123 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
7124 }
7125
7126 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
7127 where
7128 V: serde::de::MapAccess<'de>,
7129 {
7130 while map_.next_key::<GeneratedField>()?.is_some() {
7131 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7132 }
7133 Ok(GetMetaStoreInfoRequest {
7134 })
7135 }
7136 }
7137 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
7138 }
7139}
7140impl serde::Serialize for GetMetaStoreInfoResponse {
7141 #[allow(deprecated)]
7142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7143 where
7144 S: serde::Serializer,
7145 {
7146 use serde::ser::SerializeStruct;
7147 let mut len = 0;
7148 if !self.meta_store_endpoint.is_empty() {
7149 len += 1;
7150 }
7151 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
7152 if !self.meta_store_endpoint.is_empty() {
7153 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
7154 }
7155 struct_ser.end()
7156 }
7157}
7158impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
7159 #[allow(deprecated)]
7160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7161 where
7162 D: serde::Deserializer<'de>,
7163 {
7164 const FIELDS: &[&str] = &[
7165 "meta_store_endpoint",
7166 "metaStoreEndpoint",
7167 ];
7168
7169 #[allow(clippy::enum_variant_names)]
7170 enum GeneratedField {
7171 MetaStoreEndpoint,
7172 }
7173 impl<'de> serde::Deserialize<'de> for GeneratedField {
7174 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7175 where
7176 D: serde::Deserializer<'de>,
7177 {
7178 struct GeneratedVisitor;
7179
7180 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7181 type Value = GeneratedField;
7182
7183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7184 write!(formatter, "expected one of: {:?}", &FIELDS)
7185 }
7186
7187 #[allow(unused_variables)]
7188 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7189 where
7190 E: serde::de::Error,
7191 {
7192 match value {
7193 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
7194 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7195 }
7196 }
7197 }
7198 deserializer.deserialize_identifier(GeneratedVisitor)
7199 }
7200 }
7201 struct GeneratedVisitor;
7202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7203 type Value = GetMetaStoreInfoResponse;
7204
7205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7206 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
7207 }
7208
7209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
7210 where
7211 V: serde::de::MapAccess<'de>,
7212 {
7213 let mut meta_store_endpoint__ = None;
7214 while let Some(k) = map_.next_key()? {
7215 match k {
7216 GeneratedField::MetaStoreEndpoint => {
7217 if meta_store_endpoint__.is_some() {
7218 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
7219 }
7220 meta_store_endpoint__ = Some(map_.next_value()?);
7221 }
7222 }
7223 }
7224 Ok(GetMetaStoreInfoResponse {
7225 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
7226 })
7227 }
7228 }
7229 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
7230 }
7231}
7232impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
7233 #[allow(deprecated)]
7234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7235 where
7236 S: serde::Serializer,
7237 {
7238 use serde::ser::SerializeStruct;
7239 let len = 0;
7240 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
7241 struct_ser.end()
7242 }
7243}
7244impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
7245 #[allow(deprecated)]
7246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7247 where
7248 D: serde::Deserializer<'de>,
7249 {
7250 const FIELDS: &[&str] = &[
7251 ];
7252
7253 #[allow(clippy::enum_variant_names)]
7254 enum GeneratedField {
7255 }
7256 impl<'de> serde::Deserialize<'de> for GeneratedField {
7257 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7258 where
7259 D: serde::Deserializer<'de>,
7260 {
7261 struct GeneratedVisitor;
7262
7263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7264 type Value = GeneratedField;
7265
7266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7267 write!(formatter, "expected one of: {:?}", &FIELDS)
7268 }
7269
7270 #[allow(unused_variables)]
7271 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7272 where
7273 E: serde::de::Error,
7274 {
7275 Err(serde::de::Error::unknown_field(value, FIELDS))
7276 }
7277 }
7278 deserializer.deserialize_identifier(GeneratedVisitor)
7279 }
7280 }
7281 struct GeneratedVisitor;
7282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7283 type Value = GetServerlessStreamingJobsStatusRequest;
7284
7285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7286 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
7287 }
7288
7289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
7290 where
7291 V: serde::de::MapAccess<'de>,
7292 {
7293 while map_.next_key::<GeneratedField>()?.is_some() {
7294 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7295 }
7296 Ok(GetServerlessStreamingJobsStatusRequest {
7297 })
7298 }
7299 }
7300 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
7301 }
7302}
7303impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
7304 #[allow(deprecated)]
7305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7306 where
7307 S: serde::Serializer,
7308 {
7309 use serde::ser::SerializeStruct;
7310 let mut len = 0;
7311 if !self.streaming_job_statuses.is_empty() {
7312 len += 1;
7313 }
7314 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
7315 if !self.streaming_job_statuses.is_empty() {
7316 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
7317 }
7318 struct_ser.end()
7319 }
7320}
7321impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
7322 #[allow(deprecated)]
7323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7324 where
7325 D: serde::Deserializer<'de>,
7326 {
7327 const FIELDS: &[&str] = &[
7328 "streaming_job_statuses",
7329 "streamingJobStatuses",
7330 ];
7331
7332 #[allow(clippy::enum_variant_names)]
7333 enum GeneratedField {
7334 StreamingJobStatuses,
7335 }
7336 impl<'de> serde::Deserialize<'de> for GeneratedField {
7337 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7338 where
7339 D: serde::Deserializer<'de>,
7340 {
7341 struct GeneratedVisitor;
7342
7343 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7344 type Value = GeneratedField;
7345
7346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7347 write!(formatter, "expected one of: {:?}", &FIELDS)
7348 }
7349
7350 #[allow(unused_variables)]
7351 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7352 where
7353 E: serde::de::Error,
7354 {
7355 match value {
7356 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
7357 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7358 }
7359 }
7360 }
7361 deserializer.deserialize_identifier(GeneratedVisitor)
7362 }
7363 }
7364 struct GeneratedVisitor;
7365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7366 type Value = GetServerlessStreamingJobsStatusResponse;
7367
7368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7369 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
7370 }
7371
7372 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
7373 where
7374 V: serde::de::MapAccess<'de>,
7375 {
7376 let mut streaming_job_statuses__ = None;
7377 while let Some(k) = map_.next_key()? {
7378 match k {
7379 GeneratedField::StreamingJobStatuses => {
7380 if streaming_job_statuses__.is_some() {
7381 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
7382 }
7383 streaming_job_statuses__ = Some(map_.next_value()?);
7384 }
7385 }
7386 }
7387 Ok(GetServerlessStreamingJobsStatusResponse {
7388 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
7389 })
7390 }
7391 }
7392 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
7393 }
7394}
7395impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
7396 #[allow(deprecated)]
7397 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7398 where
7399 S: serde::Serializer,
7400 {
7401 use serde::ser::SerializeStruct;
7402 let mut len = 0;
7403 if self.table_id != 0 {
7404 len += 1;
7405 }
7406 if !self.node_label.is_empty() {
7407 len += 1;
7408 }
7409 if self.backfill_done {
7410 len += 1;
7411 }
7412 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
7413 if self.table_id != 0 {
7414 struct_ser.serialize_field("tableId", &self.table_id)?;
7415 }
7416 if !self.node_label.is_empty() {
7417 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
7418 }
7419 if self.backfill_done {
7420 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
7421 }
7422 struct_ser.end()
7423 }
7424}
7425impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
7426 #[allow(deprecated)]
7427 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7428 where
7429 D: serde::Deserializer<'de>,
7430 {
7431 const FIELDS: &[&str] = &[
7432 "table_id",
7433 "tableId",
7434 "node_label",
7435 "nodeLabel",
7436 "backfill_done",
7437 "backfillDone",
7438 ];
7439
7440 #[allow(clippy::enum_variant_names)]
7441 enum GeneratedField {
7442 TableId,
7443 NodeLabel,
7444 BackfillDone,
7445 }
7446 impl<'de> serde::Deserialize<'de> for GeneratedField {
7447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7448 where
7449 D: serde::Deserializer<'de>,
7450 {
7451 struct GeneratedVisitor;
7452
7453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7454 type Value = GeneratedField;
7455
7456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7457 write!(formatter, "expected one of: {:?}", &FIELDS)
7458 }
7459
7460 #[allow(unused_variables)]
7461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7462 where
7463 E: serde::de::Error,
7464 {
7465 match value {
7466 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7467 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
7468 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
7469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7470 }
7471 }
7472 }
7473 deserializer.deserialize_identifier(GeneratedVisitor)
7474 }
7475 }
7476 struct GeneratedVisitor;
7477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7478 type Value = get_serverless_streaming_jobs_status_response::Status;
7479
7480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7481 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
7482 }
7483
7484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
7485 where
7486 V: serde::de::MapAccess<'de>,
7487 {
7488 let mut table_id__ = None;
7489 let mut node_label__ = None;
7490 let mut backfill_done__ = None;
7491 while let Some(k) = map_.next_key()? {
7492 match k {
7493 GeneratedField::TableId => {
7494 if table_id__.is_some() {
7495 return Err(serde::de::Error::duplicate_field("tableId"));
7496 }
7497 table_id__ =
7498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7499 ;
7500 }
7501 GeneratedField::NodeLabel => {
7502 if node_label__.is_some() {
7503 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7504 }
7505 node_label__ = Some(map_.next_value()?);
7506 }
7507 GeneratedField::BackfillDone => {
7508 if backfill_done__.is_some() {
7509 return Err(serde::de::Error::duplicate_field("backfillDone"));
7510 }
7511 backfill_done__ = Some(map_.next_value()?);
7512 }
7513 }
7514 }
7515 Ok(get_serverless_streaming_jobs_status_response::Status {
7516 table_id: table_id__.unwrap_or_default(),
7517 node_label: node_label__.unwrap_or_default(),
7518 backfill_done: backfill_done__.unwrap_or_default(),
7519 })
7520 }
7521 }
7522 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7523 }
7524}
7525impl serde::Serialize for GetServingVnodeMappingsRequest {
7526 #[allow(deprecated)]
7527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7528 where
7529 S: serde::Serializer,
7530 {
7531 use serde::ser::SerializeStruct;
7532 let len = 0;
7533 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7534 struct_ser.end()
7535 }
7536}
7537impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7538 #[allow(deprecated)]
7539 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7540 where
7541 D: serde::Deserializer<'de>,
7542 {
7543 const FIELDS: &[&str] = &[
7544 ];
7545
7546 #[allow(clippy::enum_variant_names)]
7547 enum GeneratedField {
7548 }
7549 impl<'de> serde::Deserialize<'de> for GeneratedField {
7550 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7551 where
7552 D: serde::Deserializer<'de>,
7553 {
7554 struct GeneratedVisitor;
7555
7556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7557 type Value = GeneratedField;
7558
7559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7560 write!(formatter, "expected one of: {:?}", &FIELDS)
7561 }
7562
7563 #[allow(unused_variables)]
7564 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7565 where
7566 E: serde::de::Error,
7567 {
7568 Err(serde::de::Error::unknown_field(value, FIELDS))
7569 }
7570 }
7571 deserializer.deserialize_identifier(GeneratedVisitor)
7572 }
7573 }
7574 struct GeneratedVisitor;
7575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7576 type Value = GetServingVnodeMappingsRequest;
7577
7578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7579 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7580 }
7581
7582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7583 where
7584 V: serde::de::MapAccess<'de>,
7585 {
7586 while map_.next_key::<GeneratedField>()?.is_some() {
7587 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7588 }
7589 Ok(GetServingVnodeMappingsRequest {
7590 })
7591 }
7592 }
7593 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7594 }
7595}
7596impl serde::Serialize for GetServingVnodeMappingsResponse {
7597 #[allow(deprecated)]
7598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7599 where
7600 S: serde::Serializer,
7601 {
7602 use serde::ser::SerializeStruct;
7603 let mut len = 0;
7604 if !self.fragment_to_table.is_empty() {
7605 len += 1;
7606 }
7607 if !self.worker_slot_mappings.is_empty() {
7608 len += 1;
7609 }
7610 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7611 if !self.fragment_to_table.is_empty() {
7612 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7613 }
7614 if !self.worker_slot_mappings.is_empty() {
7615 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7616 }
7617 struct_ser.end()
7618 }
7619}
7620impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7621 #[allow(deprecated)]
7622 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7623 where
7624 D: serde::Deserializer<'de>,
7625 {
7626 const FIELDS: &[&str] = &[
7627 "fragment_to_table",
7628 "fragmentToTable",
7629 "worker_slot_mappings",
7630 "workerSlotMappings",
7631 ];
7632
7633 #[allow(clippy::enum_variant_names)]
7634 enum GeneratedField {
7635 FragmentToTable,
7636 WorkerSlotMappings,
7637 }
7638 impl<'de> serde::Deserialize<'de> for GeneratedField {
7639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7640 where
7641 D: serde::Deserializer<'de>,
7642 {
7643 struct GeneratedVisitor;
7644
7645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7646 type Value = GeneratedField;
7647
7648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7649 write!(formatter, "expected one of: {:?}", &FIELDS)
7650 }
7651
7652 #[allow(unused_variables)]
7653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7654 where
7655 E: serde::de::Error,
7656 {
7657 match value {
7658 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7659 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7660 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7661 }
7662 }
7663 }
7664 deserializer.deserialize_identifier(GeneratedVisitor)
7665 }
7666 }
7667 struct GeneratedVisitor;
7668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7669 type Value = GetServingVnodeMappingsResponse;
7670
7671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7672 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7673 }
7674
7675 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7676 where
7677 V: serde::de::MapAccess<'de>,
7678 {
7679 let mut fragment_to_table__ = None;
7680 let mut worker_slot_mappings__ = None;
7681 while let Some(k) = map_.next_key()? {
7682 match k {
7683 GeneratedField::FragmentToTable => {
7684 if fragment_to_table__.is_some() {
7685 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7686 }
7687 fragment_to_table__ = Some(
7688 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7689 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
7690 );
7691 }
7692 GeneratedField::WorkerSlotMappings => {
7693 if worker_slot_mappings__.is_some() {
7694 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7695 }
7696 worker_slot_mappings__ = Some(map_.next_value()?);
7697 }
7698 }
7699 }
7700 Ok(GetServingVnodeMappingsResponse {
7701 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7702 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7703 })
7704 }
7705 }
7706 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7707 }
7708}
7709impl serde::Serialize for GetSessionParamsRequest {
7710 #[allow(deprecated)]
7711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7712 where
7713 S: serde::Serializer,
7714 {
7715 use serde::ser::SerializeStruct;
7716 let len = 0;
7717 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7718 struct_ser.end()
7719 }
7720}
7721impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7722 #[allow(deprecated)]
7723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7724 where
7725 D: serde::Deserializer<'de>,
7726 {
7727 const FIELDS: &[&str] = &[
7728 ];
7729
7730 #[allow(clippy::enum_variant_names)]
7731 enum GeneratedField {
7732 }
7733 impl<'de> serde::Deserialize<'de> for GeneratedField {
7734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7735 where
7736 D: serde::Deserializer<'de>,
7737 {
7738 struct GeneratedVisitor;
7739
7740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7741 type Value = GeneratedField;
7742
7743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7744 write!(formatter, "expected one of: {:?}", &FIELDS)
7745 }
7746
7747 #[allow(unused_variables)]
7748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7749 where
7750 E: serde::de::Error,
7751 {
7752 Err(serde::de::Error::unknown_field(value, FIELDS))
7753 }
7754 }
7755 deserializer.deserialize_identifier(GeneratedVisitor)
7756 }
7757 }
7758 struct GeneratedVisitor;
7759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7760 type Value = GetSessionParamsRequest;
7761
7762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7763 formatter.write_str("struct meta.GetSessionParamsRequest")
7764 }
7765
7766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7767 where
7768 V: serde::de::MapAccess<'de>,
7769 {
7770 while map_.next_key::<GeneratedField>()?.is_some() {
7771 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7772 }
7773 Ok(GetSessionParamsRequest {
7774 })
7775 }
7776 }
7777 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7778 }
7779}
7780impl serde::Serialize for GetSessionParamsResponse {
7781 #[allow(deprecated)]
7782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7783 where
7784 S: serde::Serializer,
7785 {
7786 use serde::ser::SerializeStruct;
7787 let mut len = 0;
7788 if !self.params.is_empty() {
7789 len += 1;
7790 }
7791 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7792 if !self.params.is_empty() {
7793 struct_ser.serialize_field("params", &self.params)?;
7794 }
7795 struct_ser.end()
7796 }
7797}
7798impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7799 #[allow(deprecated)]
7800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7801 where
7802 D: serde::Deserializer<'de>,
7803 {
7804 const FIELDS: &[&str] = &[
7805 "params",
7806 ];
7807
7808 #[allow(clippy::enum_variant_names)]
7809 enum GeneratedField {
7810 Params,
7811 }
7812 impl<'de> serde::Deserialize<'de> for GeneratedField {
7813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7814 where
7815 D: serde::Deserializer<'de>,
7816 {
7817 struct GeneratedVisitor;
7818
7819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7820 type Value = GeneratedField;
7821
7822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7823 write!(formatter, "expected one of: {:?}", &FIELDS)
7824 }
7825
7826 #[allow(unused_variables)]
7827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7828 where
7829 E: serde::de::Error,
7830 {
7831 match value {
7832 "params" => Ok(GeneratedField::Params),
7833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7834 }
7835 }
7836 }
7837 deserializer.deserialize_identifier(GeneratedVisitor)
7838 }
7839 }
7840 struct GeneratedVisitor;
7841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7842 type Value = GetSessionParamsResponse;
7843
7844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7845 formatter.write_str("struct meta.GetSessionParamsResponse")
7846 }
7847
7848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7849 where
7850 V: serde::de::MapAccess<'de>,
7851 {
7852 let mut params__ = None;
7853 while let Some(k) = map_.next_key()? {
7854 match k {
7855 GeneratedField::Params => {
7856 if params__.is_some() {
7857 return Err(serde::de::Error::duplicate_field("params"));
7858 }
7859 params__ = Some(map_.next_value()?);
7860 }
7861 }
7862 }
7863 Ok(GetSessionParamsResponse {
7864 params: params__.unwrap_or_default(),
7865 })
7866 }
7867 }
7868 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7869 }
7870}
7871impl serde::Serialize for GetSystemParamsRequest {
7872 #[allow(deprecated)]
7873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7874 where
7875 S: serde::Serializer,
7876 {
7877 use serde::ser::SerializeStruct;
7878 let len = 0;
7879 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7880 struct_ser.end()
7881 }
7882}
7883impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7884 #[allow(deprecated)]
7885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7886 where
7887 D: serde::Deserializer<'de>,
7888 {
7889 const FIELDS: &[&str] = &[
7890 ];
7891
7892 #[allow(clippy::enum_variant_names)]
7893 enum GeneratedField {
7894 }
7895 impl<'de> serde::Deserialize<'de> for GeneratedField {
7896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7897 where
7898 D: serde::Deserializer<'de>,
7899 {
7900 struct GeneratedVisitor;
7901
7902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7903 type Value = GeneratedField;
7904
7905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7906 write!(formatter, "expected one of: {:?}", &FIELDS)
7907 }
7908
7909 #[allow(unused_variables)]
7910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7911 where
7912 E: serde::de::Error,
7913 {
7914 Err(serde::de::Error::unknown_field(value, FIELDS))
7915 }
7916 }
7917 deserializer.deserialize_identifier(GeneratedVisitor)
7918 }
7919 }
7920 struct GeneratedVisitor;
7921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7922 type Value = GetSystemParamsRequest;
7923
7924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7925 formatter.write_str("struct meta.GetSystemParamsRequest")
7926 }
7927
7928 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7929 where
7930 V: serde::de::MapAccess<'de>,
7931 {
7932 while map_.next_key::<GeneratedField>()?.is_some() {
7933 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7934 }
7935 Ok(GetSystemParamsRequest {
7936 })
7937 }
7938 }
7939 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7940 }
7941}
7942impl serde::Serialize for GetSystemParamsResponse {
7943 #[allow(deprecated)]
7944 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7945 where
7946 S: serde::Serializer,
7947 {
7948 use serde::ser::SerializeStruct;
7949 let mut len = 0;
7950 if self.params.is_some() {
7951 len += 1;
7952 }
7953 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7954 if let Some(v) = self.params.as_ref() {
7955 struct_ser.serialize_field("params", v)?;
7956 }
7957 struct_ser.end()
7958 }
7959}
7960impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7961 #[allow(deprecated)]
7962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7963 where
7964 D: serde::Deserializer<'de>,
7965 {
7966 const FIELDS: &[&str] = &[
7967 "params",
7968 ];
7969
7970 #[allow(clippy::enum_variant_names)]
7971 enum GeneratedField {
7972 Params,
7973 }
7974 impl<'de> serde::Deserialize<'de> for GeneratedField {
7975 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7976 where
7977 D: serde::Deserializer<'de>,
7978 {
7979 struct GeneratedVisitor;
7980
7981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7982 type Value = GeneratedField;
7983
7984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7985 write!(formatter, "expected one of: {:?}", &FIELDS)
7986 }
7987
7988 #[allow(unused_variables)]
7989 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7990 where
7991 E: serde::de::Error,
7992 {
7993 match value {
7994 "params" => Ok(GeneratedField::Params),
7995 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7996 }
7997 }
7998 }
7999 deserializer.deserialize_identifier(GeneratedVisitor)
8000 }
8001 }
8002 struct GeneratedVisitor;
8003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8004 type Value = GetSystemParamsResponse;
8005
8006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8007 formatter.write_str("struct meta.GetSystemParamsResponse")
8008 }
8009
8010 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
8011 where
8012 V: serde::de::MapAccess<'de>,
8013 {
8014 let mut params__ = None;
8015 while let Some(k) = map_.next_key()? {
8016 match k {
8017 GeneratedField::Params => {
8018 if params__.is_some() {
8019 return Err(serde::de::Error::duplicate_field("params"));
8020 }
8021 params__ = map_.next_value()?;
8022 }
8023 }
8024 }
8025 Ok(GetSystemParamsResponse {
8026 params: params__,
8027 })
8028 }
8029 }
8030 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
8031 }
8032}
8033impl serde::Serialize for GetTelemetryInfoRequest {
8034 #[allow(deprecated)]
8035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8036 where
8037 S: serde::Serializer,
8038 {
8039 use serde::ser::SerializeStruct;
8040 let len = 0;
8041 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
8042 struct_ser.end()
8043 }
8044}
8045impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
8046 #[allow(deprecated)]
8047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8048 where
8049 D: serde::Deserializer<'de>,
8050 {
8051 const FIELDS: &[&str] = &[
8052 ];
8053
8054 #[allow(clippy::enum_variant_names)]
8055 enum GeneratedField {
8056 }
8057 impl<'de> serde::Deserialize<'de> for GeneratedField {
8058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8059 where
8060 D: serde::Deserializer<'de>,
8061 {
8062 struct GeneratedVisitor;
8063
8064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8065 type Value = GeneratedField;
8066
8067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8068 write!(formatter, "expected one of: {:?}", &FIELDS)
8069 }
8070
8071 #[allow(unused_variables)]
8072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8073 where
8074 E: serde::de::Error,
8075 {
8076 Err(serde::de::Error::unknown_field(value, FIELDS))
8077 }
8078 }
8079 deserializer.deserialize_identifier(GeneratedVisitor)
8080 }
8081 }
8082 struct GeneratedVisitor;
8083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8084 type Value = GetTelemetryInfoRequest;
8085
8086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087 formatter.write_str("struct meta.GetTelemetryInfoRequest")
8088 }
8089
8090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
8091 where
8092 V: serde::de::MapAccess<'de>,
8093 {
8094 while map_.next_key::<GeneratedField>()?.is_some() {
8095 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8096 }
8097 Ok(GetTelemetryInfoRequest {
8098 })
8099 }
8100 }
8101 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
8102 }
8103}
8104impl serde::Serialize for HeartbeatRequest {
8105 #[allow(deprecated)]
8106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8107 where
8108 S: serde::Serializer,
8109 {
8110 use serde::ser::SerializeStruct;
8111 let mut len = 0;
8112 if self.node_id != 0 {
8113 len += 1;
8114 }
8115 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
8116 if self.node_id != 0 {
8117 struct_ser.serialize_field("nodeId", &self.node_id)?;
8118 }
8119 struct_ser.end()
8120 }
8121}
8122impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
8123 #[allow(deprecated)]
8124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8125 where
8126 D: serde::Deserializer<'de>,
8127 {
8128 const FIELDS: &[&str] = &[
8129 "node_id",
8130 "nodeId",
8131 ];
8132
8133 #[allow(clippy::enum_variant_names)]
8134 enum GeneratedField {
8135 NodeId,
8136 }
8137 impl<'de> serde::Deserialize<'de> for GeneratedField {
8138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8139 where
8140 D: serde::Deserializer<'de>,
8141 {
8142 struct GeneratedVisitor;
8143
8144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8145 type Value = GeneratedField;
8146
8147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8148 write!(formatter, "expected one of: {:?}", &FIELDS)
8149 }
8150
8151 #[allow(unused_variables)]
8152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8153 where
8154 E: serde::de::Error,
8155 {
8156 match value {
8157 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
8158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8159 }
8160 }
8161 }
8162 deserializer.deserialize_identifier(GeneratedVisitor)
8163 }
8164 }
8165 struct GeneratedVisitor;
8166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8167 type Value = HeartbeatRequest;
8168
8169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8170 formatter.write_str("struct meta.HeartbeatRequest")
8171 }
8172
8173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
8174 where
8175 V: serde::de::MapAccess<'de>,
8176 {
8177 let mut node_id__ = None;
8178 while let Some(k) = map_.next_key()? {
8179 match k {
8180 GeneratedField::NodeId => {
8181 if node_id__.is_some() {
8182 return Err(serde::de::Error::duplicate_field("nodeId"));
8183 }
8184 node_id__ =
8185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8186 ;
8187 }
8188 }
8189 }
8190 Ok(HeartbeatRequest {
8191 node_id: node_id__.unwrap_or_default(),
8192 })
8193 }
8194 }
8195 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
8196 }
8197}
8198impl serde::Serialize for HeartbeatResponse {
8199 #[allow(deprecated)]
8200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8201 where
8202 S: serde::Serializer,
8203 {
8204 use serde::ser::SerializeStruct;
8205 let mut len = 0;
8206 if self.status.is_some() {
8207 len += 1;
8208 }
8209 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
8210 if let Some(v) = self.status.as_ref() {
8211 struct_ser.serialize_field("status", v)?;
8212 }
8213 struct_ser.end()
8214 }
8215}
8216impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
8217 #[allow(deprecated)]
8218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8219 where
8220 D: serde::Deserializer<'de>,
8221 {
8222 const FIELDS: &[&str] = &[
8223 "status",
8224 ];
8225
8226 #[allow(clippy::enum_variant_names)]
8227 enum GeneratedField {
8228 Status,
8229 }
8230 impl<'de> serde::Deserialize<'de> for GeneratedField {
8231 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8232 where
8233 D: serde::Deserializer<'de>,
8234 {
8235 struct GeneratedVisitor;
8236
8237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8238 type Value = GeneratedField;
8239
8240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8241 write!(formatter, "expected one of: {:?}", &FIELDS)
8242 }
8243
8244 #[allow(unused_variables)]
8245 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8246 where
8247 E: serde::de::Error,
8248 {
8249 match value {
8250 "status" => Ok(GeneratedField::Status),
8251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8252 }
8253 }
8254 }
8255 deserializer.deserialize_identifier(GeneratedVisitor)
8256 }
8257 }
8258 struct GeneratedVisitor;
8259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8260 type Value = HeartbeatResponse;
8261
8262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8263 formatter.write_str("struct meta.HeartbeatResponse")
8264 }
8265
8266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
8267 where
8268 V: serde::de::MapAccess<'de>,
8269 {
8270 let mut status__ = None;
8271 while let Some(k) = map_.next_key()? {
8272 match k {
8273 GeneratedField::Status => {
8274 if status__.is_some() {
8275 return Err(serde::de::Error::duplicate_field("status"));
8276 }
8277 status__ = map_.next_value()?;
8278 }
8279 }
8280 }
8281 Ok(HeartbeatResponse {
8282 status: status__,
8283 })
8284 }
8285 }
8286 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
8287 }
8288}
8289impl serde::Serialize for ListActorSplitsRequest {
8290 #[allow(deprecated)]
8291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8292 where
8293 S: serde::Serializer,
8294 {
8295 use serde::ser::SerializeStruct;
8296 let len = 0;
8297 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
8298 struct_ser.end()
8299 }
8300}
8301impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
8302 #[allow(deprecated)]
8303 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8304 where
8305 D: serde::Deserializer<'de>,
8306 {
8307 const FIELDS: &[&str] = &[
8308 ];
8309
8310 #[allow(clippy::enum_variant_names)]
8311 enum GeneratedField {
8312 }
8313 impl<'de> serde::Deserialize<'de> for GeneratedField {
8314 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8315 where
8316 D: serde::Deserializer<'de>,
8317 {
8318 struct GeneratedVisitor;
8319
8320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8321 type Value = GeneratedField;
8322
8323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8324 write!(formatter, "expected one of: {:?}", &FIELDS)
8325 }
8326
8327 #[allow(unused_variables)]
8328 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8329 where
8330 E: serde::de::Error,
8331 {
8332 Err(serde::de::Error::unknown_field(value, FIELDS))
8333 }
8334 }
8335 deserializer.deserialize_identifier(GeneratedVisitor)
8336 }
8337 }
8338 struct GeneratedVisitor;
8339 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8340 type Value = ListActorSplitsRequest;
8341
8342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8343 formatter.write_str("struct meta.ListActorSplitsRequest")
8344 }
8345
8346 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
8347 where
8348 V: serde::de::MapAccess<'de>,
8349 {
8350 while map_.next_key::<GeneratedField>()?.is_some() {
8351 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8352 }
8353 Ok(ListActorSplitsRequest {
8354 })
8355 }
8356 }
8357 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
8358 }
8359}
8360impl serde::Serialize for ListActorSplitsResponse {
8361 #[allow(deprecated)]
8362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8363 where
8364 S: serde::Serializer,
8365 {
8366 use serde::ser::SerializeStruct;
8367 let mut len = 0;
8368 if !self.actor_splits.is_empty() {
8369 len += 1;
8370 }
8371 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
8372 if !self.actor_splits.is_empty() {
8373 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
8374 }
8375 struct_ser.end()
8376 }
8377}
8378impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
8379 #[allow(deprecated)]
8380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8381 where
8382 D: serde::Deserializer<'de>,
8383 {
8384 const FIELDS: &[&str] = &[
8385 "actor_splits",
8386 "actorSplits",
8387 ];
8388
8389 #[allow(clippy::enum_variant_names)]
8390 enum GeneratedField {
8391 ActorSplits,
8392 }
8393 impl<'de> serde::Deserialize<'de> for GeneratedField {
8394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8395 where
8396 D: serde::Deserializer<'de>,
8397 {
8398 struct GeneratedVisitor;
8399
8400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8401 type Value = GeneratedField;
8402
8403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8404 write!(formatter, "expected one of: {:?}", &FIELDS)
8405 }
8406
8407 #[allow(unused_variables)]
8408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8409 where
8410 E: serde::de::Error,
8411 {
8412 match value {
8413 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
8414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8415 }
8416 }
8417 }
8418 deserializer.deserialize_identifier(GeneratedVisitor)
8419 }
8420 }
8421 struct GeneratedVisitor;
8422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8423 type Value = ListActorSplitsResponse;
8424
8425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8426 formatter.write_str("struct meta.ListActorSplitsResponse")
8427 }
8428
8429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
8430 where
8431 V: serde::de::MapAccess<'de>,
8432 {
8433 let mut actor_splits__ = None;
8434 while let Some(k) = map_.next_key()? {
8435 match k {
8436 GeneratedField::ActorSplits => {
8437 if actor_splits__.is_some() {
8438 return Err(serde::de::Error::duplicate_field("actorSplits"));
8439 }
8440 actor_splits__ = Some(map_.next_value()?);
8441 }
8442 }
8443 }
8444 Ok(ListActorSplitsResponse {
8445 actor_splits: actor_splits__.unwrap_or_default(),
8446 })
8447 }
8448 }
8449 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
8450 }
8451}
8452impl serde::Serialize for list_actor_splits_response::ActorSplit {
8453 #[allow(deprecated)]
8454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8455 where
8456 S: serde::Serializer,
8457 {
8458 use serde::ser::SerializeStruct;
8459 let mut len = 0;
8460 if self.actor_id != 0 {
8461 len += 1;
8462 }
8463 if self.fragment_id != 0 {
8464 len += 1;
8465 }
8466 if self.source_id != 0 {
8467 len += 1;
8468 }
8469 if !self.split_id.is_empty() {
8470 len += 1;
8471 }
8472 if self.fragment_type != 0 {
8473 len += 1;
8474 }
8475 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
8476 if self.actor_id != 0 {
8477 struct_ser.serialize_field("actorId", &self.actor_id)?;
8478 }
8479 if self.fragment_id != 0 {
8480 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8481 }
8482 if self.source_id != 0 {
8483 struct_ser.serialize_field("sourceId", &self.source_id)?;
8484 }
8485 if !self.split_id.is_empty() {
8486 struct_ser.serialize_field("splitId", &self.split_id)?;
8487 }
8488 if self.fragment_type != 0 {
8489 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
8490 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
8491 struct_ser.serialize_field("fragmentType", &v)?;
8492 }
8493 struct_ser.end()
8494 }
8495}
8496impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
8497 #[allow(deprecated)]
8498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8499 where
8500 D: serde::Deserializer<'de>,
8501 {
8502 const FIELDS: &[&str] = &[
8503 "actor_id",
8504 "actorId",
8505 "fragment_id",
8506 "fragmentId",
8507 "source_id",
8508 "sourceId",
8509 "split_id",
8510 "splitId",
8511 "fragment_type",
8512 "fragmentType",
8513 ];
8514
8515 #[allow(clippy::enum_variant_names)]
8516 enum GeneratedField {
8517 ActorId,
8518 FragmentId,
8519 SourceId,
8520 SplitId,
8521 FragmentType,
8522 }
8523 impl<'de> serde::Deserialize<'de> for GeneratedField {
8524 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8525 where
8526 D: serde::Deserializer<'de>,
8527 {
8528 struct GeneratedVisitor;
8529
8530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8531 type Value = GeneratedField;
8532
8533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8534 write!(formatter, "expected one of: {:?}", &FIELDS)
8535 }
8536
8537 #[allow(unused_variables)]
8538 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8539 where
8540 E: serde::de::Error,
8541 {
8542 match value {
8543 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8544 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8545 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8546 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
8547 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
8548 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8549 }
8550 }
8551 }
8552 deserializer.deserialize_identifier(GeneratedVisitor)
8553 }
8554 }
8555 struct GeneratedVisitor;
8556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8557 type Value = list_actor_splits_response::ActorSplit;
8558
8559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8560 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
8561 }
8562
8563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
8564 where
8565 V: serde::de::MapAccess<'de>,
8566 {
8567 let mut actor_id__ = None;
8568 let mut fragment_id__ = None;
8569 let mut source_id__ = None;
8570 let mut split_id__ = None;
8571 let mut fragment_type__ = None;
8572 while let Some(k) = map_.next_key()? {
8573 match k {
8574 GeneratedField::ActorId => {
8575 if actor_id__.is_some() {
8576 return Err(serde::de::Error::duplicate_field("actorId"));
8577 }
8578 actor_id__ =
8579 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8580 ;
8581 }
8582 GeneratedField::FragmentId => {
8583 if fragment_id__.is_some() {
8584 return Err(serde::de::Error::duplicate_field("fragmentId"));
8585 }
8586 fragment_id__ =
8587 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8588 ;
8589 }
8590 GeneratedField::SourceId => {
8591 if source_id__.is_some() {
8592 return Err(serde::de::Error::duplicate_field("sourceId"));
8593 }
8594 source_id__ =
8595 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8596 ;
8597 }
8598 GeneratedField::SplitId => {
8599 if split_id__.is_some() {
8600 return Err(serde::de::Error::duplicate_field("splitId"));
8601 }
8602 split_id__ = Some(map_.next_value()?);
8603 }
8604 GeneratedField::FragmentType => {
8605 if fragment_type__.is_some() {
8606 return Err(serde::de::Error::duplicate_field("fragmentType"));
8607 }
8608 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
8609 }
8610 }
8611 }
8612 Ok(list_actor_splits_response::ActorSplit {
8613 actor_id: actor_id__.unwrap_or_default(),
8614 fragment_id: fragment_id__.unwrap_or_default(),
8615 source_id: source_id__.unwrap_or_default(),
8616 split_id: split_id__.unwrap_or_default(),
8617 fragment_type: fragment_type__.unwrap_or_default(),
8618 })
8619 }
8620 }
8621 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
8622 }
8623}
8624impl serde::Serialize for list_actor_splits_response::FragmentType {
8625 #[allow(deprecated)]
8626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8627 where
8628 S: serde::Serializer,
8629 {
8630 let variant = match self {
8631 Self::Unspecified => "UNSPECIFIED",
8632 Self::NonSharedSource => "NON_SHARED_SOURCE",
8633 Self::SharedSource => "SHARED_SOURCE",
8634 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
8635 };
8636 serializer.serialize_str(variant)
8637 }
8638}
8639impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
8640 #[allow(deprecated)]
8641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8642 where
8643 D: serde::Deserializer<'de>,
8644 {
8645 const FIELDS: &[&str] = &[
8646 "UNSPECIFIED",
8647 "NON_SHARED_SOURCE",
8648 "SHARED_SOURCE",
8649 "SHARED_SOURCE_BACKFILL",
8650 ];
8651
8652 struct GeneratedVisitor;
8653
8654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8655 type Value = list_actor_splits_response::FragmentType;
8656
8657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8658 write!(formatter, "expected one of: {:?}", &FIELDS)
8659 }
8660
8661 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8662 where
8663 E: serde::de::Error,
8664 {
8665 i32::try_from(v)
8666 .ok()
8667 .and_then(|x| x.try_into().ok())
8668 .ok_or_else(|| {
8669 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8670 })
8671 }
8672
8673 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8674 where
8675 E: serde::de::Error,
8676 {
8677 i32::try_from(v)
8678 .ok()
8679 .and_then(|x| x.try_into().ok())
8680 .ok_or_else(|| {
8681 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8682 })
8683 }
8684
8685 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8686 where
8687 E: serde::de::Error,
8688 {
8689 match value {
8690 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8691 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8692 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8693 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8694 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8695 }
8696 }
8697 }
8698 deserializer.deserialize_any(GeneratedVisitor)
8699 }
8700}
8701impl serde::Serialize for ListActorStatesRequest {
8702 #[allow(deprecated)]
8703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8704 where
8705 S: serde::Serializer,
8706 {
8707 use serde::ser::SerializeStruct;
8708 let len = 0;
8709 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8710 struct_ser.end()
8711 }
8712}
8713impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8714 #[allow(deprecated)]
8715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8716 where
8717 D: serde::Deserializer<'de>,
8718 {
8719 const FIELDS: &[&str] = &[
8720 ];
8721
8722 #[allow(clippy::enum_variant_names)]
8723 enum GeneratedField {
8724 }
8725 impl<'de> serde::Deserialize<'de> for GeneratedField {
8726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8727 where
8728 D: serde::Deserializer<'de>,
8729 {
8730 struct GeneratedVisitor;
8731
8732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8733 type Value = GeneratedField;
8734
8735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8736 write!(formatter, "expected one of: {:?}", &FIELDS)
8737 }
8738
8739 #[allow(unused_variables)]
8740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8741 where
8742 E: serde::de::Error,
8743 {
8744 Err(serde::de::Error::unknown_field(value, FIELDS))
8745 }
8746 }
8747 deserializer.deserialize_identifier(GeneratedVisitor)
8748 }
8749 }
8750 struct GeneratedVisitor;
8751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8752 type Value = ListActorStatesRequest;
8753
8754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8755 formatter.write_str("struct meta.ListActorStatesRequest")
8756 }
8757
8758 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8759 where
8760 V: serde::de::MapAccess<'de>,
8761 {
8762 while map_.next_key::<GeneratedField>()?.is_some() {
8763 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8764 }
8765 Ok(ListActorStatesRequest {
8766 })
8767 }
8768 }
8769 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8770 }
8771}
8772impl serde::Serialize for ListActorStatesResponse {
8773 #[allow(deprecated)]
8774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8775 where
8776 S: serde::Serializer,
8777 {
8778 use serde::ser::SerializeStruct;
8779 let mut len = 0;
8780 if !self.states.is_empty() {
8781 len += 1;
8782 }
8783 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8784 if !self.states.is_empty() {
8785 struct_ser.serialize_field("states", &self.states)?;
8786 }
8787 struct_ser.end()
8788 }
8789}
8790impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8791 #[allow(deprecated)]
8792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8793 where
8794 D: serde::Deserializer<'de>,
8795 {
8796 const FIELDS: &[&str] = &[
8797 "states",
8798 ];
8799
8800 #[allow(clippy::enum_variant_names)]
8801 enum GeneratedField {
8802 States,
8803 }
8804 impl<'de> serde::Deserialize<'de> for GeneratedField {
8805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8806 where
8807 D: serde::Deserializer<'de>,
8808 {
8809 struct GeneratedVisitor;
8810
8811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8812 type Value = GeneratedField;
8813
8814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8815 write!(formatter, "expected one of: {:?}", &FIELDS)
8816 }
8817
8818 #[allow(unused_variables)]
8819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8820 where
8821 E: serde::de::Error,
8822 {
8823 match value {
8824 "states" => Ok(GeneratedField::States),
8825 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8826 }
8827 }
8828 }
8829 deserializer.deserialize_identifier(GeneratedVisitor)
8830 }
8831 }
8832 struct GeneratedVisitor;
8833 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8834 type Value = ListActorStatesResponse;
8835
8836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8837 formatter.write_str("struct meta.ListActorStatesResponse")
8838 }
8839
8840 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8841 where
8842 V: serde::de::MapAccess<'de>,
8843 {
8844 let mut states__ = None;
8845 while let Some(k) = map_.next_key()? {
8846 match k {
8847 GeneratedField::States => {
8848 if states__.is_some() {
8849 return Err(serde::de::Error::duplicate_field("states"));
8850 }
8851 states__ = Some(map_.next_value()?);
8852 }
8853 }
8854 }
8855 Ok(ListActorStatesResponse {
8856 states: states__.unwrap_or_default(),
8857 })
8858 }
8859 }
8860 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8861 }
8862}
8863impl serde::Serialize for list_actor_states_response::ActorState {
8864 #[allow(deprecated)]
8865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8866 where
8867 S: serde::Serializer,
8868 {
8869 use serde::ser::SerializeStruct;
8870 let mut len = 0;
8871 if self.actor_id != 0 {
8872 len += 1;
8873 }
8874 if self.fragment_id != 0 {
8875 len += 1;
8876 }
8877 if self.worker_id != 0 {
8878 len += 1;
8879 }
8880 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8881 if self.actor_id != 0 {
8882 struct_ser.serialize_field("actorId", &self.actor_id)?;
8883 }
8884 if self.fragment_id != 0 {
8885 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8886 }
8887 if self.worker_id != 0 {
8888 struct_ser.serialize_field("workerId", &self.worker_id)?;
8889 }
8890 struct_ser.end()
8891 }
8892}
8893impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8894 #[allow(deprecated)]
8895 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8896 where
8897 D: serde::Deserializer<'de>,
8898 {
8899 const FIELDS: &[&str] = &[
8900 "actor_id",
8901 "actorId",
8902 "fragment_id",
8903 "fragmentId",
8904 "worker_id",
8905 "workerId",
8906 ];
8907
8908 #[allow(clippy::enum_variant_names)]
8909 enum GeneratedField {
8910 ActorId,
8911 FragmentId,
8912 WorkerId,
8913 }
8914 impl<'de> serde::Deserialize<'de> for GeneratedField {
8915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8916 where
8917 D: serde::Deserializer<'de>,
8918 {
8919 struct GeneratedVisitor;
8920
8921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8922 type Value = GeneratedField;
8923
8924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8925 write!(formatter, "expected one of: {:?}", &FIELDS)
8926 }
8927
8928 #[allow(unused_variables)]
8929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8930 where
8931 E: serde::de::Error,
8932 {
8933 match value {
8934 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8935 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8936 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8937 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8938 }
8939 }
8940 }
8941 deserializer.deserialize_identifier(GeneratedVisitor)
8942 }
8943 }
8944 struct GeneratedVisitor;
8945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8946 type Value = list_actor_states_response::ActorState;
8947
8948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8949 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8950 }
8951
8952 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8953 where
8954 V: serde::de::MapAccess<'de>,
8955 {
8956 let mut actor_id__ = None;
8957 let mut fragment_id__ = None;
8958 let mut worker_id__ = None;
8959 while let Some(k) = map_.next_key()? {
8960 match k {
8961 GeneratedField::ActorId => {
8962 if actor_id__.is_some() {
8963 return Err(serde::de::Error::duplicate_field("actorId"));
8964 }
8965 actor_id__ =
8966 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8967 ;
8968 }
8969 GeneratedField::FragmentId => {
8970 if fragment_id__.is_some() {
8971 return Err(serde::de::Error::duplicate_field("fragmentId"));
8972 }
8973 fragment_id__ =
8974 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8975 ;
8976 }
8977 GeneratedField::WorkerId => {
8978 if worker_id__.is_some() {
8979 return Err(serde::de::Error::duplicate_field("workerId"));
8980 }
8981 worker_id__ =
8982 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8983 ;
8984 }
8985 }
8986 }
8987 Ok(list_actor_states_response::ActorState {
8988 actor_id: actor_id__.unwrap_or_default(),
8989 fragment_id: fragment_id__.unwrap_or_default(),
8990 worker_id: worker_id__.unwrap_or_default(),
8991 })
8992 }
8993 }
8994 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8995 }
8996}
8997impl serde::Serialize for ListAllNodesRequest {
8998 #[allow(deprecated)]
8999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9000 where
9001 S: serde::Serializer,
9002 {
9003 use serde::ser::SerializeStruct;
9004 let mut len = 0;
9005 if self.worker_type.is_some() {
9006 len += 1;
9007 }
9008 if self.include_starting_nodes {
9009 len += 1;
9010 }
9011 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
9012 if let Some(v) = self.worker_type.as_ref() {
9013 let v = super::common::WorkerType::try_from(*v)
9014 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
9015 struct_ser.serialize_field("workerType", &v)?;
9016 }
9017 if self.include_starting_nodes {
9018 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
9019 }
9020 struct_ser.end()
9021 }
9022}
9023impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
9024 #[allow(deprecated)]
9025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9026 where
9027 D: serde::Deserializer<'de>,
9028 {
9029 const FIELDS: &[&str] = &[
9030 "worker_type",
9031 "workerType",
9032 "include_starting_nodes",
9033 "includeStartingNodes",
9034 ];
9035
9036 #[allow(clippy::enum_variant_names)]
9037 enum GeneratedField {
9038 WorkerType,
9039 IncludeStartingNodes,
9040 }
9041 impl<'de> serde::Deserialize<'de> for GeneratedField {
9042 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9043 where
9044 D: serde::Deserializer<'de>,
9045 {
9046 struct GeneratedVisitor;
9047
9048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9049 type Value = GeneratedField;
9050
9051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9052 write!(formatter, "expected one of: {:?}", &FIELDS)
9053 }
9054
9055 #[allow(unused_variables)]
9056 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9057 where
9058 E: serde::de::Error,
9059 {
9060 match value {
9061 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
9062 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
9063 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9064 }
9065 }
9066 }
9067 deserializer.deserialize_identifier(GeneratedVisitor)
9068 }
9069 }
9070 struct GeneratedVisitor;
9071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9072 type Value = ListAllNodesRequest;
9073
9074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9075 formatter.write_str("struct meta.ListAllNodesRequest")
9076 }
9077
9078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
9079 where
9080 V: serde::de::MapAccess<'de>,
9081 {
9082 let mut worker_type__ = None;
9083 let mut include_starting_nodes__ = None;
9084 while let Some(k) = map_.next_key()? {
9085 match k {
9086 GeneratedField::WorkerType => {
9087 if worker_type__.is_some() {
9088 return Err(serde::de::Error::duplicate_field("workerType"));
9089 }
9090 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
9091 }
9092 GeneratedField::IncludeStartingNodes => {
9093 if include_starting_nodes__.is_some() {
9094 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
9095 }
9096 include_starting_nodes__ = Some(map_.next_value()?);
9097 }
9098 }
9099 }
9100 Ok(ListAllNodesRequest {
9101 worker_type: worker_type__,
9102 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
9103 })
9104 }
9105 }
9106 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
9107 }
9108}
9109impl serde::Serialize for ListAllNodesResponse {
9110 #[allow(deprecated)]
9111 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9112 where
9113 S: serde::Serializer,
9114 {
9115 use serde::ser::SerializeStruct;
9116 let mut len = 0;
9117 if self.status.is_some() {
9118 len += 1;
9119 }
9120 if !self.nodes.is_empty() {
9121 len += 1;
9122 }
9123 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
9124 if let Some(v) = self.status.as_ref() {
9125 struct_ser.serialize_field("status", v)?;
9126 }
9127 if !self.nodes.is_empty() {
9128 struct_ser.serialize_field("nodes", &self.nodes)?;
9129 }
9130 struct_ser.end()
9131 }
9132}
9133impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
9134 #[allow(deprecated)]
9135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9136 where
9137 D: serde::Deserializer<'de>,
9138 {
9139 const FIELDS: &[&str] = &[
9140 "status",
9141 "nodes",
9142 ];
9143
9144 #[allow(clippy::enum_variant_names)]
9145 enum GeneratedField {
9146 Status,
9147 Nodes,
9148 }
9149 impl<'de> serde::Deserialize<'de> for GeneratedField {
9150 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9151 where
9152 D: serde::Deserializer<'de>,
9153 {
9154 struct GeneratedVisitor;
9155
9156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9157 type Value = GeneratedField;
9158
9159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9160 write!(formatter, "expected one of: {:?}", &FIELDS)
9161 }
9162
9163 #[allow(unused_variables)]
9164 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9165 where
9166 E: serde::de::Error,
9167 {
9168 match value {
9169 "status" => Ok(GeneratedField::Status),
9170 "nodes" => Ok(GeneratedField::Nodes),
9171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9172 }
9173 }
9174 }
9175 deserializer.deserialize_identifier(GeneratedVisitor)
9176 }
9177 }
9178 struct GeneratedVisitor;
9179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9180 type Value = ListAllNodesResponse;
9181
9182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9183 formatter.write_str("struct meta.ListAllNodesResponse")
9184 }
9185
9186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
9187 where
9188 V: serde::de::MapAccess<'de>,
9189 {
9190 let mut status__ = None;
9191 let mut nodes__ = None;
9192 while let Some(k) = map_.next_key()? {
9193 match k {
9194 GeneratedField::Status => {
9195 if status__.is_some() {
9196 return Err(serde::de::Error::duplicate_field("status"));
9197 }
9198 status__ = map_.next_value()?;
9199 }
9200 GeneratedField::Nodes => {
9201 if nodes__.is_some() {
9202 return Err(serde::de::Error::duplicate_field("nodes"));
9203 }
9204 nodes__ = Some(map_.next_value()?);
9205 }
9206 }
9207 }
9208 Ok(ListAllNodesResponse {
9209 status: status__,
9210 nodes: nodes__.unwrap_or_default(),
9211 })
9212 }
9213 }
9214 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
9215 }
9216}
9217impl serde::Serialize for ListCdcProgressRequest {
9218 #[allow(deprecated)]
9219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9220 where
9221 S: serde::Serializer,
9222 {
9223 use serde::ser::SerializeStruct;
9224 let len = 0;
9225 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
9226 struct_ser.end()
9227 }
9228}
9229impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
9230 #[allow(deprecated)]
9231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9232 where
9233 D: serde::Deserializer<'de>,
9234 {
9235 const FIELDS: &[&str] = &[
9236 ];
9237
9238 #[allow(clippy::enum_variant_names)]
9239 enum GeneratedField {
9240 }
9241 impl<'de> serde::Deserialize<'de> for GeneratedField {
9242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9243 where
9244 D: serde::Deserializer<'de>,
9245 {
9246 struct GeneratedVisitor;
9247
9248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9249 type Value = GeneratedField;
9250
9251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9252 write!(formatter, "expected one of: {:?}", &FIELDS)
9253 }
9254
9255 #[allow(unused_variables)]
9256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9257 where
9258 E: serde::de::Error,
9259 {
9260 Err(serde::de::Error::unknown_field(value, FIELDS))
9261 }
9262 }
9263 deserializer.deserialize_identifier(GeneratedVisitor)
9264 }
9265 }
9266 struct GeneratedVisitor;
9267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9268 type Value = ListCdcProgressRequest;
9269
9270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9271 formatter.write_str("struct meta.ListCdcProgressRequest")
9272 }
9273
9274 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
9275 where
9276 V: serde::de::MapAccess<'de>,
9277 {
9278 while map_.next_key::<GeneratedField>()?.is_some() {
9279 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9280 }
9281 Ok(ListCdcProgressRequest {
9282 })
9283 }
9284 }
9285 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
9286 }
9287}
9288impl serde::Serialize for ListCdcProgressResponse {
9289 #[allow(deprecated)]
9290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9291 where
9292 S: serde::Serializer,
9293 {
9294 use serde::ser::SerializeStruct;
9295 let mut len = 0;
9296 if !self.cdc_progress.is_empty() {
9297 len += 1;
9298 }
9299 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
9300 if !self.cdc_progress.is_empty() {
9301 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
9302 }
9303 struct_ser.end()
9304 }
9305}
9306impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
9307 #[allow(deprecated)]
9308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9309 where
9310 D: serde::Deserializer<'de>,
9311 {
9312 const FIELDS: &[&str] = &[
9313 "cdc_progress",
9314 "cdcProgress",
9315 ];
9316
9317 #[allow(clippy::enum_variant_names)]
9318 enum GeneratedField {
9319 CdcProgress,
9320 }
9321 impl<'de> serde::Deserialize<'de> for GeneratedField {
9322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9323 where
9324 D: serde::Deserializer<'de>,
9325 {
9326 struct GeneratedVisitor;
9327
9328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9329 type Value = GeneratedField;
9330
9331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9332 write!(formatter, "expected one of: {:?}", &FIELDS)
9333 }
9334
9335 #[allow(unused_variables)]
9336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9337 where
9338 E: serde::de::Error,
9339 {
9340 match value {
9341 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
9342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9343 }
9344 }
9345 }
9346 deserializer.deserialize_identifier(GeneratedVisitor)
9347 }
9348 }
9349 struct GeneratedVisitor;
9350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9351 type Value = ListCdcProgressResponse;
9352
9353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9354 formatter.write_str("struct meta.ListCdcProgressResponse")
9355 }
9356
9357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
9358 where
9359 V: serde::de::MapAccess<'de>,
9360 {
9361 let mut cdc_progress__ = None;
9362 while let Some(k) = map_.next_key()? {
9363 match k {
9364 GeneratedField::CdcProgress => {
9365 if cdc_progress__.is_some() {
9366 return Err(serde::de::Error::duplicate_field("cdcProgress"));
9367 }
9368 cdc_progress__ = Some(
9369 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9370 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9371 );
9372 }
9373 }
9374 }
9375 Ok(ListCdcProgressResponse {
9376 cdc_progress: cdc_progress__.unwrap_or_default(),
9377 })
9378 }
9379 }
9380 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
9381 }
9382}
9383impl serde::Serialize for list_cdc_progress_response::CdcProgress {
9384 #[allow(deprecated)]
9385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9386 where
9387 S: serde::Serializer,
9388 {
9389 use serde::ser::SerializeStruct;
9390 let mut len = 0;
9391 if self.split_total_count != 0 {
9392 len += 1;
9393 }
9394 if self.split_backfilled_count != 0 {
9395 len += 1;
9396 }
9397 if self.split_completed_count != 0 {
9398 len += 1;
9399 }
9400 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
9401 if self.split_total_count != 0 {
9402 #[allow(clippy::needless_borrow)]
9403 #[allow(clippy::needless_borrows_for_generic_args)]
9404 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
9405 }
9406 if self.split_backfilled_count != 0 {
9407 #[allow(clippy::needless_borrow)]
9408 #[allow(clippy::needless_borrows_for_generic_args)]
9409 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
9410 }
9411 if self.split_completed_count != 0 {
9412 #[allow(clippy::needless_borrow)]
9413 #[allow(clippy::needless_borrows_for_generic_args)]
9414 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
9415 }
9416 struct_ser.end()
9417 }
9418}
9419impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
9420 #[allow(deprecated)]
9421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9422 where
9423 D: serde::Deserializer<'de>,
9424 {
9425 const FIELDS: &[&str] = &[
9426 "split_total_count",
9427 "splitTotalCount",
9428 "split_backfilled_count",
9429 "splitBackfilledCount",
9430 "split_completed_count",
9431 "splitCompletedCount",
9432 ];
9433
9434 #[allow(clippy::enum_variant_names)]
9435 enum GeneratedField {
9436 SplitTotalCount,
9437 SplitBackfilledCount,
9438 SplitCompletedCount,
9439 }
9440 impl<'de> serde::Deserialize<'de> for GeneratedField {
9441 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9442 where
9443 D: serde::Deserializer<'de>,
9444 {
9445 struct GeneratedVisitor;
9446
9447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9448 type Value = GeneratedField;
9449
9450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9451 write!(formatter, "expected one of: {:?}", &FIELDS)
9452 }
9453
9454 #[allow(unused_variables)]
9455 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9456 where
9457 E: serde::de::Error,
9458 {
9459 match value {
9460 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
9461 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
9462 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
9463 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9464 }
9465 }
9466 }
9467 deserializer.deserialize_identifier(GeneratedVisitor)
9468 }
9469 }
9470 struct GeneratedVisitor;
9471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9472 type Value = list_cdc_progress_response::CdcProgress;
9473
9474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9475 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
9476 }
9477
9478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
9479 where
9480 V: serde::de::MapAccess<'de>,
9481 {
9482 let mut split_total_count__ = None;
9483 let mut split_backfilled_count__ = None;
9484 let mut split_completed_count__ = None;
9485 while let Some(k) = map_.next_key()? {
9486 match k {
9487 GeneratedField::SplitTotalCount => {
9488 if split_total_count__.is_some() {
9489 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9490 }
9491 split_total_count__ =
9492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9493 ;
9494 }
9495 GeneratedField::SplitBackfilledCount => {
9496 if split_backfilled_count__.is_some() {
9497 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9498 }
9499 split_backfilled_count__ =
9500 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9501 ;
9502 }
9503 GeneratedField::SplitCompletedCount => {
9504 if split_completed_count__.is_some() {
9505 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9506 }
9507 split_completed_count__ =
9508 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9509 ;
9510 }
9511 }
9512 }
9513 Ok(list_cdc_progress_response::CdcProgress {
9514 split_total_count: split_total_count__.unwrap_or_default(),
9515 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
9516 split_completed_count: split_completed_count__.unwrap_or_default(),
9517 })
9518 }
9519 }
9520 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
9521 }
9522}
9523impl serde::Serialize for ListCreatingFragmentDistributionRequest {
9524 #[allow(deprecated)]
9525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9526 where
9527 S: serde::Serializer,
9528 {
9529 use serde::ser::SerializeStruct;
9530 let len = 0;
9531 let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
9532 struct_ser.end()
9533 }
9534}
9535impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
9536 #[allow(deprecated)]
9537 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9538 where
9539 D: serde::Deserializer<'de>,
9540 {
9541 const FIELDS: &[&str] = &[
9542 ];
9543
9544 #[allow(clippy::enum_variant_names)]
9545 enum GeneratedField {
9546 }
9547 impl<'de> serde::Deserialize<'de> for GeneratedField {
9548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9549 where
9550 D: serde::Deserializer<'de>,
9551 {
9552 struct GeneratedVisitor;
9553
9554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9555 type Value = GeneratedField;
9556
9557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9558 write!(formatter, "expected one of: {:?}", &FIELDS)
9559 }
9560
9561 #[allow(unused_variables)]
9562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9563 where
9564 E: serde::de::Error,
9565 {
9566 Err(serde::de::Error::unknown_field(value, FIELDS))
9567 }
9568 }
9569 deserializer.deserialize_identifier(GeneratedVisitor)
9570 }
9571 }
9572 struct GeneratedVisitor;
9573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9574 type Value = ListCreatingFragmentDistributionRequest;
9575
9576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9577 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
9578 }
9579
9580 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
9581 where
9582 V: serde::de::MapAccess<'de>,
9583 {
9584 while map_.next_key::<GeneratedField>()?.is_some() {
9585 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9586 }
9587 Ok(ListCreatingFragmentDistributionRequest {
9588 })
9589 }
9590 }
9591 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9592 }
9593}
9594impl serde::Serialize for ListCreatingFragmentDistributionResponse {
9595 #[allow(deprecated)]
9596 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9597 where
9598 S: serde::Serializer,
9599 {
9600 use serde::ser::SerializeStruct;
9601 let mut len = 0;
9602 if !self.distributions.is_empty() {
9603 len += 1;
9604 }
9605 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
9606 if !self.distributions.is_empty() {
9607 struct_ser.serialize_field("distributions", &self.distributions)?;
9608 }
9609 struct_ser.end()
9610 }
9611}
9612impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
9613 #[allow(deprecated)]
9614 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9615 where
9616 D: serde::Deserializer<'de>,
9617 {
9618 const FIELDS: &[&str] = &[
9619 "distributions",
9620 ];
9621
9622 #[allow(clippy::enum_variant_names)]
9623 enum GeneratedField {
9624 Distributions,
9625 }
9626 impl<'de> serde::Deserialize<'de> for GeneratedField {
9627 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9628 where
9629 D: serde::Deserializer<'de>,
9630 {
9631 struct GeneratedVisitor;
9632
9633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9634 type Value = GeneratedField;
9635
9636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9637 write!(formatter, "expected one of: {:?}", &FIELDS)
9638 }
9639
9640 #[allow(unused_variables)]
9641 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9642 where
9643 E: serde::de::Error,
9644 {
9645 match value {
9646 "distributions" => Ok(GeneratedField::Distributions),
9647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9648 }
9649 }
9650 }
9651 deserializer.deserialize_identifier(GeneratedVisitor)
9652 }
9653 }
9654 struct GeneratedVisitor;
9655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9656 type Value = ListCreatingFragmentDistributionResponse;
9657
9658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9659 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
9660 }
9661
9662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
9663 where
9664 V: serde::de::MapAccess<'de>,
9665 {
9666 let mut distributions__ = None;
9667 while let Some(k) = map_.next_key()? {
9668 match k {
9669 GeneratedField::Distributions => {
9670 if distributions__.is_some() {
9671 return Err(serde::de::Error::duplicate_field("distributions"));
9672 }
9673 distributions__ = Some(map_.next_value()?);
9674 }
9675 }
9676 }
9677 Ok(ListCreatingFragmentDistributionResponse {
9678 distributions: distributions__.unwrap_or_default(),
9679 })
9680 }
9681 }
9682 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9683 }
9684}
9685impl serde::Serialize for ListEventLogRequest {
9686 #[allow(deprecated)]
9687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9688 where
9689 S: serde::Serializer,
9690 {
9691 use serde::ser::SerializeStruct;
9692 let len = 0;
9693 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
9694 struct_ser.end()
9695 }
9696}
9697impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
9698 #[allow(deprecated)]
9699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9700 where
9701 D: serde::Deserializer<'de>,
9702 {
9703 const FIELDS: &[&str] = &[
9704 ];
9705
9706 #[allow(clippy::enum_variant_names)]
9707 enum GeneratedField {
9708 }
9709 impl<'de> serde::Deserialize<'de> for GeneratedField {
9710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9711 where
9712 D: serde::Deserializer<'de>,
9713 {
9714 struct GeneratedVisitor;
9715
9716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9717 type Value = GeneratedField;
9718
9719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9720 write!(formatter, "expected one of: {:?}", &FIELDS)
9721 }
9722
9723 #[allow(unused_variables)]
9724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9725 where
9726 E: serde::de::Error,
9727 {
9728 Err(serde::de::Error::unknown_field(value, FIELDS))
9729 }
9730 }
9731 deserializer.deserialize_identifier(GeneratedVisitor)
9732 }
9733 }
9734 struct GeneratedVisitor;
9735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9736 type Value = ListEventLogRequest;
9737
9738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9739 formatter.write_str("struct meta.ListEventLogRequest")
9740 }
9741
9742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
9743 where
9744 V: serde::de::MapAccess<'de>,
9745 {
9746 while map_.next_key::<GeneratedField>()?.is_some() {
9747 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9748 }
9749 Ok(ListEventLogRequest {
9750 })
9751 }
9752 }
9753 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
9754 }
9755}
9756impl serde::Serialize for ListEventLogResponse {
9757 #[allow(deprecated)]
9758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9759 where
9760 S: serde::Serializer,
9761 {
9762 use serde::ser::SerializeStruct;
9763 let mut len = 0;
9764 if !self.event_logs.is_empty() {
9765 len += 1;
9766 }
9767 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
9768 if !self.event_logs.is_empty() {
9769 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
9770 }
9771 struct_ser.end()
9772 }
9773}
9774impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
9775 #[allow(deprecated)]
9776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9777 where
9778 D: serde::Deserializer<'de>,
9779 {
9780 const FIELDS: &[&str] = &[
9781 "event_logs",
9782 "eventLogs",
9783 ];
9784
9785 #[allow(clippy::enum_variant_names)]
9786 enum GeneratedField {
9787 EventLogs,
9788 }
9789 impl<'de> serde::Deserialize<'de> for GeneratedField {
9790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9791 where
9792 D: serde::Deserializer<'de>,
9793 {
9794 struct GeneratedVisitor;
9795
9796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9797 type Value = GeneratedField;
9798
9799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9800 write!(formatter, "expected one of: {:?}", &FIELDS)
9801 }
9802
9803 #[allow(unused_variables)]
9804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9805 where
9806 E: serde::de::Error,
9807 {
9808 match value {
9809 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
9810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9811 }
9812 }
9813 }
9814 deserializer.deserialize_identifier(GeneratedVisitor)
9815 }
9816 }
9817 struct GeneratedVisitor;
9818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9819 type Value = ListEventLogResponse;
9820
9821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9822 formatter.write_str("struct meta.ListEventLogResponse")
9823 }
9824
9825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
9826 where
9827 V: serde::de::MapAccess<'de>,
9828 {
9829 let mut event_logs__ = None;
9830 while let Some(k) = map_.next_key()? {
9831 match k {
9832 GeneratedField::EventLogs => {
9833 if event_logs__.is_some() {
9834 return Err(serde::de::Error::duplicate_field("eventLogs"));
9835 }
9836 event_logs__ = Some(map_.next_value()?);
9837 }
9838 }
9839 }
9840 Ok(ListEventLogResponse {
9841 event_logs: event_logs__.unwrap_or_default(),
9842 })
9843 }
9844 }
9845 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
9846 }
9847}
9848impl serde::Serialize for ListFragmentDistributionRequest {
9849 #[allow(deprecated)]
9850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9851 where
9852 S: serde::Serializer,
9853 {
9854 use serde::ser::SerializeStruct;
9855 let len = 0;
9856 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
9857 struct_ser.end()
9858 }
9859}
9860impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
9861 #[allow(deprecated)]
9862 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9863 where
9864 D: serde::Deserializer<'de>,
9865 {
9866 const FIELDS: &[&str] = &[
9867 ];
9868
9869 #[allow(clippy::enum_variant_names)]
9870 enum GeneratedField {
9871 }
9872 impl<'de> serde::Deserialize<'de> for GeneratedField {
9873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9874 where
9875 D: serde::Deserializer<'de>,
9876 {
9877 struct GeneratedVisitor;
9878
9879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9880 type Value = GeneratedField;
9881
9882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9883 write!(formatter, "expected one of: {:?}", &FIELDS)
9884 }
9885
9886 #[allow(unused_variables)]
9887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9888 where
9889 E: serde::de::Error,
9890 {
9891 Err(serde::de::Error::unknown_field(value, FIELDS))
9892 }
9893 }
9894 deserializer.deserialize_identifier(GeneratedVisitor)
9895 }
9896 }
9897 struct GeneratedVisitor;
9898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9899 type Value = ListFragmentDistributionRequest;
9900
9901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9902 formatter.write_str("struct meta.ListFragmentDistributionRequest")
9903 }
9904
9905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
9906 where
9907 V: serde::de::MapAccess<'de>,
9908 {
9909 while map_.next_key::<GeneratedField>()?.is_some() {
9910 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9911 }
9912 Ok(ListFragmentDistributionRequest {
9913 })
9914 }
9915 }
9916 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9917 }
9918}
9919impl serde::Serialize for ListFragmentDistributionResponse {
9920 #[allow(deprecated)]
9921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9922 where
9923 S: serde::Serializer,
9924 {
9925 use serde::ser::SerializeStruct;
9926 let mut len = 0;
9927 if !self.distributions.is_empty() {
9928 len += 1;
9929 }
9930 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
9931 if !self.distributions.is_empty() {
9932 struct_ser.serialize_field("distributions", &self.distributions)?;
9933 }
9934 struct_ser.end()
9935 }
9936}
9937impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
9938 #[allow(deprecated)]
9939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9940 where
9941 D: serde::Deserializer<'de>,
9942 {
9943 const FIELDS: &[&str] = &[
9944 "distributions",
9945 ];
9946
9947 #[allow(clippy::enum_variant_names)]
9948 enum GeneratedField {
9949 Distributions,
9950 }
9951 impl<'de> serde::Deserialize<'de> for GeneratedField {
9952 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9953 where
9954 D: serde::Deserializer<'de>,
9955 {
9956 struct GeneratedVisitor;
9957
9958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9959 type Value = GeneratedField;
9960
9961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9962 write!(formatter, "expected one of: {:?}", &FIELDS)
9963 }
9964
9965 #[allow(unused_variables)]
9966 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9967 where
9968 E: serde::de::Error,
9969 {
9970 match value {
9971 "distributions" => Ok(GeneratedField::Distributions),
9972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9973 }
9974 }
9975 }
9976 deserializer.deserialize_identifier(GeneratedVisitor)
9977 }
9978 }
9979 struct GeneratedVisitor;
9980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9981 type Value = ListFragmentDistributionResponse;
9982
9983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9984 formatter.write_str("struct meta.ListFragmentDistributionResponse")
9985 }
9986
9987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9988 where
9989 V: serde::de::MapAccess<'de>,
9990 {
9991 let mut distributions__ = None;
9992 while let Some(k) = map_.next_key()? {
9993 match k {
9994 GeneratedField::Distributions => {
9995 if distributions__.is_some() {
9996 return Err(serde::de::Error::duplicate_field("distributions"));
9997 }
9998 distributions__ = Some(map_.next_value()?);
9999 }
10000 }
10001 }
10002 Ok(ListFragmentDistributionResponse {
10003 distributions: distributions__.unwrap_or_default(),
10004 })
10005 }
10006 }
10007 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
10008 }
10009}
10010impl serde::Serialize for ListIcebergTablesRequest {
10011 #[allow(deprecated)]
10012 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10013 where
10014 S: serde::Serializer,
10015 {
10016 use serde::ser::SerializeStruct;
10017 let len = 0;
10018 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
10019 struct_ser.end()
10020 }
10021}
10022impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
10023 #[allow(deprecated)]
10024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10025 where
10026 D: serde::Deserializer<'de>,
10027 {
10028 const FIELDS: &[&str] = &[
10029 ];
10030
10031 #[allow(clippy::enum_variant_names)]
10032 enum GeneratedField {
10033 }
10034 impl<'de> serde::Deserialize<'de> for GeneratedField {
10035 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10036 where
10037 D: serde::Deserializer<'de>,
10038 {
10039 struct GeneratedVisitor;
10040
10041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10042 type Value = GeneratedField;
10043
10044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10045 write!(formatter, "expected one of: {:?}", &FIELDS)
10046 }
10047
10048 #[allow(unused_variables)]
10049 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10050 where
10051 E: serde::de::Error,
10052 {
10053 Err(serde::de::Error::unknown_field(value, FIELDS))
10054 }
10055 }
10056 deserializer.deserialize_identifier(GeneratedVisitor)
10057 }
10058 }
10059 struct GeneratedVisitor;
10060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10061 type Value = ListIcebergTablesRequest;
10062
10063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10064 formatter.write_str("struct meta.ListIcebergTablesRequest")
10065 }
10066
10067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
10068 where
10069 V: serde::de::MapAccess<'de>,
10070 {
10071 while map_.next_key::<GeneratedField>()?.is_some() {
10072 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10073 }
10074 Ok(ListIcebergTablesRequest {
10075 })
10076 }
10077 }
10078 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
10079 }
10080}
10081impl serde::Serialize for ListIcebergTablesResponse {
10082 #[allow(deprecated)]
10083 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10084 where
10085 S: serde::Serializer,
10086 {
10087 use serde::ser::SerializeStruct;
10088 let mut len = 0;
10089 if !self.iceberg_tables.is_empty() {
10090 len += 1;
10091 }
10092 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
10093 if !self.iceberg_tables.is_empty() {
10094 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
10095 }
10096 struct_ser.end()
10097 }
10098}
10099impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
10100 #[allow(deprecated)]
10101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10102 where
10103 D: serde::Deserializer<'de>,
10104 {
10105 const FIELDS: &[&str] = &[
10106 "iceberg_tables",
10107 "icebergTables",
10108 ];
10109
10110 #[allow(clippy::enum_variant_names)]
10111 enum GeneratedField {
10112 IcebergTables,
10113 }
10114 impl<'de> serde::Deserialize<'de> for GeneratedField {
10115 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10116 where
10117 D: serde::Deserializer<'de>,
10118 {
10119 struct GeneratedVisitor;
10120
10121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10122 type Value = GeneratedField;
10123
10124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10125 write!(formatter, "expected one of: {:?}", &FIELDS)
10126 }
10127
10128 #[allow(unused_variables)]
10129 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10130 where
10131 E: serde::de::Error,
10132 {
10133 match value {
10134 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
10135 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10136 }
10137 }
10138 }
10139 deserializer.deserialize_identifier(GeneratedVisitor)
10140 }
10141 }
10142 struct GeneratedVisitor;
10143 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10144 type Value = ListIcebergTablesResponse;
10145
10146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10147 formatter.write_str("struct meta.ListIcebergTablesResponse")
10148 }
10149
10150 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
10151 where
10152 V: serde::de::MapAccess<'de>,
10153 {
10154 let mut iceberg_tables__ = None;
10155 while let Some(k) = map_.next_key()? {
10156 match k {
10157 GeneratedField::IcebergTables => {
10158 if iceberg_tables__.is_some() {
10159 return Err(serde::de::Error::duplicate_field("icebergTables"));
10160 }
10161 iceberg_tables__ = Some(map_.next_value()?);
10162 }
10163 }
10164 }
10165 Ok(ListIcebergTablesResponse {
10166 iceberg_tables: iceberg_tables__.unwrap_or_default(),
10167 })
10168 }
10169 }
10170 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
10171 }
10172}
10173impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
10174 #[allow(deprecated)]
10175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10176 where
10177 S: serde::Serializer,
10178 {
10179 use serde::ser::SerializeStruct;
10180 let mut len = 0;
10181 if !self.catalog_name.is_empty() {
10182 len += 1;
10183 }
10184 if !self.table_namespace.is_empty() {
10185 len += 1;
10186 }
10187 if !self.table_name.is_empty() {
10188 len += 1;
10189 }
10190 if self.metadata_location.is_some() {
10191 len += 1;
10192 }
10193 if self.previous_metadata_location.is_some() {
10194 len += 1;
10195 }
10196 if self.iceberg_type.is_some() {
10197 len += 1;
10198 }
10199 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
10200 if !self.catalog_name.is_empty() {
10201 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
10202 }
10203 if !self.table_namespace.is_empty() {
10204 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
10205 }
10206 if !self.table_name.is_empty() {
10207 struct_ser.serialize_field("tableName", &self.table_name)?;
10208 }
10209 if let Some(v) = self.metadata_location.as_ref() {
10210 struct_ser.serialize_field("metadataLocation", v)?;
10211 }
10212 if let Some(v) = self.previous_metadata_location.as_ref() {
10213 struct_ser.serialize_field("previousMetadataLocation", v)?;
10214 }
10215 if let Some(v) = self.iceberg_type.as_ref() {
10216 struct_ser.serialize_field("icebergType", v)?;
10217 }
10218 struct_ser.end()
10219 }
10220}
10221impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
10222 #[allow(deprecated)]
10223 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10224 where
10225 D: serde::Deserializer<'de>,
10226 {
10227 const FIELDS: &[&str] = &[
10228 "catalog_name",
10229 "catalogName",
10230 "table_namespace",
10231 "tableNamespace",
10232 "table_name",
10233 "tableName",
10234 "metadata_location",
10235 "metadataLocation",
10236 "previous_metadata_location",
10237 "previousMetadataLocation",
10238 "iceberg_type",
10239 "icebergType",
10240 ];
10241
10242 #[allow(clippy::enum_variant_names)]
10243 enum GeneratedField {
10244 CatalogName,
10245 TableNamespace,
10246 TableName,
10247 MetadataLocation,
10248 PreviousMetadataLocation,
10249 IcebergType,
10250 }
10251 impl<'de> serde::Deserialize<'de> for GeneratedField {
10252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10253 where
10254 D: serde::Deserializer<'de>,
10255 {
10256 struct GeneratedVisitor;
10257
10258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10259 type Value = GeneratedField;
10260
10261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10262 write!(formatter, "expected one of: {:?}", &FIELDS)
10263 }
10264
10265 #[allow(unused_variables)]
10266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10267 where
10268 E: serde::de::Error,
10269 {
10270 match value {
10271 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
10272 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
10273 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10274 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
10275 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
10276 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
10277 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10278 }
10279 }
10280 }
10281 deserializer.deserialize_identifier(GeneratedVisitor)
10282 }
10283 }
10284 struct GeneratedVisitor;
10285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10286 type Value = list_iceberg_tables_response::IcebergTable;
10287
10288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10289 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
10290 }
10291
10292 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
10293 where
10294 V: serde::de::MapAccess<'de>,
10295 {
10296 let mut catalog_name__ = None;
10297 let mut table_namespace__ = None;
10298 let mut table_name__ = None;
10299 let mut metadata_location__ = None;
10300 let mut previous_metadata_location__ = None;
10301 let mut iceberg_type__ = None;
10302 while let Some(k) = map_.next_key()? {
10303 match k {
10304 GeneratedField::CatalogName => {
10305 if catalog_name__.is_some() {
10306 return Err(serde::de::Error::duplicate_field("catalogName"));
10307 }
10308 catalog_name__ = Some(map_.next_value()?);
10309 }
10310 GeneratedField::TableNamespace => {
10311 if table_namespace__.is_some() {
10312 return Err(serde::de::Error::duplicate_field("tableNamespace"));
10313 }
10314 table_namespace__ = Some(map_.next_value()?);
10315 }
10316 GeneratedField::TableName => {
10317 if table_name__.is_some() {
10318 return Err(serde::de::Error::duplicate_field("tableName"));
10319 }
10320 table_name__ = Some(map_.next_value()?);
10321 }
10322 GeneratedField::MetadataLocation => {
10323 if metadata_location__.is_some() {
10324 return Err(serde::de::Error::duplicate_field("metadataLocation"));
10325 }
10326 metadata_location__ = map_.next_value()?;
10327 }
10328 GeneratedField::PreviousMetadataLocation => {
10329 if previous_metadata_location__.is_some() {
10330 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
10331 }
10332 previous_metadata_location__ = map_.next_value()?;
10333 }
10334 GeneratedField::IcebergType => {
10335 if iceberg_type__.is_some() {
10336 return Err(serde::de::Error::duplicate_field("icebergType"));
10337 }
10338 iceberg_type__ = map_.next_value()?;
10339 }
10340 }
10341 }
10342 Ok(list_iceberg_tables_response::IcebergTable {
10343 catalog_name: catalog_name__.unwrap_or_default(),
10344 table_namespace: table_namespace__.unwrap_or_default(),
10345 table_name: table_name__.unwrap_or_default(),
10346 metadata_location: metadata_location__,
10347 previous_metadata_location: previous_metadata_location__,
10348 iceberg_type: iceberg_type__,
10349 })
10350 }
10351 }
10352 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
10353 }
10354}
10355impl serde::Serialize for ListObjectDependenciesRequest {
10356 #[allow(deprecated)]
10357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10358 where
10359 S: serde::Serializer,
10360 {
10361 use serde::ser::SerializeStruct;
10362 let len = 0;
10363 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
10364 struct_ser.end()
10365 }
10366}
10367impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
10368 #[allow(deprecated)]
10369 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10370 where
10371 D: serde::Deserializer<'de>,
10372 {
10373 const FIELDS: &[&str] = &[
10374 ];
10375
10376 #[allow(clippy::enum_variant_names)]
10377 enum GeneratedField {
10378 }
10379 impl<'de> serde::Deserialize<'de> for GeneratedField {
10380 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10381 where
10382 D: serde::Deserializer<'de>,
10383 {
10384 struct GeneratedVisitor;
10385
10386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10387 type Value = GeneratedField;
10388
10389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10390 write!(formatter, "expected one of: {:?}", &FIELDS)
10391 }
10392
10393 #[allow(unused_variables)]
10394 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10395 where
10396 E: serde::de::Error,
10397 {
10398 Err(serde::de::Error::unknown_field(value, FIELDS))
10399 }
10400 }
10401 deserializer.deserialize_identifier(GeneratedVisitor)
10402 }
10403 }
10404 struct GeneratedVisitor;
10405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10406 type Value = ListObjectDependenciesRequest;
10407
10408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10409 formatter.write_str("struct meta.ListObjectDependenciesRequest")
10410 }
10411
10412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
10413 where
10414 V: serde::de::MapAccess<'de>,
10415 {
10416 while map_.next_key::<GeneratedField>()?.is_some() {
10417 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10418 }
10419 Ok(ListObjectDependenciesRequest {
10420 })
10421 }
10422 }
10423 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
10424 }
10425}
10426impl serde::Serialize for ListObjectDependenciesResponse {
10427 #[allow(deprecated)]
10428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10429 where
10430 S: serde::Serializer,
10431 {
10432 use serde::ser::SerializeStruct;
10433 let mut len = 0;
10434 if !self.dependencies.is_empty() {
10435 len += 1;
10436 }
10437 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
10438 if !self.dependencies.is_empty() {
10439 struct_ser.serialize_field("dependencies", &self.dependencies)?;
10440 }
10441 struct_ser.end()
10442 }
10443}
10444impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
10445 #[allow(deprecated)]
10446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10447 where
10448 D: serde::Deserializer<'de>,
10449 {
10450 const FIELDS: &[&str] = &[
10451 "dependencies",
10452 ];
10453
10454 #[allow(clippy::enum_variant_names)]
10455 enum GeneratedField {
10456 Dependencies,
10457 }
10458 impl<'de> serde::Deserialize<'de> for GeneratedField {
10459 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10460 where
10461 D: serde::Deserializer<'de>,
10462 {
10463 struct GeneratedVisitor;
10464
10465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10466 type Value = GeneratedField;
10467
10468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10469 write!(formatter, "expected one of: {:?}", &FIELDS)
10470 }
10471
10472 #[allow(unused_variables)]
10473 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10474 where
10475 E: serde::de::Error,
10476 {
10477 match value {
10478 "dependencies" => Ok(GeneratedField::Dependencies),
10479 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10480 }
10481 }
10482 }
10483 deserializer.deserialize_identifier(GeneratedVisitor)
10484 }
10485 }
10486 struct GeneratedVisitor;
10487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10488 type Value = ListObjectDependenciesResponse;
10489
10490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10491 formatter.write_str("struct meta.ListObjectDependenciesResponse")
10492 }
10493
10494 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
10495 where
10496 V: serde::de::MapAccess<'de>,
10497 {
10498 let mut dependencies__ = None;
10499 while let Some(k) = map_.next_key()? {
10500 match k {
10501 GeneratedField::Dependencies => {
10502 if dependencies__.is_some() {
10503 return Err(serde::de::Error::duplicate_field("dependencies"));
10504 }
10505 dependencies__ = Some(map_.next_value()?);
10506 }
10507 }
10508 }
10509 Ok(ListObjectDependenciesResponse {
10510 dependencies: dependencies__.unwrap_or_default(),
10511 })
10512 }
10513 }
10514 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
10515 }
10516}
10517impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
10518 #[allow(deprecated)]
10519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10520 where
10521 S: serde::Serializer,
10522 {
10523 use serde::ser::SerializeStruct;
10524 let mut len = 0;
10525 if self.object_id != 0 {
10526 len += 1;
10527 }
10528 if self.referenced_object_id != 0 {
10529 len += 1;
10530 }
10531 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
10532 if self.object_id != 0 {
10533 struct_ser.serialize_field("objectId", &self.object_id)?;
10534 }
10535 if self.referenced_object_id != 0 {
10536 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
10537 }
10538 struct_ser.end()
10539 }
10540}
10541impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
10542 #[allow(deprecated)]
10543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10544 where
10545 D: serde::Deserializer<'de>,
10546 {
10547 const FIELDS: &[&str] = &[
10548 "object_id",
10549 "objectId",
10550 "referenced_object_id",
10551 "referencedObjectId",
10552 ];
10553
10554 #[allow(clippy::enum_variant_names)]
10555 enum GeneratedField {
10556 ObjectId,
10557 ReferencedObjectId,
10558 }
10559 impl<'de> serde::Deserialize<'de> for GeneratedField {
10560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10561 where
10562 D: serde::Deserializer<'de>,
10563 {
10564 struct GeneratedVisitor;
10565
10566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10567 type Value = GeneratedField;
10568
10569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10570 write!(formatter, "expected one of: {:?}", &FIELDS)
10571 }
10572
10573 #[allow(unused_variables)]
10574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10575 where
10576 E: serde::de::Error,
10577 {
10578 match value {
10579 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
10580 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
10581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10582 }
10583 }
10584 }
10585 deserializer.deserialize_identifier(GeneratedVisitor)
10586 }
10587 }
10588 struct GeneratedVisitor;
10589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10590 type Value = list_object_dependencies_response::ObjectDependencies;
10591
10592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10593 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
10594 }
10595
10596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
10597 where
10598 V: serde::de::MapAccess<'de>,
10599 {
10600 let mut object_id__ = None;
10601 let mut referenced_object_id__ = None;
10602 while let Some(k) = map_.next_key()? {
10603 match k {
10604 GeneratedField::ObjectId => {
10605 if object_id__.is_some() {
10606 return Err(serde::de::Error::duplicate_field("objectId"));
10607 }
10608 object_id__ =
10609 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10610 ;
10611 }
10612 GeneratedField::ReferencedObjectId => {
10613 if referenced_object_id__.is_some() {
10614 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
10615 }
10616 referenced_object_id__ =
10617 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10618 ;
10619 }
10620 }
10621 }
10622 Ok(list_object_dependencies_response::ObjectDependencies {
10623 object_id: object_id__.unwrap_or_default(),
10624 referenced_object_id: referenced_object_id__.unwrap_or_default(),
10625 })
10626 }
10627 }
10628 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
10629 }
10630}
10631impl serde::Serialize for ListRateLimitsRequest {
10632 #[allow(deprecated)]
10633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10634 where
10635 S: serde::Serializer,
10636 {
10637 use serde::ser::SerializeStruct;
10638 let len = 0;
10639 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10640 struct_ser.end()
10641 }
10642}
10643impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10644 #[allow(deprecated)]
10645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10646 where
10647 D: serde::Deserializer<'de>,
10648 {
10649 const FIELDS: &[&str] = &[
10650 ];
10651
10652 #[allow(clippy::enum_variant_names)]
10653 enum GeneratedField {
10654 }
10655 impl<'de> serde::Deserialize<'de> for GeneratedField {
10656 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10657 where
10658 D: serde::Deserializer<'de>,
10659 {
10660 struct GeneratedVisitor;
10661
10662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10663 type Value = GeneratedField;
10664
10665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10666 write!(formatter, "expected one of: {:?}", &FIELDS)
10667 }
10668
10669 #[allow(unused_variables)]
10670 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10671 where
10672 E: serde::de::Error,
10673 {
10674 Err(serde::de::Error::unknown_field(value, FIELDS))
10675 }
10676 }
10677 deserializer.deserialize_identifier(GeneratedVisitor)
10678 }
10679 }
10680 struct GeneratedVisitor;
10681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10682 type Value = ListRateLimitsRequest;
10683
10684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10685 formatter.write_str("struct meta.ListRateLimitsRequest")
10686 }
10687
10688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10689 where
10690 V: serde::de::MapAccess<'de>,
10691 {
10692 while map_.next_key::<GeneratedField>()?.is_some() {
10693 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10694 }
10695 Ok(ListRateLimitsRequest {
10696 })
10697 }
10698 }
10699 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10700 }
10701}
10702impl serde::Serialize for ListRateLimitsResponse {
10703 #[allow(deprecated)]
10704 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10705 where
10706 S: serde::Serializer,
10707 {
10708 use serde::ser::SerializeStruct;
10709 let mut len = 0;
10710 if !self.rate_limits.is_empty() {
10711 len += 1;
10712 }
10713 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10714 if !self.rate_limits.is_empty() {
10715 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10716 }
10717 struct_ser.end()
10718 }
10719}
10720impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10721 #[allow(deprecated)]
10722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10723 where
10724 D: serde::Deserializer<'de>,
10725 {
10726 const FIELDS: &[&str] = &[
10727 "rate_limits",
10728 "rateLimits",
10729 ];
10730
10731 #[allow(clippy::enum_variant_names)]
10732 enum GeneratedField {
10733 RateLimits,
10734 }
10735 impl<'de> serde::Deserialize<'de> for GeneratedField {
10736 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10737 where
10738 D: serde::Deserializer<'de>,
10739 {
10740 struct GeneratedVisitor;
10741
10742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10743 type Value = GeneratedField;
10744
10745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10746 write!(formatter, "expected one of: {:?}", &FIELDS)
10747 }
10748
10749 #[allow(unused_variables)]
10750 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10751 where
10752 E: serde::de::Error,
10753 {
10754 match value {
10755 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10756 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10757 }
10758 }
10759 }
10760 deserializer.deserialize_identifier(GeneratedVisitor)
10761 }
10762 }
10763 struct GeneratedVisitor;
10764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10765 type Value = ListRateLimitsResponse;
10766
10767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10768 formatter.write_str("struct meta.ListRateLimitsResponse")
10769 }
10770
10771 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
10772 where
10773 V: serde::de::MapAccess<'de>,
10774 {
10775 let mut rate_limits__ = None;
10776 while let Some(k) = map_.next_key()? {
10777 match k {
10778 GeneratedField::RateLimits => {
10779 if rate_limits__.is_some() {
10780 return Err(serde::de::Error::duplicate_field("rateLimits"));
10781 }
10782 rate_limits__ = Some(map_.next_value()?);
10783 }
10784 }
10785 }
10786 Ok(ListRateLimitsResponse {
10787 rate_limits: rate_limits__.unwrap_or_default(),
10788 })
10789 }
10790 }
10791 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
10792 }
10793}
10794impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
10795 #[allow(deprecated)]
10796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10797 where
10798 S: serde::Serializer,
10799 {
10800 use serde::ser::SerializeStruct;
10801 let mut len = 0;
10802 if self.fragment_id != 0 {
10803 len += 1;
10804 }
10805 if self.job_id != 0 {
10806 len += 1;
10807 }
10808 if self.fragment_type_mask != 0 {
10809 len += 1;
10810 }
10811 if self.rate_limit != 0 {
10812 len += 1;
10813 }
10814 if !self.node_name.is_empty() {
10815 len += 1;
10816 }
10817 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
10818 if self.fragment_id != 0 {
10819 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10820 }
10821 if self.job_id != 0 {
10822 struct_ser.serialize_field("jobId", &self.job_id)?;
10823 }
10824 if self.fragment_type_mask != 0 {
10825 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10826 }
10827 if self.rate_limit != 0 {
10828 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
10829 }
10830 if !self.node_name.is_empty() {
10831 struct_ser.serialize_field("nodeName", &self.node_name)?;
10832 }
10833 struct_ser.end()
10834 }
10835}
10836impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
10837 #[allow(deprecated)]
10838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10839 where
10840 D: serde::Deserializer<'de>,
10841 {
10842 const FIELDS: &[&str] = &[
10843 "fragment_id",
10844 "fragmentId",
10845 "job_id",
10846 "jobId",
10847 "fragment_type_mask",
10848 "fragmentTypeMask",
10849 "rate_limit",
10850 "rateLimit",
10851 "node_name",
10852 "nodeName",
10853 ];
10854
10855 #[allow(clippy::enum_variant_names)]
10856 enum GeneratedField {
10857 FragmentId,
10858 JobId,
10859 FragmentTypeMask,
10860 RateLimit,
10861 NodeName,
10862 }
10863 impl<'de> serde::Deserialize<'de> for GeneratedField {
10864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10865 where
10866 D: serde::Deserializer<'de>,
10867 {
10868 struct GeneratedVisitor;
10869
10870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10871 type Value = GeneratedField;
10872
10873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10874 write!(formatter, "expected one of: {:?}", &FIELDS)
10875 }
10876
10877 #[allow(unused_variables)]
10878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10879 where
10880 E: serde::de::Error,
10881 {
10882 match value {
10883 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10884 "jobId" | "job_id" => Ok(GeneratedField::JobId),
10885 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10886 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10887 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
10888 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10889 }
10890 }
10891 }
10892 deserializer.deserialize_identifier(GeneratedVisitor)
10893 }
10894 }
10895 struct GeneratedVisitor;
10896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10897 type Value = list_rate_limits_response::RateLimitInfo;
10898
10899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10900 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
10901 }
10902
10903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
10904 where
10905 V: serde::de::MapAccess<'de>,
10906 {
10907 let mut fragment_id__ = None;
10908 let mut job_id__ = None;
10909 let mut fragment_type_mask__ = None;
10910 let mut rate_limit__ = None;
10911 let mut node_name__ = None;
10912 while let Some(k) = map_.next_key()? {
10913 match k {
10914 GeneratedField::FragmentId => {
10915 if fragment_id__.is_some() {
10916 return Err(serde::de::Error::duplicate_field("fragmentId"));
10917 }
10918 fragment_id__ =
10919 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10920 ;
10921 }
10922 GeneratedField::JobId => {
10923 if job_id__.is_some() {
10924 return Err(serde::de::Error::duplicate_field("jobId"));
10925 }
10926 job_id__ =
10927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10928 ;
10929 }
10930 GeneratedField::FragmentTypeMask => {
10931 if fragment_type_mask__.is_some() {
10932 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10933 }
10934 fragment_type_mask__ =
10935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10936 ;
10937 }
10938 GeneratedField::RateLimit => {
10939 if rate_limit__.is_some() {
10940 return Err(serde::de::Error::duplicate_field("rateLimit"));
10941 }
10942 rate_limit__ =
10943 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10944 ;
10945 }
10946 GeneratedField::NodeName => {
10947 if node_name__.is_some() {
10948 return Err(serde::de::Error::duplicate_field("nodeName"));
10949 }
10950 node_name__ = Some(map_.next_value()?);
10951 }
10952 }
10953 }
10954 Ok(list_rate_limits_response::RateLimitInfo {
10955 fragment_id: fragment_id__.unwrap_or_default(),
10956 job_id: job_id__.unwrap_or_default(),
10957 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10958 rate_limit: rate_limit__.unwrap_or_default(),
10959 node_name: node_name__.unwrap_or_default(),
10960 })
10961 }
10962 }
10963 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10964 }
10965}
10966impl serde::Serialize for ListRefreshTableStatesRequest {
10967 #[allow(deprecated)]
10968 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10969 where
10970 S: serde::Serializer,
10971 {
10972 use serde::ser::SerializeStruct;
10973 let len = 0;
10974 let struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesRequest", len)?;
10975 struct_ser.end()
10976 }
10977}
10978impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesRequest {
10979 #[allow(deprecated)]
10980 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10981 where
10982 D: serde::Deserializer<'de>,
10983 {
10984 const FIELDS: &[&str] = &[
10985 ];
10986
10987 #[allow(clippy::enum_variant_names)]
10988 enum GeneratedField {
10989 }
10990 impl<'de> serde::Deserialize<'de> for GeneratedField {
10991 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10992 where
10993 D: serde::Deserializer<'de>,
10994 {
10995 struct GeneratedVisitor;
10996
10997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10998 type Value = GeneratedField;
10999
11000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11001 write!(formatter, "expected one of: {:?}", &FIELDS)
11002 }
11003
11004 #[allow(unused_variables)]
11005 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11006 where
11007 E: serde::de::Error,
11008 {
11009 Err(serde::de::Error::unknown_field(value, FIELDS))
11010 }
11011 }
11012 deserializer.deserialize_identifier(GeneratedVisitor)
11013 }
11014 }
11015 struct GeneratedVisitor;
11016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11017 type Value = ListRefreshTableStatesRequest;
11018
11019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11020 formatter.write_str("struct meta.ListRefreshTableStatesRequest")
11021 }
11022
11023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesRequest, V::Error>
11024 where
11025 V: serde::de::MapAccess<'de>,
11026 {
11027 while map_.next_key::<GeneratedField>()?.is_some() {
11028 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11029 }
11030 Ok(ListRefreshTableStatesRequest {
11031 })
11032 }
11033 }
11034 deserializer.deserialize_struct("meta.ListRefreshTableStatesRequest", FIELDS, GeneratedVisitor)
11035 }
11036}
11037impl serde::Serialize for ListRefreshTableStatesResponse {
11038 #[allow(deprecated)]
11039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11040 where
11041 S: serde::Serializer,
11042 {
11043 use serde::ser::SerializeStruct;
11044 let mut len = 0;
11045 if !self.states.is_empty() {
11046 len += 1;
11047 }
11048 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse", len)?;
11049 if !self.states.is_empty() {
11050 struct_ser.serialize_field("states", &self.states)?;
11051 }
11052 struct_ser.end()
11053 }
11054}
11055impl<'de> serde::Deserialize<'de> for ListRefreshTableStatesResponse {
11056 #[allow(deprecated)]
11057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11058 where
11059 D: serde::Deserializer<'de>,
11060 {
11061 const FIELDS: &[&str] = &[
11062 "states",
11063 ];
11064
11065 #[allow(clippy::enum_variant_names)]
11066 enum GeneratedField {
11067 States,
11068 }
11069 impl<'de> serde::Deserialize<'de> for GeneratedField {
11070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11071 where
11072 D: serde::Deserializer<'de>,
11073 {
11074 struct GeneratedVisitor;
11075
11076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11077 type Value = GeneratedField;
11078
11079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11080 write!(formatter, "expected one of: {:?}", &FIELDS)
11081 }
11082
11083 #[allow(unused_variables)]
11084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11085 where
11086 E: serde::de::Error,
11087 {
11088 match value {
11089 "states" => Ok(GeneratedField::States),
11090 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11091 }
11092 }
11093 }
11094 deserializer.deserialize_identifier(GeneratedVisitor)
11095 }
11096 }
11097 struct GeneratedVisitor;
11098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11099 type Value = ListRefreshTableStatesResponse;
11100
11101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11102 formatter.write_str("struct meta.ListRefreshTableStatesResponse")
11103 }
11104
11105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRefreshTableStatesResponse, V::Error>
11106 where
11107 V: serde::de::MapAccess<'de>,
11108 {
11109 let mut states__ = None;
11110 while let Some(k) = map_.next_key()? {
11111 match k {
11112 GeneratedField::States => {
11113 if states__.is_some() {
11114 return Err(serde::de::Error::duplicate_field("states"));
11115 }
11116 states__ = Some(map_.next_value()?);
11117 }
11118 }
11119 }
11120 Ok(ListRefreshTableStatesResponse {
11121 states: states__.unwrap_or_default(),
11122 })
11123 }
11124 }
11125 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse", FIELDS, GeneratedVisitor)
11126 }
11127}
11128impl serde::Serialize for list_refresh_table_states_response::RefreshTableState {
11129 #[allow(deprecated)]
11130 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11131 where
11132 S: serde::Serializer,
11133 {
11134 use serde::ser::SerializeStruct;
11135 let mut len = 0;
11136 if self.table_id != 0 {
11137 len += 1;
11138 }
11139 if !self.current_status.is_empty() {
11140 len += 1;
11141 }
11142 if self.last_trigger_time.is_some() {
11143 len += 1;
11144 }
11145 if self.trigger_interval_secs.is_some() {
11146 len += 1;
11147 }
11148 if self.last_success_time.is_some() {
11149 len += 1;
11150 }
11151 let mut struct_ser = serializer.serialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", len)?;
11152 if self.table_id != 0 {
11153 struct_ser.serialize_field("tableId", &self.table_id)?;
11154 }
11155 if !self.current_status.is_empty() {
11156 struct_ser.serialize_field("currentStatus", &self.current_status)?;
11157 }
11158 if let Some(v) = self.last_trigger_time.as_ref() {
11159 struct_ser.serialize_field("lastTriggerTime", v)?;
11160 }
11161 if let Some(v) = self.trigger_interval_secs.as_ref() {
11162 #[allow(clippy::needless_borrow)]
11163 #[allow(clippy::needless_borrows_for_generic_args)]
11164 struct_ser.serialize_field("triggerIntervalSecs", ToString::to_string(&v).as_str())?;
11165 }
11166 if let Some(v) = self.last_success_time.as_ref() {
11167 struct_ser.serialize_field("lastSuccessTime", v)?;
11168 }
11169 struct_ser.end()
11170 }
11171}
11172impl<'de> serde::Deserialize<'de> for list_refresh_table_states_response::RefreshTableState {
11173 #[allow(deprecated)]
11174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11175 where
11176 D: serde::Deserializer<'de>,
11177 {
11178 const FIELDS: &[&str] = &[
11179 "table_id",
11180 "tableId",
11181 "current_status",
11182 "currentStatus",
11183 "last_trigger_time",
11184 "lastTriggerTime",
11185 "trigger_interval_secs",
11186 "triggerIntervalSecs",
11187 "last_success_time",
11188 "lastSuccessTime",
11189 ];
11190
11191 #[allow(clippy::enum_variant_names)]
11192 enum GeneratedField {
11193 TableId,
11194 CurrentStatus,
11195 LastTriggerTime,
11196 TriggerIntervalSecs,
11197 LastSuccessTime,
11198 }
11199 impl<'de> serde::Deserialize<'de> for GeneratedField {
11200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11201 where
11202 D: serde::Deserializer<'de>,
11203 {
11204 struct GeneratedVisitor;
11205
11206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11207 type Value = GeneratedField;
11208
11209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11210 write!(formatter, "expected one of: {:?}", &FIELDS)
11211 }
11212
11213 #[allow(unused_variables)]
11214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11215 where
11216 E: serde::de::Error,
11217 {
11218 match value {
11219 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11220 "currentStatus" | "current_status" => Ok(GeneratedField::CurrentStatus),
11221 "lastTriggerTime" | "last_trigger_time" => Ok(GeneratedField::LastTriggerTime),
11222 "triggerIntervalSecs" | "trigger_interval_secs" => Ok(GeneratedField::TriggerIntervalSecs),
11223 "lastSuccessTime" | "last_success_time" => Ok(GeneratedField::LastSuccessTime),
11224 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11225 }
11226 }
11227 }
11228 deserializer.deserialize_identifier(GeneratedVisitor)
11229 }
11230 }
11231 struct GeneratedVisitor;
11232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11233 type Value = list_refresh_table_states_response::RefreshTableState;
11234
11235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11236 formatter.write_str("struct meta.ListRefreshTableStatesResponse.RefreshTableState")
11237 }
11238
11239 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_refresh_table_states_response::RefreshTableState, V::Error>
11240 where
11241 V: serde::de::MapAccess<'de>,
11242 {
11243 let mut table_id__ = None;
11244 let mut current_status__ = None;
11245 let mut last_trigger_time__ = None;
11246 let mut trigger_interval_secs__ = None;
11247 let mut last_success_time__ = None;
11248 while let Some(k) = map_.next_key()? {
11249 match k {
11250 GeneratedField::TableId => {
11251 if table_id__.is_some() {
11252 return Err(serde::de::Error::duplicate_field("tableId"));
11253 }
11254 table_id__ =
11255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11256 ;
11257 }
11258 GeneratedField::CurrentStatus => {
11259 if current_status__.is_some() {
11260 return Err(serde::de::Error::duplicate_field("currentStatus"));
11261 }
11262 current_status__ = Some(map_.next_value()?);
11263 }
11264 GeneratedField::LastTriggerTime => {
11265 if last_trigger_time__.is_some() {
11266 return Err(serde::de::Error::duplicate_field("lastTriggerTime"));
11267 }
11268 last_trigger_time__ = map_.next_value()?;
11269 }
11270 GeneratedField::TriggerIntervalSecs => {
11271 if trigger_interval_secs__.is_some() {
11272 return Err(serde::de::Error::duplicate_field("triggerIntervalSecs"));
11273 }
11274 trigger_interval_secs__ =
11275 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11276 ;
11277 }
11278 GeneratedField::LastSuccessTime => {
11279 if last_success_time__.is_some() {
11280 return Err(serde::de::Error::duplicate_field("lastSuccessTime"));
11281 }
11282 last_success_time__ = map_.next_value()?;
11283 }
11284 }
11285 }
11286 Ok(list_refresh_table_states_response::RefreshTableState {
11287 table_id: table_id__.unwrap_or_default(),
11288 current_status: current_status__.unwrap_or_default(),
11289 last_trigger_time: last_trigger_time__,
11290 trigger_interval_secs: trigger_interval_secs__,
11291 last_success_time: last_success_time__,
11292 })
11293 }
11294 }
11295 deserializer.deserialize_struct("meta.ListRefreshTableStatesResponse.RefreshTableState", FIELDS, GeneratedVisitor)
11296 }
11297}
11298impl serde::Serialize for ListStreamingJobStatesRequest {
11299 #[allow(deprecated)]
11300 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11301 where
11302 S: serde::Serializer,
11303 {
11304 use serde::ser::SerializeStruct;
11305 let len = 0;
11306 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
11307 struct_ser.end()
11308 }
11309}
11310impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
11311 #[allow(deprecated)]
11312 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11313 where
11314 D: serde::Deserializer<'de>,
11315 {
11316 const FIELDS: &[&str] = &[
11317 ];
11318
11319 #[allow(clippy::enum_variant_names)]
11320 enum GeneratedField {
11321 }
11322 impl<'de> serde::Deserialize<'de> for GeneratedField {
11323 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11324 where
11325 D: serde::Deserializer<'de>,
11326 {
11327 struct GeneratedVisitor;
11328
11329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11330 type Value = GeneratedField;
11331
11332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11333 write!(formatter, "expected one of: {:?}", &FIELDS)
11334 }
11335
11336 #[allow(unused_variables)]
11337 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11338 where
11339 E: serde::de::Error,
11340 {
11341 Err(serde::de::Error::unknown_field(value, FIELDS))
11342 }
11343 }
11344 deserializer.deserialize_identifier(GeneratedVisitor)
11345 }
11346 }
11347 struct GeneratedVisitor;
11348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11349 type Value = ListStreamingJobStatesRequest;
11350
11351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11352 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
11353 }
11354
11355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
11356 where
11357 V: serde::de::MapAccess<'de>,
11358 {
11359 while map_.next_key::<GeneratedField>()?.is_some() {
11360 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11361 }
11362 Ok(ListStreamingJobStatesRequest {
11363 })
11364 }
11365 }
11366 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
11367 }
11368}
11369impl serde::Serialize for ListStreamingJobStatesResponse {
11370 #[allow(deprecated)]
11371 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11372 where
11373 S: serde::Serializer,
11374 {
11375 use serde::ser::SerializeStruct;
11376 let mut len = 0;
11377 if !self.states.is_empty() {
11378 len += 1;
11379 }
11380 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
11381 if !self.states.is_empty() {
11382 struct_ser.serialize_field("states", &self.states)?;
11383 }
11384 struct_ser.end()
11385 }
11386}
11387impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
11388 #[allow(deprecated)]
11389 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11390 where
11391 D: serde::Deserializer<'de>,
11392 {
11393 const FIELDS: &[&str] = &[
11394 "states",
11395 ];
11396
11397 #[allow(clippy::enum_variant_names)]
11398 enum GeneratedField {
11399 States,
11400 }
11401 impl<'de> serde::Deserialize<'de> for GeneratedField {
11402 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11403 where
11404 D: serde::Deserializer<'de>,
11405 {
11406 struct GeneratedVisitor;
11407
11408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11409 type Value = GeneratedField;
11410
11411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11412 write!(formatter, "expected one of: {:?}", &FIELDS)
11413 }
11414
11415 #[allow(unused_variables)]
11416 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11417 where
11418 E: serde::de::Error,
11419 {
11420 match value {
11421 "states" => Ok(GeneratedField::States),
11422 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11423 }
11424 }
11425 }
11426 deserializer.deserialize_identifier(GeneratedVisitor)
11427 }
11428 }
11429 struct GeneratedVisitor;
11430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11431 type Value = ListStreamingJobStatesResponse;
11432
11433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11434 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
11435 }
11436
11437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
11438 where
11439 V: serde::de::MapAccess<'de>,
11440 {
11441 let mut states__ = None;
11442 while let Some(k) = map_.next_key()? {
11443 match k {
11444 GeneratedField::States => {
11445 if states__.is_some() {
11446 return Err(serde::de::Error::duplicate_field("states"));
11447 }
11448 states__ = Some(map_.next_value()?);
11449 }
11450 }
11451 }
11452 Ok(ListStreamingJobStatesResponse {
11453 states: states__.unwrap_or_default(),
11454 })
11455 }
11456 }
11457 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
11458 }
11459}
11460impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
11461 #[allow(deprecated)]
11462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11463 where
11464 S: serde::Serializer,
11465 {
11466 use serde::ser::SerializeStruct;
11467 let mut len = 0;
11468 if self.table_id != 0 {
11469 len += 1;
11470 }
11471 if self.state != 0 {
11472 len += 1;
11473 }
11474 if self.parallelism.is_some() {
11475 len += 1;
11476 }
11477 if self.max_parallelism != 0 {
11478 len += 1;
11479 }
11480 if !self.name.is_empty() {
11481 len += 1;
11482 }
11483 if !self.resource_group.is_empty() {
11484 len += 1;
11485 }
11486 if self.database_id != 0 {
11487 len += 1;
11488 }
11489 if self.schema_id != 0 {
11490 len += 1;
11491 }
11492 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
11493 if self.table_id != 0 {
11494 struct_ser.serialize_field("tableId", &self.table_id)?;
11495 }
11496 if self.state != 0 {
11497 let v = table_fragments::State::try_from(self.state)
11498 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
11499 struct_ser.serialize_field("state", &v)?;
11500 }
11501 if let Some(v) = self.parallelism.as_ref() {
11502 struct_ser.serialize_field("parallelism", v)?;
11503 }
11504 if self.max_parallelism != 0 {
11505 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11506 }
11507 if !self.name.is_empty() {
11508 struct_ser.serialize_field("name", &self.name)?;
11509 }
11510 if !self.resource_group.is_empty() {
11511 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
11512 }
11513 if self.database_id != 0 {
11514 struct_ser.serialize_field("databaseId", &self.database_id)?;
11515 }
11516 if self.schema_id != 0 {
11517 struct_ser.serialize_field("schemaId", &self.schema_id)?;
11518 }
11519 struct_ser.end()
11520 }
11521}
11522impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
11523 #[allow(deprecated)]
11524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11525 where
11526 D: serde::Deserializer<'de>,
11527 {
11528 const FIELDS: &[&str] = &[
11529 "table_id",
11530 "tableId",
11531 "state",
11532 "parallelism",
11533 "max_parallelism",
11534 "maxParallelism",
11535 "name",
11536 "resource_group",
11537 "resourceGroup",
11538 "database_id",
11539 "databaseId",
11540 "schema_id",
11541 "schemaId",
11542 ];
11543
11544 #[allow(clippy::enum_variant_names)]
11545 enum GeneratedField {
11546 TableId,
11547 State,
11548 Parallelism,
11549 MaxParallelism,
11550 Name,
11551 ResourceGroup,
11552 DatabaseId,
11553 SchemaId,
11554 }
11555 impl<'de> serde::Deserialize<'de> for GeneratedField {
11556 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11557 where
11558 D: serde::Deserializer<'de>,
11559 {
11560 struct GeneratedVisitor;
11561
11562 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11563 type Value = GeneratedField;
11564
11565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11566 write!(formatter, "expected one of: {:?}", &FIELDS)
11567 }
11568
11569 #[allow(unused_variables)]
11570 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11571 where
11572 E: serde::de::Error,
11573 {
11574 match value {
11575 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11576 "state" => Ok(GeneratedField::State),
11577 "parallelism" => Ok(GeneratedField::Parallelism),
11578 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11579 "name" => Ok(GeneratedField::Name),
11580 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
11581 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
11582 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
11583 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11584 }
11585 }
11586 }
11587 deserializer.deserialize_identifier(GeneratedVisitor)
11588 }
11589 }
11590 struct GeneratedVisitor;
11591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11592 type Value = list_streaming_job_states_response::StreamingJobState;
11593
11594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11595 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
11596 }
11597
11598 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
11599 where
11600 V: serde::de::MapAccess<'de>,
11601 {
11602 let mut table_id__ = None;
11603 let mut state__ = None;
11604 let mut parallelism__ = None;
11605 let mut max_parallelism__ = None;
11606 let mut name__ = None;
11607 let mut resource_group__ = None;
11608 let mut database_id__ = None;
11609 let mut schema_id__ = None;
11610 while let Some(k) = map_.next_key()? {
11611 match k {
11612 GeneratedField::TableId => {
11613 if table_id__.is_some() {
11614 return Err(serde::de::Error::duplicate_field("tableId"));
11615 }
11616 table_id__ =
11617 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11618 ;
11619 }
11620 GeneratedField::State => {
11621 if state__.is_some() {
11622 return Err(serde::de::Error::duplicate_field("state"));
11623 }
11624 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
11625 }
11626 GeneratedField::Parallelism => {
11627 if parallelism__.is_some() {
11628 return Err(serde::de::Error::duplicate_field("parallelism"));
11629 }
11630 parallelism__ = map_.next_value()?;
11631 }
11632 GeneratedField::MaxParallelism => {
11633 if max_parallelism__.is_some() {
11634 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11635 }
11636 max_parallelism__ =
11637 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11638 ;
11639 }
11640 GeneratedField::Name => {
11641 if name__.is_some() {
11642 return Err(serde::de::Error::duplicate_field("name"));
11643 }
11644 name__ = Some(map_.next_value()?);
11645 }
11646 GeneratedField::ResourceGroup => {
11647 if resource_group__.is_some() {
11648 return Err(serde::de::Error::duplicate_field("resourceGroup"));
11649 }
11650 resource_group__ = Some(map_.next_value()?);
11651 }
11652 GeneratedField::DatabaseId => {
11653 if database_id__.is_some() {
11654 return Err(serde::de::Error::duplicate_field("databaseId"));
11655 }
11656 database_id__ =
11657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11658 ;
11659 }
11660 GeneratedField::SchemaId => {
11661 if schema_id__.is_some() {
11662 return Err(serde::de::Error::duplicate_field("schemaId"));
11663 }
11664 schema_id__ =
11665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11666 ;
11667 }
11668 }
11669 }
11670 Ok(list_streaming_job_states_response::StreamingJobState {
11671 table_id: table_id__.unwrap_or_default(),
11672 state: state__.unwrap_or_default(),
11673 parallelism: parallelism__,
11674 max_parallelism: max_parallelism__.unwrap_or_default(),
11675 name: name__.unwrap_or_default(),
11676 resource_group: resource_group__.unwrap_or_default(),
11677 database_id: database_id__.unwrap_or_default(),
11678 schema_id: schema_id__.unwrap_or_default(),
11679 })
11680 }
11681 }
11682 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
11683 }
11684}
11685impl serde::Serialize for ListTableFragmentsRequest {
11686 #[allow(deprecated)]
11687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11688 where
11689 S: serde::Serializer,
11690 {
11691 use serde::ser::SerializeStruct;
11692 let mut len = 0;
11693 if !self.table_ids.is_empty() {
11694 len += 1;
11695 }
11696 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
11697 if !self.table_ids.is_empty() {
11698 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11699 }
11700 struct_ser.end()
11701 }
11702}
11703impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
11704 #[allow(deprecated)]
11705 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11706 where
11707 D: serde::Deserializer<'de>,
11708 {
11709 const FIELDS: &[&str] = &[
11710 "table_ids",
11711 "tableIds",
11712 ];
11713
11714 #[allow(clippy::enum_variant_names)]
11715 enum GeneratedField {
11716 TableIds,
11717 }
11718 impl<'de> serde::Deserialize<'de> for GeneratedField {
11719 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11720 where
11721 D: serde::Deserializer<'de>,
11722 {
11723 struct GeneratedVisitor;
11724
11725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11726 type Value = GeneratedField;
11727
11728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11729 write!(formatter, "expected one of: {:?}", &FIELDS)
11730 }
11731
11732 #[allow(unused_variables)]
11733 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11734 where
11735 E: serde::de::Error,
11736 {
11737 match value {
11738 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11739 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11740 }
11741 }
11742 }
11743 deserializer.deserialize_identifier(GeneratedVisitor)
11744 }
11745 }
11746 struct GeneratedVisitor;
11747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11748 type Value = ListTableFragmentsRequest;
11749
11750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11751 formatter.write_str("struct meta.ListTableFragmentsRequest")
11752 }
11753
11754 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
11755 where
11756 V: serde::de::MapAccess<'de>,
11757 {
11758 let mut table_ids__ = None;
11759 while let Some(k) = map_.next_key()? {
11760 match k {
11761 GeneratedField::TableIds => {
11762 if table_ids__.is_some() {
11763 return Err(serde::de::Error::duplicate_field("tableIds"));
11764 }
11765 table_ids__ =
11766 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11767 .into_iter().map(|x| x.0).collect())
11768 ;
11769 }
11770 }
11771 }
11772 Ok(ListTableFragmentsRequest {
11773 table_ids: table_ids__.unwrap_or_default(),
11774 })
11775 }
11776 }
11777 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
11778 }
11779}
11780impl serde::Serialize for ListTableFragmentsResponse {
11781 #[allow(deprecated)]
11782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11783 where
11784 S: serde::Serializer,
11785 {
11786 use serde::ser::SerializeStruct;
11787 let mut len = 0;
11788 if !self.table_fragments.is_empty() {
11789 len += 1;
11790 }
11791 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
11792 if !self.table_fragments.is_empty() {
11793 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
11794 }
11795 struct_ser.end()
11796 }
11797}
11798impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
11799 #[allow(deprecated)]
11800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11801 where
11802 D: serde::Deserializer<'de>,
11803 {
11804 const FIELDS: &[&str] = &[
11805 "table_fragments",
11806 "tableFragments",
11807 ];
11808
11809 #[allow(clippy::enum_variant_names)]
11810 enum GeneratedField {
11811 TableFragments,
11812 }
11813 impl<'de> serde::Deserialize<'de> for GeneratedField {
11814 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11815 where
11816 D: serde::Deserializer<'de>,
11817 {
11818 struct GeneratedVisitor;
11819
11820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11821 type Value = GeneratedField;
11822
11823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11824 write!(formatter, "expected one of: {:?}", &FIELDS)
11825 }
11826
11827 #[allow(unused_variables)]
11828 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11829 where
11830 E: serde::de::Error,
11831 {
11832 match value {
11833 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
11834 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11835 }
11836 }
11837 }
11838 deserializer.deserialize_identifier(GeneratedVisitor)
11839 }
11840 }
11841 struct GeneratedVisitor;
11842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11843 type Value = ListTableFragmentsResponse;
11844
11845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11846 formatter.write_str("struct meta.ListTableFragmentsResponse")
11847 }
11848
11849 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
11850 where
11851 V: serde::de::MapAccess<'de>,
11852 {
11853 let mut table_fragments__ = None;
11854 while let Some(k) = map_.next_key()? {
11855 match k {
11856 GeneratedField::TableFragments => {
11857 if table_fragments__.is_some() {
11858 return Err(serde::de::Error::duplicate_field("tableFragments"));
11859 }
11860 table_fragments__ = Some(
11861 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11862 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11863 );
11864 }
11865 }
11866 }
11867 Ok(ListTableFragmentsResponse {
11868 table_fragments: table_fragments__.unwrap_or_default(),
11869 })
11870 }
11871 }
11872 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
11873 }
11874}
11875impl serde::Serialize for list_table_fragments_response::ActorInfo {
11876 #[allow(deprecated)]
11877 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11878 where
11879 S: serde::Serializer,
11880 {
11881 use serde::ser::SerializeStruct;
11882 let mut len = 0;
11883 if self.id != 0 {
11884 len += 1;
11885 }
11886 if self.node.is_some() {
11887 len += 1;
11888 }
11889 if !self.dispatcher.is_empty() {
11890 len += 1;
11891 }
11892 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
11893 if self.id != 0 {
11894 struct_ser.serialize_field("id", &self.id)?;
11895 }
11896 if let Some(v) = self.node.as_ref() {
11897 struct_ser.serialize_field("node", v)?;
11898 }
11899 if !self.dispatcher.is_empty() {
11900 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11901 }
11902 struct_ser.end()
11903 }
11904}
11905impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
11906 #[allow(deprecated)]
11907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11908 where
11909 D: serde::Deserializer<'de>,
11910 {
11911 const FIELDS: &[&str] = &[
11912 "id",
11913 "node",
11914 "dispatcher",
11915 ];
11916
11917 #[allow(clippy::enum_variant_names)]
11918 enum GeneratedField {
11919 Id,
11920 Node,
11921 Dispatcher,
11922 }
11923 impl<'de> serde::Deserialize<'de> for GeneratedField {
11924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11925 where
11926 D: serde::Deserializer<'de>,
11927 {
11928 struct GeneratedVisitor;
11929
11930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11931 type Value = GeneratedField;
11932
11933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11934 write!(formatter, "expected one of: {:?}", &FIELDS)
11935 }
11936
11937 #[allow(unused_variables)]
11938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11939 where
11940 E: serde::de::Error,
11941 {
11942 match value {
11943 "id" => Ok(GeneratedField::Id),
11944 "node" => Ok(GeneratedField::Node),
11945 "dispatcher" => Ok(GeneratedField::Dispatcher),
11946 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11947 }
11948 }
11949 }
11950 deserializer.deserialize_identifier(GeneratedVisitor)
11951 }
11952 }
11953 struct GeneratedVisitor;
11954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11955 type Value = list_table_fragments_response::ActorInfo;
11956
11957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11958 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
11959 }
11960
11961 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
11962 where
11963 V: serde::de::MapAccess<'de>,
11964 {
11965 let mut id__ = None;
11966 let mut node__ = None;
11967 let mut dispatcher__ = None;
11968 while let Some(k) = map_.next_key()? {
11969 match k {
11970 GeneratedField::Id => {
11971 if id__.is_some() {
11972 return Err(serde::de::Error::duplicate_field("id"));
11973 }
11974 id__ =
11975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11976 ;
11977 }
11978 GeneratedField::Node => {
11979 if node__.is_some() {
11980 return Err(serde::de::Error::duplicate_field("node"));
11981 }
11982 node__ = map_.next_value()?;
11983 }
11984 GeneratedField::Dispatcher => {
11985 if dispatcher__.is_some() {
11986 return Err(serde::de::Error::duplicate_field("dispatcher"));
11987 }
11988 dispatcher__ = Some(map_.next_value()?);
11989 }
11990 }
11991 }
11992 Ok(list_table_fragments_response::ActorInfo {
11993 id: id__.unwrap_or_default(),
11994 node: node__,
11995 dispatcher: dispatcher__.unwrap_or_default(),
11996 })
11997 }
11998 }
11999 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12000 }
12001}
12002impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12003 #[allow(deprecated)]
12004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12005 where
12006 S: serde::Serializer,
12007 {
12008 use serde::ser::SerializeStruct;
12009 let mut len = 0;
12010 if self.id != 0 {
12011 len += 1;
12012 }
12013 if !self.actors.is_empty() {
12014 len += 1;
12015 }
12016 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12017 if self.id != 0 {
12018 struct_ser.serialize_field("id", &self.id)?;
12019 }
12020 if !self.actors.is_empty() {
12021 struct_ser.serialize_field("actors", &self.actors)?;
12022 }
12023 struct_ser.end()
12024 }
12025}
12026impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12027 #[allow(deprecated)]
12028 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12029 where
12030 D: serde::Deserializer<'de>,
12031 {
12032 const FIELDS: &[&str] = &[
12033 "id",
12034 "actors",
12035 ];
12036
12037 #[allow(clippy::enum_variant_names)]
12038 enum GeneratedField {
12039 Id,
12040 Actors,
12041 }
12042 impl<'de> serde::Deserialize<'de> for GeneratedField {
12043 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12044 where
12045 D: serde::Deserializer<'de>,
12046 {
12047 struct GeneratedVisitor;
12048
12049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12050 type Value = GeneratedField;
12051
12052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12053 write!(formatter, "expected one of: {:?}", &FIELDS)
12054 }
12055
12056 #[allow(unused_variables)]
12057 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12058 where
12059 E: serde::de::Error,
12060 {
12061 match value {
12062 "id" => Ok(GeneratedField::Id),
12063 "actors" => Ok(GeneratedField::Actors),
12064 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12065 }
12066 }
12067 }
12068 deserializer.deserialize_identifier(GeneratedVisitor)
12069 }
12070 }
12071 struct GeneratedVisitor;
12072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12073 type Value = list_table_fragments_response::FragmentInfo;
12074
12075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12076 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
12077 }
12078
12079 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
12080 where
12081 V: serde::de::MapAccess<'de>,
12082 {
12083 let mut id__ = None;
12084 let mut actors__ = None;
12085 while let Some(k) = map_.next_key()? {
12086 match k {
12087 GeneratedField::Id => {
12088 if id__.is_some() {
12089 return Err(serde::de::Error::duplicate_field("id"));
12090 }
12091 id__ =
12092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12093 ;
12094 }
12095 GeneratedField::Actors => {
12096 if actors__.is_some() {
12097 return Err(serde::de::Error::duplicate_field("actors"));
12098 }
12099 actors__ = Some(map_.next_value()?);
12100 }
12101 }
12102 }
12103 Ok(list_table_fragments_response::FragmentInfo {
12104 id: id__.unwrap_or_default(),
12105 actors: actors__.unwrap_or_default(),
12106 })
12107 }
12108 }
12109 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
12110 }
12111}
12112impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
12113 #[allow(deprecated)]
12114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12115 where
12116 S: serde::Serializer,
12117 {
12118 use serde::ser::SerializeStruct;
12119 let mut len = 0;
12120 if !self.fragments.is_empty() {
12121 len += 1;
12122 }
12123 if self.ctx.is_some() {
12124 len += 1;
12125 }
12126 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
12127 if !self.fragments.is_empty() {
12128 struct_ser.serialize_field("fragments", &self.fragments)?;
12129 }
12130 if let Some(v) = self.ctx.as_ref() {
12131 struct_ser.serialize_field("ctx", v)?;
12132 }
12133 struct_ser.end()
12134 }
12135}
12136impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
12137 #[allow(deprecated)]
12138 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12139 where
12140 D: serde::Deserializer<'de>,
12141 {
12142 const FIELDS: &[&str] = &[
12143 "fragments",
12144 "ctx",
12145 ];
12146
12147 #[allow(clippy::enum_variant_names)]
12148 enum GeneratedField {
12149 Fragments,
12150 Ctx,
12151 }
12152 impl<'de> serde::Deserialize<'de> for GeneratedField {
12153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12154 where
12155 D: serde::Deserializer<'de>,
12156 {
12157 struct GeneratedVisitor;
12158
12159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12160 type Value = GeneratedField;
12161
12162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12163 write!(formatter, "expected one of: {:?}", &FIELDS)
12164 }
12165
12166 #[allow(unused_variables)]
12167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12168 where
12169 E: serde::de::Error,
12170 {
12171 match value {
12172 "fragments" => Ok(GeneratedField::Fragments),
12173 "ctx" => Ok(GeneratedField::Ctx),
12174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12175 }
12176 }
12177 }
12178 deserializer.deserialize_identifier(GeneratedVisitor)
12179 }
12180 }
12181 struct GeneratedVisitor;
12182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12183 type Value = list_table_fragments_response::TableFragmentInfo;
12184
12185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12186 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
12187 }
12188
12189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
12190 where
12191 V: serde::de::MapAccess<'de>,
12192 {
12193 let mut fragments__ = None;
12194 let mut ctx__ = None;
12195 while let Some(k) = map_.next_key()? {
12196 match k {
12197 GeneratedField::Fragments => {
12198 if fragments__.is_some() {
12199 return Err(serde::de::Error::duplicate_field("fragments"));
12200 }
12201 fragments__ = Some(map_.next_value()?);
12202 }
12203 GeneratedField::Ctx => {
12204 if ctx__.is_some() {
12205 return Err(serde::de::Error::duplicate_field("ctx"));
12206 }
12207 ctx__ = map_.next_value()?;
12208 }
12209 }
12210 }
12211 Ok(list_table_fragments_response::TableFragmentInfo {
12212 fragments: fragments__.unwrap_or_default(),
12213 ctx: ctx__,
12214 })
12215 }
12216 }
12217 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
12218 }
12219}
12220impl serde::Serialize for ListUnmigratedTablesRequest {
12221 #[allow(deprecated)]
12222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12223 where
12224 S: serde::Serializer,
12225 {
12226 use serde::ser::SerializeStruct;
12227 let len = 0;
12228 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
12229 struct_ser.end()
12230 }
12231}
12232impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
12233 #[allow(deprecated)]
12234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12235 where
12236 D: serde::Deserializer<'de>,
12237 {
12238 const FIELDS: &[&str] = &[
12239 ];
12240
12241 #[allow(clippy::enum_variant_names)]
12242 enum GeneratedField {
12243 }
12244 impl<'de> serde::Deserialize<'de> for GeneratedField {
12245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12246 where
12247 D: serde::Deserializer<'de>,
12248 {
12249 struct GeneratedVisitor;
12250
12251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12252 type Value = GeneratedField;
12253
12254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12255 write!(formatter, "expected one of: {:?}", &FIELDS)
12256 }
12257
12258 #[allow(unused_variables)]
12259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12260 where
12261 E: serde::de::Error,
12262 {
12263 Err(serde::de::Error::unknown_field(value, FIELDS))
12264 }
12265 }
12266 deserializer.deserialize_identifier(GeneratedVisitor)
12267 }
12268 }
12269 struct GeneratedVisitor;
12270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12271 type Value = ListUnmigratedTablesRequest;
12272
12273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12274 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
12275 }
12276
12277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
12278 where
12279 V: serde::de::MapAccess<'de>,
12280 {
12281 while map_.next_key::<GeneratedField>()?.is_some() {
12282 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12283 }
12284 Ok(ListUnmigratedTablesRequest {
12285 })
12286 }
12287 }
12288 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
12289 }
12290}
12291impl serde::Serialize for ListUnmigratedTablesResponse {
12292 #[allow(deprecated)]
12293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12294 where
12295 S: serde::Serializer,
12296 {
12297 use serde::ser::SerializeStruct;
12298 let mut len = 0;
12299 if !self.tables.is_empty() {
12300 len += 1;
12301 }
12302 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
12303 if !self.tables.is_empty() {
12304 struct_ser.serialize_field("tables", &self.tables)?;
12305 }
12306 struct_ser.end()
12307 }
12308}
12309impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
12310 #[allow(deprecated)]
12311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12312 where
12313 D: serde::Deserializer<'de>,
12314 {
12315 const FIELDS: &[&str] = &[
12316 "tables",
12317 ];
12318
12319 #[allow(clippy::enum_variant_names)]
12320 enum GeneratedField {
12321 Tables,
12322 }
12323 impl<'de> serde::Deserialize<'de> for GeneratedField {
12324 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12325 where
12326 D: serde::Deserializer<'de>,
12327 {
12328 struct GeneratedVisitor;
12329
12330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12331 type Value = GeneratedField;
12332
12333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12334 write!(formatter, "expected one of: {:?}", &FIELDS)
12335 }
12336
12337 #[allow(unused_variables)]
12338 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12339 where
12340 E: serde::de::Error,
12341 {
12342 match value {
12343 "tables" => Ok(GeneratedField::Tables),
12344 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12345 }
12346 }
12347 }
12348 deserializer.deserialize_identifier(GeneratedVisitor)
12349 }
12350 }
12351 struct GeneratedVisitor;
12352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12353 type Value = ListUnmigratedTablesResponse;
12354
12355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12356 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
12357 }
12358
12359 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
12360 where
12361 V: serde::de::MapAccess<'de>,
12362 {
12363 let mut tables__ = None;
12364 while let Some(k) = map_.next_key()? {
12365 match k {
12366 GeneratedField::Tables => {
12367 if tables__.is_some() {
12368 return Err(serde::de::Error::duplicate_field("tables"));
12369 }
12370 tables__ = Some(map_.next_value()?);
12371 }
12372 }
12373 }
12374 Ok(ListUnmigratedTablesResponse {
12375 tables: tables__.unwrap_or_default(),
12376 })
12377 }
12378 }
12379 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
12380 }
12381}
12382impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
12383 #[allow(deprecated)]
12384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12385 where
12386 S: serde::Serializer,
12387 {
12388 use serde::ser::SerializeStruct;
12389 let mut len = 0;
12390 if self.table_id != 0 {
12391 len += 1;
12392 }
12393 if !self.table_name.is_empty() {
12394 len += 1;
12395 }
12396 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
12397 if self.table_id != 0 {
12398 struct_ser.serialize_field("tableId", &self.table_id)?;
12399 }
12400 if !self.table_name.is_empty() {
12401 struct_ser.serialize_field("tableName", &self.table_name)?;
12402 }
12403 struct_ser.end()
12404 }
12405}
12406impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
12407 #[allow(deprecated)]
12408 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12409 where
12410 D: serde::Deserializer<'de>,
12411 {
12412 const FIELDS: &[&str] = &[
12413 "table_id",
12414 "tableId",
12415 "table_name",
12416 "tableName",
12417 ];
12418
12419 #[allow(clippy::enum_variant_names)]
12420 enum GeneratedField {
12421 TableId,
12422 TableName,
12423 }
12424 impl<'de> serde::Deserialize<'de> for GeneratedField {
12425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12426 where
12427 D: serde::Deserializer<'de>,
12428 {
12429 struct GeneratedVisitor;
12430
12431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12432 type Value = GeneratedField;
12433
12434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12435 write!(formatter, "expected one of: {:?}", &FIELDS)
12436 }
12437
12438 #[allow(unused_variables)]
12439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12440 where
12441 E: serde::de::Error,
12442 {
12443 match value {
12444 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12445 "tableName" | "table_name" => Ok(GeneratedField::TableName),
12446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12447 }
12448 }
12449 }
12450 deserializer.deserialize_identifier(GeneratedVisitor)
12451 }
12452 }
12453 struct GeneratedVisitor;
12454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12455 type Value = list_unmigrated_tables_response::UnmigratedTable;
12456
12457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12458 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
12459 }
12460
12461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
12462 where
12463 V: serde::de::MapAccess<'de>,
12464 {
12465 let mut table_id__ = None;
12466 let mut table_name__ = None;
12467 while let Some(k) = map_.next_key()? {
12468 match k {
12469 GeneratedField::TableId => {
12470 if table_id__.is_some() {
12471 return Err(serde::de::Error::duplicate_field("tableId"));
12472 }
12473 table_id__ =
12474 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12475 ;
12476 }
12477 GeneratedField::TableName => {
12478 if table_name__.is_some() {
12479 return Err(serde::de::Error::duplicate_field("tableName"));
12480 }
12481 table_name__ = Some(map_.next_value()?);
12482 }
12483 }
12484 }
12485 Ok(list_unmigrated_tables_response::UnmigratedTable {
12486 table_id: table_id__.unwrap_or_default(),
12487 table_name: table_name__.unwrap_or_default(),
12488 })
12489 }
12490 }
12491 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
12492 }
12493}
12494impl serde::Serialize for MembersRequest {
12495 #[allow(deprecated)]
12496 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12497 where
12498 S: serde::Serializer,
12499 {
12500 use serde::ser::SerializeStruct;
12501 let len = 0;
12502 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
12503 struct_ser.end()
12504 }
12505}
12506impl<'de> serde::Deserialize<'de> for MembersRequest {
12507 #[allow(deprecated)]
12508 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12509 where
12510 D: serde::Deserializer<'de>,
12511 {
12512 const FIELDS: &[&str] = &[
12513 ];
12514
12515 #[allow(clippy::enum_variant_names)]
12516 enum GeneratedField {
12517 }
12518 impl<'de> serde::Deserialize<'de> for GeneratedField {
12519 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12520 where
12521 D: serde::Deserializer<'de>,
12522 {
12523 struct GeneratedVisitor;
12524
12525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12526 type Value = GeneratedField;
12527
12528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12529 write!(formatter, "expected one of: {:?}", &FIELDS)
12530 }
12531
12532 #[allow(unused_variables)]
12533 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12534 where
12535 E: serde::de::Error,
12536 {
12537 Err(serde::de::Error::unknown_field(value, FIELDS))
12538 }
12539 }
12540 deserializer.deserialize_identifier(GeneratedVisitor)
12541 }
12542 }
12543 struct GeneratedVisitor;
12544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12545 type Value = MembersRequest;
12546
12547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12548 formatter.write_str("struct meta.MembersRequest")
12549 }
12550
12551 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
12552 where
12553 V: serde::de::MapAccess<'de>,
12554 {
12555 while map_.next_key::<GeneratedField>()?.is_some() {
12556 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12557 }
12558 Ok(MembersRequest {
12559 })
12560 }
12561 }
12562 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
12563 }
12564}
12565impl serde::Serialize for MembersResponse {
12566 #[allow(deprecated)]
12567 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12568 where
12569 S: serde::Serializer,
12570 {
12571 use serde::ser::SerializeStruct;
12572 let mut len = 0;
12573 if !self.members.is_empty() {
12574 len += 1;
12575 }
12576 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
12577 if !self.members.is_empty() {
12578 struct_ser.serialize_field("members", &self.members)?;
12579 }
12580 struct_ser.end()
12581 }
12582}
12583impl<'de> serde::Deserialize<'de> for MembersResponse {
12584 #[allow(deprecated)]
12585 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12586 where
12587 D: serde::Deserializer<'de>,
12588 {
12589 const FIELDS: &[&str] = &[
12590 "members",
12591 ];
12592
12593 #[allow(clippy::enum_variant_names)]
12594 enum GeneratedField {
12595 Members,
12596 }
12597 impl<'de> serde::Deserialize<'de> for GeneratedField {
12598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12599 where
12600 D: serde::Deserializer<'de>,
12601 {
12602 struct GeneratedVisitor;
12603
12604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12605 type Value = GeneratedField;
12606
12607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12608 write!(formatter, "expected one of: {:?}", &FIELDS)
12609 }
12610
12611 #[allow(unused_variables)]
12612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12613 where
12614 E: serde::de::Error,
12615 {
12616 match value {
12617 "members" => Ok(GeneratedField::Members),
12618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12619 }
12620 }
12621 }
12622 deserializer.deserialize_identifier(GeneratedVisitor)
12623 }
12624 }
12625 struct GeneratedVisitor;
12626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12627 type Value = MembersResponse;
12628
12629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12630 formatter.write_str("struct meta.MembersResponse")
12631 }
12632
12633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
12634 where
12635 V: serde::de::MapAccess<'de>,
12636 {
12637 let mut members__ = None;
12638 while let Some(k) = map_.next_key()? {
12639 match k {
12640 GeneratedField::Members => {
12641 if members__.is_some() {
12642 return Err(serde::de::Error::duplicate_field("members"));
12643 }
12644 members__ = Some(map_.next_value()?);
12645 }
12646 }
12647 }
12648 Ok(MembersResponse {
12649 members: members__.unwrap_or_default(),
12650 })
12651 }
12652 }
12653 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
12654 }
12655}
12656impl serde::Serialize for MetaMember {
12657 #[allow(deprecated)]
12658 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12659 where
12660 S: serde::Serializer,
12661 {
12662 use serde::ser::SerializeStruct;
12663 let mut len = 0;
12664 if self.address.is_some() {
12665 len += 1;
12666 }
12667 if self.is_leader {
12668 len += 1;
12669 }
12670 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
12671 if let Some(v) = self.address.as_ref() {
12672 struct_ser.serialize_field("address", v)?;
12673 }
12674 if self.is_leader {
12675 struct_ser.serialize_field("isLeader", &self.is_leader)?;
12676 }
12677 struct_ser.end()
12678 }
12679}
12680impl<'de> serde::Deserialize<'de> for MetaMember {
12681 #[allow(deprecated)]
12682 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12683 where
12684 D: serde::Deserializer<'de>,
12685 {
12686 const FIELDS: &[&str] = &[
12687 "address",
12688 "is_leader",
12689 "isLeader",
12690 ];
12691
12692 #[allow(clippy::enum_variant_names)]
12693 enum GeneratedField {
12694 Address,
12695 IsLeader,
12696 }
12697 impl<'de> serde::Deserialize<'de> for GeneratedField {
12698 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12699 where
12700 D: serde::Deserializer<'de>,
12701 {
12702 struct GeneratedVisitor;
12703
12704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12705 type Value = GeneratedField;
12706
12707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12708 write!(formatter, "expected one of: {:?}", &FIELDS)
12709 }
12710
12711 #[allow(unused_variables)]
12712 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12713 where
12714 E: serde::de::Error,
12715 {
12716 match value {
12717 "address" => Ok(GeneratedField::Address),
12718 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
12719 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12720 }
12721 }
12722 }
12723 deserializer.deserialize_identifier(GeneratedVisitor)
12724 }
12725 }
12726 struct GeneratedVisitor;
12727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12728 type Value = MetaMember;
12729
12730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12731 formatter.write_str("struct meta.MetaMember")
12732 }
12733
12734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
12735 where
12736 V: serde::de::MapAccess<'de>,
12737 {
12738 let mut address__ = None;
12739 let mut is_leader__ = None;
12740 while let Some(k) = map_.next_key()? {
12741 match k {
12742 GeneratedField::Address => {
12743 if address__.is_some() {
12744 return Err(serde::de::Error::duplicate_field("address"));
12745 }
12746 address__ = map_.next_value()?;
12747 }
12748 GeneratedField::IsLeader => {
12749 if is_leader__.is_some() {
12750 return Err(serde::de::Error::duplicate_field("isLeader"));
12751 }
12752 is_leader__ = Some(map_.next_value()?);
12753 }
12754 }
12755 }
12756 Ok(MetaMember {
12757 address: address__,
12758 is_leader: is_leader__.unwrap_or_default(),
12759 })
12760 }
12761 }
12762 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
12763 }
12764}
12765impl serde::Serialize for MetaSnapshot {
12766 #[allow(deprecated)]
12767 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12768 where
12769 S: serde::Serializer,
12770 {
12771 use serde::ser::SerializeStruct;
12772 let mut len = 0;
12773 if !self.databases.is_empty() {
12774 len += 1;
12775 }
12776 if !self.schemas.is_empty() {
12777 len += 1;
12778 }
12779 if !self.sources.is_empty() {
12780 len += 1;
12781 }
12782 if !self.sinks.is_empty() {
12783 len += 1;
12784 }
12785 if !self.tables.is_empty() {
12786 len += 1;
12787 }
12788 if !self.indexes.is_empty() {
12789 len += 1;
12790 }
12791 if !self.views.is_empty() {
12792 len += 1;
12793 }
12794 if !self.functions.is_empty() {
12795 len += 1;
12796 }
12797 if !self.connections.is_empty() {
12798 len += 1;
12799 }
12800 if !self.subscriptions.is_empty() {
12801 len += 1;
12802 }
12803 if !self.users.is_empty() {
12804 len += 1;
12805 }
12806 if self.session_params.is_some() {
12807 len += 1;
12808 }
12809 if !self.secrets.is_empty() {
12810 len += 1;
12811 }
12812 if self.cluster_resource.is_some() {
12813 len += 1;
12814 }
12815 if !self.nodes.is_empty() {
12816 len += 1;
12817 }
12818 if self.hummock_version.is_some() {
12819 len += 1;
12820 }
12821 if self.meta_backup_manifest_id.is_some() {
12822 len += 1;
12823 }
12824 if self.hummock_write_limits.is_some() {
12825 len += 1;
12826 }
12827 if !self.streaming_worker_slot_mappings.is_empty() {
12828 len += 1;
12829 }
12830 if !self.serving_worker_slot_mappings.is_empty() {
12831 len += 1;
12832 }
12833 if self.version.is_some() {
12834 len += 1;
12835 }
12836 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
12837 if !self.databases.is_empty() {
12838 struct_ser.serialize_field("databases", &self.databases)?;
12839 }
12840 if !self.schemas.is_empty() {
12841 struct_ser.serialize_field("schemas", &self.schemas)?;
12842 }
12843 if !self.sources.is_empty() {
12844 struct_ser.serialize_field("sources", &self.sources)?;
12845 }
12846 if !self.sinks.is_empty() {
12847 struct_ser.serialize_field("sinks", &self.sinks)?;
12848 }
12849 if !self.tables.is_empty() {
12850 struct_ser.serialize_field("tables", &self.tables)?;
12851 }
12852 if !self.indexes.is_empty() {
12853 struct_ser.serialize_field("indexes", &self.indexes)?;
12854 }
12855 if !self.views.is_empty() {
12856 struct_ser.serialize_field("views", &self.views)?;
12857 }
12858 if !self.functions.is_empty() {
12859 struct_ser.serialize_field("functions", &self.functions)?;
12860 }
12861 if !self.connections.is_empty() {
12862 struct_ser.serialize_field("connections", &self.connections)?;
12863 }
12864 if !self.subscriptions.is_empty() {
12865 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
12866 }
12867 if !self.users.is_empty() {
12868 struct_ser.serialize_field("users", &self.users)?;
12869 }
12870 if let Some(v) = self.session_params.as_ref() {
12871 struct_ser.serialize_field("sessionParams", v)?;
12872 }
12873 if !self.secrets.is_empty() {
12874 struct_ser.serialize_field("secrets", &self.secrets)?;
12875 }
12876 if let Some(v) = self.cluster_resource.as_ref() {
12877 struct_ser.serialize_field("clusterResource", v)?;
12878 }
12879 if !self.nodes.is_empty() {
12880 struct_ser.serialize_field("nodes", &self.nodes)?;
12881 }
12882 if let Some(v) = self.hummock_version.as_ref() {
12883 struct_ser.serialize_field("hummockVersion", v)?;
12884 }
12885 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
12886 struct_ser.serialize_field("metaBackupManifestId", v)?;
12887 }
12888 if let Some(v) = self.hummock_write_limits.as_ref() {
12889 struct_ser.serialize_field("hummockWriteLimits", v)?;
12890 }
12891 if !self.streaming_worker_slot_mappings.is_empty() {
12892 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
12893 }
12894 if !self.serving_worker_slot_mappings.is_empty() {
12895 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
12896 }
12897 if let Some(v) = self.version.as_ref() {
12898 struct_ser.serialize_field("version", v)?;
12899 }
12900 struct_ser.end()
12901 }
12902}
12903impl<'de> serde::Deserialize<'de> for MetaSnapshot {
12904 #[allow(deprecated)]
12905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12906 where
12907 D: serde::Deserializer<'de>,
12908 {
12909 const FIELDS: &[&str] = &[
12910 "databases",
12911 "schemas",
12912 "sources",
12913 "sinks",
12914 "tables",
12915 "indexes",
12916 "views",
12917 "functions",
12918 "connections",
12919 "subscriptions",
12920 "users",
12921 "session_params",
12922 "sessionParams",
12923 "secrets",
12924 "cluster_resource",
12925 "clusterResource",
12926 "nodes",
12927 "hummock_version",
12928 "hummockVersion",
12929 "meta_backup_manifest_id",
12930 "metaBackupManifestId",
12931 "hummock_write_limits",
12932 "hummockWriteLimits",
12933 "streaming_worker_slot_mappings",
12934 "streamingWorkerSlotMappings",
12935 "serving_worker_slot_mappings",
12936 "servingWorkerSlotMappings",
12937 "version",
12938 ];
12939
12940 #[allow(clippy::enum_variant_names)]
12941 enum GeneratedField {
12942 Databases,
12943 Schemas,
12944 Sources,
12945 Sinks,
12946 Tables,
12947 Indexes,
12948 Views,
12949 Functions,
12950 Connections,
12951 Subscriptions,
12952 Users,
12953 SessionParams,
12954 Secrets,
12955 ClusterResource,
12956 Nodes,
12957 HummockVersion,
12958 MetaBackupManifestId,
12959 HummockWriteLimits,
12960 StreamingWorkerSlotMappings,
12961 ServingWorkerSlotMappings,
12962 Version,
12963 }
12964 impl<'de> serde::Deserialize<'de> for GeneratedField {
12965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12966 where
12967 D: serde::Deserializer<'de>,
12968 {
12969 struct GeneratedVisitor;
12970
12971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12972 type Value = GeneratedField;
12973
12974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12975 write!(formatter, "expected one of: {:?}", &FIELDS)
12976 }
12977
12978 #[allow(unused_variables)]
12979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12980 where
12981 E: serde::de::Error,
12982 {
12983 match value {
12984 "databases" => Ok(GeneratedField::Databases),
12985 "schemas" => Ok(GeneratedField::Schemas),
12986 "sources" => Ok(GeneratedField::Sources),
12987 "sinks" => Ok(GeneratedField::Sinks),
12988 "tables" => Ok(GeneratedField::Tables),
12989 "indexes" => Ok(GeneratedField::Indexes),
12990 "views" => Ok(GeneratedField::Views),
12991 "functions" => Ok(GeneratedField::Functions),
12992 "connections" => Ok(GeneratedField::Connections),
12993 "subscriptions" => Ok(GeneratedField::Subscriptions),
12994 "users" => Ok(GeneratedField::Users),
12995 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
12996 "secrets" => Ok(GeneratedField::Secrets),
12997 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
12998 "nodes" => Ok(GeneratedField::Nodes),
12999 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13000 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13001 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13002 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13003 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13004 "version" => Ok(GeneratedField::Version),
13005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13006 }
13007 }
13008 }
13009 deserializer.deserialize_identifier(GeneratedVisitor)
13010 }
13011 }
13012 struct GeneratedVisitor;
13013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13014 type Value = MetaSnapshot;
13015
13016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13017 formatter.write_str("struct meta.MetaSnapshot")
13018 }
13019
13020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13021 where
13022 V: serde::de::MapAccess<'de>,
13023 {
13024 let mut databases__ = None;
13025 let mut schemas__ = None;
13026 let mut sources__ = None;
13027 let mut sinks__ = None;
13028 let mut tables__ = None;
13029 let mut indexes__ = None;
13030 let mut views__ = None;
13031 let mut functions__ = None;
13032 let mut connections__ = None;
13033 let mut subscriptions__ = None;
13034 let mut users__ = None;
13035 let mut session_params__ = None;
13036 let mut secrets__ = None;
13037 let mut cluster_resource__ = None;
13038 let mut nodes__ = None;
13039 let mut hummock_version__ = None;
13040 let mut meta_backup_manifest_id__ = None;
13041 let mut hummock_write_limits__ = None;
13042 let mut streaming_worker_slot_mappings__ = None;
13043 let mut serving_worker_slot_mappings__ = None;
13044 let mut version__ = None;
13045 while let Some(k) = map_.next_key()? {
13046 match k {
13047 GeneratedField::Databases => {
13048 if databases__.is_some() {
13049 return Err(serde::de::Error::duplicate_field("databases"));
13050 }
13051 databases__ = Some(map_.next_value()?);
13052 }
13053 GeneratedField::Schemas => {
13054 if schemas__.is_some() {
13055 return Err(serde::de::Error::duplicate_field("schemas"));
13056 }
13057 schemas__ = Some(map_.next_value()?);
13058 }
13059 GeneratedField::Sources => {
13060 if sources__.is_some() {
13061 return Err(serde::de::Error::duplicate_field("sources"));
13062 }
13063 sources__ = Some(map_.next_value()?);
13064 }
13065 GeneratedField::Sinks => {
13066 if sinks__.is_some() {
13067 return Err(serde::de::Error::duplicate_field("sinks"));
13068 }
13069 sinks__ = Some(map_.next_value()?);
13070 }
13071 GeneratedField::Tables => {
13072 if tables__.is_some() {
13073 return Err(serde::de::Error::duplicate_field("tables"));
13074 }
13075 tables__ = Some(map_.next_value()?);
13076 }
13077 GeneratedField::Indexes => {
13078 if indexes__.is_some() {
13079 return Err(serde::de::Error::duplicate_field("indexes"));
13080 }
13081 indexes__ = Some(map_.next_value()?);
13082 }
13083 GeneratedField::Views => {
13084 if views__.is_some() {
13085 return Err(serde::de::Error::duplicate_field("views"));
13086 }
13087 views__ = Some(map_.next_value()?);
13088 }
13089 GeneratedField::Functions => {
13090 if functions__.is_some() {
13091 return Err(serde::de::Error::duplicate_field("functions"));
13092 }
13093 functions__ = Some(map_.next_value()?);
13094 }
13095 GeneratedField::Connections => {
13096 if connections__.is_some() {
13097 return Err(serde::de::Error::duplicate_field("connections"));
13098 }
13099 connections__ = Some(map_.next_value()?);
13100 }
13101 GeneratedField::Subscriptions => {
13102 if subscriptions__.is_some() {
13103 return Err(serde::de::Error::duplicate_field("subscriptions"));
13104 }
13105 subscriptions__ = Some(map_.next_value()?);
13106 }
13107 GeneratedField::Users => {
13108 if users__.is_some() {
13109 return Err(serde::de::Error::duplicate_field("users"));
13110 }
13111 users__ = Some(map_.next_value()?);
13112 }
13113 GeneratedField::SessionParams => {
13114 if session_params__.is_some() {
13115 return Err(serde::de::Error::duplicate_field("sessionParams"));
13116 }
13117 session_params__ = map_.next_value()?;
13118 }
13119 GeneratedField::Secrets => {
13120 if secrets__.is_some() {
13121 return Err(serde::de::Error::duplicate_field("secrets"));
13122 }
13123 secrets__ = Some(map_.next_value()?);
13124 }
13125 GeneratedField::ClusterResource => {
13126 if cluster_resource__.is_some() {
13127 return Err(serde::de::Error::duplicate_field("clusterResource"));
13128 }
13129 cluster_resource__ = map_.next_value()?;
13130 }
13131 GeneratedField::Nodes => {
13132 if nodes__.is_some() {
13133 return Err(serde::de::Error::duplicate_field("nodes"));
13134 }
13135 nodes__ = Some(map_.next_value()?);
13136 }
13137 GeneratedField::HummockVersion => {
13138 if hummock_version__.is_some() {
13139 return Err(serde::de::Error::duplicate_field("hummockVersion"));
13140 }
13141 hummock_version__ = map_.next_value()?;
13142 }
13143 GeneratedField::MetaBackupManifestId => {
13144 if meta_backup_manifest_id__.is_some() {
13145 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
13146 }
13147 meta_backup_manifest_id__ = map_.next_value()?;
13148 }
13149 GeneratedField::HummockWriteLimits => {
13150 if hummock_write_limits__.is_some() {
13151 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
13152 }
13153 hummock_write_limits__ = map_.next_value()?;
13154 }
13155 GeneratedField::StreamingWorkerSlotMappings => {
13156 if streaming_worker_slot_mappings__.is_some() {
13157 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
13158 }
13159 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
13160 }
13161 GeneratedField::ServingWorkerSlotMappings => {
13162 if serving_worker_slot_mappings__.is_some() {
13163 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
13164 }
13165 serving_worker_slot_mappings__ = Some(map_.next_value()?);
13166 }
13167 GeneratedField::Version => {
13168 if version__.is_some() {
13169 return Err(serde::de::Error::duplicate_field("version"));
13170 }
13171 version__ = map_.next_value()?;
13172 }
13173 }
13174 }
13175 Ok(MetaSnapshot {
13176 databases: databases__.unwrap_or_default(),
13177 schemas: schemas__.unwrap_or_default(),
13178 sources: sources__.unwrap_or_default(),
13179 sinks: sinks__.unwrap_or_default(),
13180 tables: tables__.unwrap_or_default(),
13181 indexes: indexes__.unwrap_or_default(),
13182 views: views__.unwrap_or_default(),
13183 functions: functions__.unwrap_or_default(),
13184 connections: connections__.unwrap_or_default(),
13185 subscriptions: subscriptions__.unwrap_or_default(),
13186 users: users__.unwrap_or_default(),
13187 session_params: session_params__,
13188 secrets: secrets__.unwrap_or_default(),
13189 cluster_resource: cluster_resource__,
13190 nodes: nodes__.unwrap_or_default(),
13191 hummock_version: hummock_version__,
13192 meta_backup_manifest_id: meta_backup_manifest_id__,
13193 hummock_write_limits: hummock_write_limits__,
13194 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
13195 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
13196 version: version__,
13197 })
13198 }
13199 }
13200 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
13201 }
13202}
13203impl serde::Serialize for meta_snapshot::SnapshotVersion {
13204 #[allow(deprecated)]
13205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13206 where
13207 S: serde::Serializer,
13208 {
13209 use serde::ser::SerializeStruct;
13210 let mut len = 0;
13211 if self.catalog_version != 0 {
13212 len += 1;
13213 }
13214 if self.worker_node_version != 0 {
13215 len += 1;
13216 }
13217 if self.streaming_worker_slot_mapping_version != 0 {
13218 len += 1;
13219 }
13220 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
13221 if self.catalog_version != 0 {
13222 #[allow(clippy::needless_borrow)]
13223 #[allow(clippy::needless_borrows_for_generic_args)]
13224 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13225 }
13226 if self.worker_node_version != 0 {
13227 #[allow(clippy::needless_borrow)]
13228 #[allow(clippy::needless_borrows_for_generic_args)]
13229 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
13230 }
13231 if self.streaming_worker_slot_mapping_version != 0 {
13232 #[allow(clippy::needless_borrow)]
13233 #[allow(clippy::needless_borrows_for_generic_args)]
13234 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
13235 }
13236 struct_ser.end()
13237 }
13238}
13239impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
13240 #[allow(deprecated)]
13241 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13242 where
13243 D: serde::Deserializer<'de>,
13244 {
13245 const FIELDS: &[&str] = &[
13246 "catalog_version",
13247 "catalogVersion",
13248 "worker_node_version",
13249 "workerNodeVersion",
13250 "streaming_worker_slot_mapping_version",
13251 "streamingWorkerSlotMappingVersion",
13252 ];
13253
13254 #[allow(clippy::enum_variant_names)]
13255 enum GeneratedField {
13256 CatalogVersion,
13257 WorkerNodeVersion,
13258 StreamingWorkerSlotMappingVersion,
13259 }
13260 impl<'de> serde::Deserialize<'de> for GeneratedField {
13261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13262 where
13263 D: serde::Deserializer<'de>,
13264 {
13265 struct GeneratedVisitor;
13266
13267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13268 type Value = GeneratedField;
13269
13270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13271 write!(formatter, "expected one of: {:?}", &FIELDS)
13272 }
13273
13274 #[allow(unused_variables)]
13275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13276 where
13277 E: serde::de::Error,
13278 {
13279 match value {
13280 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13281 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
13282 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
13283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13284 }
13285 }
13286 }
13287 deserializer.deserialize_identifier(GeneratedVisitor)
13288 }
13289 }
13290 struct GeneratedVisitor;
13291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13292 type Value = meta_snapshot::SnapshotVersion;
13293
13294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13295 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
13296 }
13297
13298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
13299 where
13300 V: serde::de::MapAccess<'de>,
13301 {
13302 let mut catalog_version__ = None;
13303 let mut worker_node_version__ = None;
13304 let mut streaming_worker_slot_mapping_version__ = None;
13305 while let Some(k) = map_.next_key()? {
13306 match k {
13307 GeneratedField::CatalogVersion => {
13308 if catalog_version__.is_some() {
13309 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13310 }
13311 catalog_version__ =
13312 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13313 ;
13314 }
13315 GeneratedField::WorkerNodeVersion => {
13316 if worker_node_version__.is_some() {
13317 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
13318 }
13319 worker_node_version__ =
13320 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13321 ;
13322 }
13323 GeneratedField::StreamingWorkerSlotMappingVersion => {
13324 if streaming_worker_slot_mapping_version__.is_some() {
13325 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
13326 }
13327 streaming_worker_slot_mapping_version__ =
13328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13329 ;
13330 }
13331 }
13332 }
13333 Ok(meta_snapshot::SnapshotVersion {
13334 catalog_version: catalog_version__.unwrap_or_default(),
13335 worker_node_version: worker_node_version__.unwrap_or_default(),
13336 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
13337 })
13338 }
13339 }
13340 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
13341 }
13342}
13343impl serde::Serialize for MigrationPlan {
13344 #[allow(deprecated)]
13345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13346 where
13347 S: serde::Serializer,
13348 {
13349 use serde::ser::SerializeStruct;
13350 let mut len = 0;
13351 if !self.worker_slot_migration_plan.is_empty() {
13352 len += 1;
13353 }
13354 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
13355 if !self.worker_slot_migration_plan.is_empty() {
13356 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
13357 .map(|(k, v)| (k, v.to_string())).collect();
13358 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
13359 }
13360 struct_ser.end()
13361 }
13362}
13363impl<'de> serde::Deserialize<'de> for MigrationPlan {
13364 #[allow(deprecated)]
13365 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13366 where
13367 D: serde::Deserializer<'de>,
13368 {
13369 const FIELDS: &[&str] = &[
13370 "worker_slot_migration_plan",
13371 "workerSlotMigrationPlan",
13372 ];
13373
13374 #[allow(clippy::enum_variant_names)]
13375 enum GeneratedField {
13376 WorkerSlotMigrationPlan,
13377 }
13378 impl<'de> serde::Deserialize<'de> for GeneratedField {
13379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13380 where
13381 D: serde::Deserializer<'de>,
13382 {
13383 struct GeneratedVisitor;
13384
13385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13386 type Value = GeneratedField;
13387
13388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13389 write!(formatter, "expected one of: {:?}", &FIELDS)
13390 }
13391
13392 #[allow(unused_variables)]
13393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13394 where
13395 E: serde::de::Error,
13396 {
13397 match value {
13398 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
13399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13400 }
13401 }
13402 }
13403 deserializer.deserialize_identifier(GeneratedVisitor)
13404 }
13405 }
13406 struct GeneratedVisitor;
13407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13408 type Value = MigrationPlan;
13409
13410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13411 formatter.write_str("struct meta.MigrationPlan")
13412 }
13413
13414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
13415 where
13416 V: serde::de::MapAccess<'de>,
13417 {
13418 let mut worker_slot_migration_plan__ = None;
13419 while let Some(k) = map_.next_key()? {
13420 match k {
13421 GeneratedField::WorkerSlotMigrationPlan => {
13422 if worker_slot_migration_plan__.is_some() {
13423 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
13424 }
13425 worker_slot_migration_plan__ = Some(
13426 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
13427 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
13428 );
13429 }
13430 }
13431 }
13432 Ok(MigrationPlan {
13433 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
13434 })
13435 }
13436 }
13437 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
13438 }
13439}
13440impl serde::Serialize for Object {
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 mut len = 0;
13448 if self.object_info.is_some() {
13449 len += 1;
13450 }
13451 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
13452 if let Some(v) = self.object_info.as_ref() {
13453 match v {
13454 object::ObjectInfo::Database(v) => {
13455 struct_ser.serialize_field("database", v)?;
13456 }
13457 object::ObjectInfo::Schema(v) => {
13458 struct_ser.serialize_field("schema", v)?;
13459 }
13460 object::ObjectInfo::Table(v) => {
13461 struct_ser.serialize_field("table", v)?;
13462 }
13463 object::ObjectInfo::Index(v) => {
13464 struct_ser.serialize_field("index", v)?;
13465 }
13466 object::ObjectInfo::Source(v) => {
13467 struct_ser.serialize_field("source", v)?;
13468 }
13469 object::ObjectInfo::Sink(v) => {
13470 struct_ser.serialize_field("sink", v)?;
13471 }
13472 object::ObjectInfo::View(v) => {
13473 struct_ser.serialize_field("view", v)?;
13474 }
13475 object::ObjectInfo::Function(v) => {
13476 struct_ser.serialize_field("function", v)?;
13477 }
13478 object::ObjectInfo::Connection(v) => {
13479 struct_ser.serialize_field("connection", v)?;
13480 }
13481 object::ObjectInfo::Subscription(v) => {
13482 struct_ser.serialize_field("subscription", v)?;
13483 }
13484 object::ObjectInfo::Secret(v) => {
13485 struct_ser.serialize_field("secret", v)?;
13486 }
13487 }
13488 }
13489 struct_ser.end()
13490 }
13491}
13492impl<'de> serde::Deserialize<'de> for Object {
13493 #[allow(deprecated)]
13494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13495 where
13496 D: serde::Deserializer<'de>,
13497 {
13498 const FIELDS: &[&str] = &[
13499 "database",
13500 "schema",
13501 "table",
13502 "index",
13503 "source",
13504 "sink",
13505 "view",
13506 "function",
13507 "connection",
13508 "subscription",
13509 "secret",
13510 ];
13511
13512 #[allow(clippy::enum_variant_names)]
13513 enum GeneratedField {
13514 Database,
13515 Schema,
13516 Table,
13517 Index,
13518 Source,
13519 Sink,
13520 View,
13521 Function,
13522 Connection,
13523 Subscription,
13524 Secret,
13525 }
13526 impl<'de> serde::Deserialize<'de> for GeneratedField {
13527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13528 where
13529 D: serde::Deserializer<'de>,
13530 {
13531 struct GeneratedVisitor;
13532
13533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13534 type Value = GeneratedField;
13535
13536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13537 write!(formatter, "expected one of: {:?}", &FIELDS)
13538 }
13539
13540 #[allow(unused_variables)]
13541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13542 where
13543 E: serde::de::Error,
13544 {
13545 match value {
13546 "database" => Ok(GeneratedField::Database),
13547 "schema" => Ok(GeneratedField::Schema),
13548 "table" => Ok(GeneratedField::Table),
13549 "index" => Ok(GeneratedField::Index),
13550 "source" => Ok(GeneratedField::Source),
13551 "sink" => Ok(GeneratedField::Sink),
13552 "view" => Ok(GeneratedField::View),
13553 "function" => Ok(GeneratedField::Function),
13554 "connection" => Ok(GeneratedField::Connection),
13555 "subscription" => Ok(GeneratedField::Subscription),
13556 "secret" => Ok(GeneratedField::Secret),
13557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13558 }
13559 }
13560 }
13561 deserializer.deserialize_identifier(GeneratedVisitor)
13562 }
13563 }
13564 struct GeneratedVisitor;
13565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13566 type Value = Object;
13567
13568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13569 formatter.write_str("struct meta.Object")
13570 }
13571
13572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
13573 where
13574 V: serde::de::MapAccess<'de>,
13575 {
13576 let mut object_info__ = None;
13577 while let Some(k) = map_.next_key()? {
13578 match k {
13579 GeneratedField::Database => {
13580 if object_info__.is_some() {
13581 return Err(serde::de::Error::duplicate_field("database"));
13582 }
13583 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
13584;
13585 }
13586 GeneratedField::Schema => {
13587 if object_info__.is_some() {
13588 return Err(serde::de::Error::duplicate_field("schema"));
13589 }
13590 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
13591;
13592 }
13593 GeneratedField::Table => {
13594 if object_info__.is_some() {
13595 return Err(serde::de::Error::duplicate_field("table"));
13596 }
13597 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
13598;
13599 }
13600 GeneratedField::Index => {
13601 if object_info__.is_some() {
13602 return Err(serde::de::Error::duplicate_field("index"));
13603 }
13604 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
13605;
13606 }
13607 GeneratedField::Source => {
13608 if object_info__.is_some() {
13609 return Err(serde::de::Error::duplicate_field("source"));
13610 }
13611 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
13612;
13613 }
13614 GeneratedField::Sink => {
13615 if object_info__.is_some() {
13616 return Err(serde::de::Error::duplicate_field("sink"));
13617 }
13618 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
13619;
13620 }
13621 GeneratedField::View => {
13622 if object_info__.is_some() {
13623 return Err(serde::de::Error::duplicate_field("view"));
13624 }
13625 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
13626;
13627 }
13628 GeneratedField::Function => {
13629 if object_info__.is_some() {
13630 return Err(serde::de::Error::duplicate_field("function"));
13631 }
13632 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
13633;
13634 }
13635 GeneratedField::Connection => {
13636 if object_info__.is_some() {
13637 return Err(serde::de::Error::duplicate_field("connection"));
13638 }
13639 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
13640;
13641 }
13642 GeneratedField::Subscription => {
13643 if object_info__.is_some() {
13644 return Err(serde::de::Error::duplicate_field("subscription"));
13645 }
13646 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
13647;
13648 }
13649 GeneratedField::Secret => {
13650 if object_info__.is_some() {
13651 return Err(serde::de::Error::duplicate_field("secret"));
13652 }
13653 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
13654;
13655 }
13656 }
13657 }
13658 Ok(Object {
13659 object_info: object_info__,
13660 })
13661 }
13662 }
13663 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
13664 }
13665}
13666impl serde::Serialize for ObjectGroup {
13667 #[allow(deprecated)]
13668 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13669 where
13670 S: serde::Serializer,
13671 {
13672 use serde::ser::SerializeStruct;
13673 let mut len = 0;
13674 if !self.objects.is_empty() {
13675 len += 1;
13676 }
13677 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
13678 if !self.objects.is_empty() {
13679 struct_ser.serialize_field("objects", &self.objects)?;
13680 }
13681 struct_ser.end()
13682 }
13683}
13684impl<'de> serde::Deserialize<'de> for ObjectGroup {
13685 #[allow(deprecated)]
13686 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13687 where
13688 D: serde::Deserializer<'de>,
13689 {
13690 const FIELDS: &[&str] = &[
13691 "objects",
13692 ];
13693
13694 #[allow(clippy::enum_variant_names)]
13695 enum GeneratedField {
13696 Objects,
13697 }
13698 impl<'de> serde::Deserialize<'de> for GeneratedField {
13699 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13700 where
13701 D: serde::Deserializer<'de>,
13702 {
13703 struct GeneratedVisitor;
13704
13705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13706 type Value = GeneratedField;
13707
13708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13709 write!(formatter, "expected one of: {:?}", &FIELDS)
13710 }
13711
13712 #[allow(unused_variables)]
13713 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13714 where
13715 E: serde::de::Error,
13716 {
13717 match value {
13718 "objects" => Ok(GeneratedField::Objects),
13719 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13720 }
13721 }
13722 }
13723 deserializer.deserialize_identifier(GeneratedVisitor)
13724 }
13725 }
13726 struct GeneratedVisitor;
13727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13728 type Value = ObjectGroup;
13729
13730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13731 formatter.write_str("struct meta.ObjectGroup")
13732 }
13733
13734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
13735 where
13736 V: serde::de::MapAccess<'de>,
13737 {
13738 let mut objects__ = None;
13739 while let Some(k) = map_.next_key()? {
13740 match k {
13741 GeneratedField::Objects => {
13742 if objects__.is_some() {
13743 return Err(serde::de::Error::duplicate_field("objects"));
13744 }
13745 objects__ = Some(map_.next_value()?);
13746 }
13747 }
13748 }
13749 Ok(ObjectGroup {
13750 objects: objects__.unwrap_or_default(),
13751 })
13752 }
13753 }
13754 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
13755 }
13756}
13757impl serde::Serialize for PauseRequest {
13758 #[allow(deprecated)]
13759 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13760 where
13761 S: serde::Serializer,
13762 {
13763 use serde::ser::SerializeStruct;
13764 let len = 0;
13765 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
13766 struct_ser.end()
13767 }
13768}
13769impl<'de> serde::Deserialize<'de> for PauseRequest {
13770 #[allow(deprecated)]
13771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13772 where
13773 D: serde::Deserializer<'de>,
13774 {
13775 const FIELDS: &[&str] = &[
13776 ];
13777
13778 #[allow(clippy::enum_variant_names)]
13779 enum GeneratedField {
13780 }
13781 impl<'de> serde::Deserialize<'de> for GeneratedField {
13782 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13783 where
13784 D: serde::Deserializer<'de>,
13785 {
13786 struct GeneratedVisitor;
13787
13788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13789 type Value = GeneratedField;
13790
13791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13792 write!(formatter, "expected one of: {:?}", &FIELDS)
13793 }
13794
13795 #[allow(unused_variables)]
13796 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13797 where
13798 E: serde::de::Error,
13799 {
13800 Err(serde::de::Error::unknown_field(value, FIELDS))
13801 }
13802 }
13803 deserializer.deserialize_identifier(GeneratedVisitor)
13804 }
13805 }
13806 struct GeneratedVisitor;
13807 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13808 type Value = PauseRequest;
13809
13810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13811 formatter.write_str("struct meta.PauseRequest")
13812 }
13813
13814 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
13815 where
13816 V: serde::de::MapAccess<'de>,
13817 {
13818 while map_.next_key::<GeneratedField>()?.is_some() {
13819 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13820 }
13821 Ok(PauseRequest {
13822 })
13823 }
13824 }
13825 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
13826 }
13827}
13828impl serde::Serialize for PauseResponse {
13829 #[allow(deprecated)]
13830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13831 where
13832 S: serde::Serializer,
13833 {
13834 use serde::ser::SerializeStruct;
13835 let len = 0;
13836 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
13837 struct_ser.end()
13838 }
13839}
13840impl<'de> serde::Deserialize<'de> for PauseResponse {
13841 #[allow(deprecated)]
13842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13843 where
13844 D: serde::Deserializer<'de>,
13845 {
13846 const FIELDS: &[&str] = &[
13847 ];
13848
13849 #[allow(clippy::enum_variant_names)]
13850 enum GeneratedField {
13851 }
13852 impl<'de> serde::Deserialize<'de> for GeneratedField {
13853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13854 where
13855 D: serde::Deserializer<'de>,
13856 {
13857 struct GeneratedVisitor;
13858
13859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13860 type Value = GeneratedField;
13861
13862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13863 write!(formatter, "expected one of: {:?}", &FIELDS)
13864 }
13865
13866 #[allow(unused_variables)]
13867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13868 where
13869 E: serde::de::Error,
13870 {
13871 Err(serde::de::Error::unknown_field(value, FIELDS))
13872 }
13873 }
13874 deserializer.deserialize_identifier(GeneratedVisitor)
13875 }
13876 }
13877 struct GeneratedVisitor;
13878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13879 type Value = PauseResponse;
13880
13881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13882 formatter.write_str("struct meta.PauseResponse")
13883 }
13884
13885 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
13886 where
13887 V: serde::de::MapAccess<'de>,
13888 {
13889 while map_.next_key::<GeneratedField>()?.is_some() {
13890 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13891 }
13892 Ok(PauseResponse {
13893 })
13894 }
13895 }
13896 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
13897 }
13898}
13899impl serde::Serialize for RecoverRequest {
13900 #[allow(deprecated)]
13901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13902 where
13903 S: serde::Serializer,
13904 {
13905 use serde::ser::SerializeStruct;
13906 let len = 0;
13907 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
13908 struct_ser.end()
13909 }
13910}
13911impl<'de> serde::Deserialize<'de> for RecoverRequest {
13912 #[allow(deprecated)]
13913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13914 where
13915 D: serde::Deserializer<'de>,
13916 {
13917 const FIELDS: &[&str] = &[
13918 ];
13919
13920 #[allow(clippy::enum_variant_names)]
13921 enum GeneratedField {
13922 }
13923 impl<'de> serde::Deserialize<'de> for GeneratedField {
13924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13925 where
13926 D: serde::Deserializer<'de>,
13927 {
13928 struct GeneratedVisitor;
13929
13930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13931 type Value = GeneratedField;
13932
13933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13934 write!(formatter, "expected one of: {:?}", &FIELDS)
13935 }
13936
13937 #[allow(unused_variables)]
13938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13939 where
13940 E: serde::de::Error,
13941 {
13942 Err(serde::de::Error::unknown_field(value, FIELDS))
13943 }
13944 }
13945 deserializer.deserialize_identifier(GeneratedVisitor)
13946 }
13947 }
13948 struct GeneratedVisitor;
13949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13950 type Value = RecoverRequest;
13951
13952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13953 formatter.write_str("struct meta.RecoverRequest")
13954 }
13955
13956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
13957 where
13958 V: serde::de::MapAccess<'de>,
13959 {
13960 while map_.next_key::<GeneratedField>()?.is_some() {
13961 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13962 }
13963 Ok(RecoverRequest {
13964 })
13965 }
13966 }
13967 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
13968 }
13969}
13970impl serde::Serialize for RecoverResponse {
13971 #[allow(deprecated)]
13972 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13973 where
13974 S: serde::Serializer,
13975 {
13976 use serde::ser::SerializeStruct;
13977 let len = 0;
13978 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
13979 struct_ser.end()
13980 }
13981}
13982impl<'de> serde::Deserialize<'de> for RecoverResponse {
13983 #[allow(deprecated)]
13984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13985 where
13986 D: serde::Deserializer<'de>,
13987 {
13988 const FIELDS: &[&str] = &[
13989 ];
13990
13991 #[allow(clippy::enum_variant_names)]
13992 enum GeneratedField {
13993 }
13994 impl<'de> serde::Deserialize<'de> for GeneratedField {
13995 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13996 where
13997 D: serde::Deserializer<'de>,
13998 {
13999 struct GeneratedVisitor;
14000
14001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14002 type Value = GeneratedField;
14003
14004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14005 write!(formatter, "expected one of: {:?}", &FIELDS)
14006 }
14007
14008 #[allow(unused_variables)]
14009 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14010 where
14011 E: serde::de::Error,
14012 {
14013 Err(serde::de::Error::unknown_field(value, FIELDS))
14014 }
14015 }
14016 deserializer.deserialize_identifier(GeneratedVisitor)
14017 }
14018 }
14019 struct GeneratedVisitor;
14020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14021 type Value = RecoverResponse;
14022
14023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14024 formatter.write_str("struct meta.RecoverResponse")
14025 }
14026
14027 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
14028 where
14029 V: serde::de::MapAccess<'de>,
14030 {
14031 while map_.next_key::<GeneratedField>()?.is_some() {
14032 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14033 }
14034 Ok(RecoverResponse {
14035 })
14036 }
14037 }
14038 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
14039 }
14040}
14041impl serde::Serialize for Recovery {
14042 #[allow(deprecated)]
14043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14044 where
14045 S: serde::Serializer,
14046 {
14047 use serde::ser::SerializeStruct;
14048 let len = 0;
14049 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
14050 struct_ser.end()
14051 }
14052}
14053impl<'de> serde::Deserialize<'de> for Recovery {
14054 #[allow(deprecated)]
14055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14056 where
14057 D: serde::Deserializer<'de>,
14058 {
14059 const FIELDS: &[&str] = &[
14060 ];
14061
14062 #[allow(clippy::enum_variant_names)]
14063 enum GeneratedField {
14064 }
14065 impl<'de> serde::Deserialize<'de> for GeneratedField {
14066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14067 where
14068 D: serde::Deserializer<'de>,
14069 {
14070 struct GeneratedVisitor;
14071
14072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14073 type Value = GeneratedField;
14074
14075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14076 write!(formatter, "expected one of: {:?}", &FIELDS)
14077 }
14078
14079 #[allow(unused_variables)]
14080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14081 where
14082 E: serde::de::Error,
14083 {
14084 Err(serde::de::Error::unknown_field(value, FIELDS))
14085 }
14086 }
14087 deserializer.deserialize_identifier(GeneratedVisitor)
14088 }
14089 }
14090 struct GeneratedVisitor;
14091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14092 type Value = Recovery;
14093
14094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14095 formatter.write_str("struct meta.Recovery")
14096 }
14097
14098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
14099 where
14100 V: serde::de::MapAccess<'de>,
14101 {
14102 while map_.next_key::<GeneratedField>()?.is_some() {
14103 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14104 }
14105 Ok(Recovery {
14106 })
14107 }
14108 }
14109 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
14110 }
14111}
14112impl serde::Serialize for RecoveryStatus {
14113 #[allow(deprecated)]
14114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14115 where
14116 S: serde::Serializer,
14117 {
14118 let variant = match self {
14119 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
14120 Self::StatusStarting => "STATUS_STARTING",
14121 Self::StatusRecovering => "STATUS_RECOVERING",
14122 Self::StatusRunning => "STATUS_RUNNING",
14123 };
14124 serializer.serialize_str(variant)
14125 }
14126}
14127impl<'de> serde::Deserialize<'de> for RecoveryStatus {
14128 #[allow(deprecated)]
14129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14130 where
14131 D: serde::Deserializer<'de>,
14132 {
14133 const FIELDS: &[&str] = &[
14134 "STATUS_UNSPECIFIED",
14135 "STATUS_STARTING",
14136 "STATUS_RECOVERING",
14137 "STATUS_RUNNING",
14138 ];
14139
14140 struct GeneratedVisitor;
14141
14142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14143 type Value = RecoveryStatus;
14144
14145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14146 write!(formatter, "expected one of: {:?}", &FIELDS)
14147 }
14148
14149 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14150 where
14151 E: serde::de::Error,
14152 {
14153 i32::try_from(v)
14154 .ok()
14155 .and_then(|x| x.try_into().ok())
14156 .ok_or_else(|| {
14157 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14158 })
14159 }
14160
14161 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14162 where
14163 E: serde::de::Error,
14164 {
14165 i32::try_from(v)
14166 .ok()
14167 .and_then(|x| x.try_into().ok())
14168 .ok_or_else(|| {
14169 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14170 })
14171 }
14172
14173 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14174 where
14175 E: serde::de::Error,
14176 {
14177 match value {
14178 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
14179 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
14180 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
14181 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
14182 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14183 }
14184 }
14185 }
14186 deserializer.deserialize_any(GeneratedVisitor)
14187 }
14188}
14189impl serde::Serialize for RefreshRequest {
14190 #[allow(deprecated)]
14191 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14192 where
14193 S: serde::Serializer,
14194 {
14195 use serde::ser::SerializeStruct;
14196 let mut len = 0;
14197 if self.table_id != 0 {
14198 len += 1;
14199 }
14200 if self.associated_source_id != 0 {
14201 len += 1;
14202 }
14203 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
14204 if self.table_id != 0 {
14205 struct_ser.serialize_field("tableId", &self.table_id)?;
14206 }
14207 if self.associated_source_id != 0 {
14208 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
14209 }
14210 struct_ser.end()
14211 }
14212}
14213impl<'de> serde::Deserialize<'de> for RefreshRequest {
14214 #[allow(deprecated)]
14215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14216 where
14217 D: serde::Deserializer<'de>,
14218 {
14219 const FIELDS: &[&str] = &[
14220 "table_id",
14221 "tableId",
14222 "associated_source_id",
14223 "associatedSourceId",
14224 ];
14225
14226 #[allow(clippy::enum_variant_names)]
14227 enum GeneratedField {
14228 TableId,
14229 AssociatedSourceId,
14230 }
14231 impl<'de> serde::Deserialize<'de> for GeneratedField {
14232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14233 where
14234 D: serde::Deserializer<'de>,
14235 {
14236 struct GeneratedVisitor;
14237
14238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14239 type Value = GeneratedField;
14240
14241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14242 write!(formatter, "expected one of: {:?}", &FIELDS)
14243 }
14244
14245 #[allow(unused_variables)]
14246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14247 where
14248 E: serde::de::Error,
14249 {
14250 match value {
14251 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14252 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
14253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14254 }
14255 }
14256 }
14257 deserializer.deserialize_identifier(GeneratedVisitor)
14258 }
14259 }
14260 struct GeneratedVisitor;
14261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14262 type Value = RefreshRequest;
14263
14264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14265 formatter.write_str("struct meta.RefreshRequest")
14266 }
14267
14268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
14269 where
14270 V: serde::de::MapAccess<'de>,
14271 {
14272 let mut table_id__ = None;
14273 let mut associated_source_id__ = None;
14274 while let Some(k) = map_.next_key()? {
14275 match k {
14276 GeneratedField::TableId => {
14277 if table_id__.is_some() {
14278 return Err(serde::de::Error::duplicate_field("tableId"));
14279 }
14280 table_id__ =
14281 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14282 ;
14283 }
14284 GeneratedField::AssociatedSourceId => {
14285 if associated_source_id__.is_some() {
14286 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
14287 }
14288 associated_source_id__ =
14289 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14290 ;
14291 }
14292 }
14293 }
14294 Ok(RefreshRequest {
14295 table_id: table_id__.unwrap_or_default(),
14296 associated_source_id: associated_source_id__.unwrap_or_default(),
14297 })
14298 }
14299 }
14300 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
14301 }
14302}
14303impl serde::Serialize for RefreshResponse {
14304 #[allow(deprecated)]
14305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14306 where
14307 S: serde::Serializer,
14308 {
14309 use serde::ser::SerializeStruct;
14310 let mut len = 0;
14311 if self.status.is_some() {
14312 len += 1;
14313 }
14314 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
14315 if let Some(v) = self.status.as_ref() {
14316 struct_ser.serialize_field("status", v)?;
14317 }
14318 struct_ser.end()
14319 }
14320}
14321impl<'de> serde::Deserialize<'de> for RefreshResponse {
14322 #[allow(deprecated)]
14323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14324 where
14325 D: serde::Deserializer<'de>,
14326 {
14327 const FIELDS: &[&str] = &[
14328 "status",
14329 ];
14330
14331 #[allow(clippy::enum_variant_names)]
14332 enum GeneratedField {
14333 Status,
14334 }
14335 impl<'de> serde::Deserialize<'de> for GeneratedField {
14336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14337 where
14338 D: serde::Deserializer<'de>,
14339 {
14340 struct GeneratedVisitor;
14341
14342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14343 type Value = GeneratedField;
14344
14345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14346 write!(formatter, "expected one of: {:?}", &FIELDS)
14347 }
14348
14349 #[allow(unused_variables)]
14350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14351 where
14352 E: serde::de::Error,
14353 {
14354 match value {
14355 "status" => Ok(GeneratedField::Status),
14356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14357 }
14358 }
14359 }
14360 deserializer.deserialize_identifier(GeneratedVisitor)
14361 }
14362 }
14363 struct GeneratedVisitor;
14364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14365 type Value = RefreshResponse;
14366
14367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14368 formatter.write_str("struct meta.RefreshResponse")
14369 }
14370
14371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
14372 where
14373 V: serde::de::MapAccess<'de>,
14374 {
14375 let mut status__ = None;
14376 while let Some(k) = map_.next_key()? {
14377 match k {
14378 GeneratedField::Status => {
14379 if status__.is_some() {
14380 return Err(serde::de::Error::duplicate_field("status"));
14381 }
14382 status__ = map_.next_value()?;
14383 }
14384 }
14385 }
14386 Ok(RefreshResponse {
14387 status: status__,
14388 })
14389 }
14390 }
14391 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
14392 }
14393}
14394impl serde::Serialize for RelationIdInfos {
14395 #[allow(deprecated)]
14396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14397 where
14398 S: serde::Serializer,
14399 {
14400 use serde::ser::SerializeStruct;
14401 let mut len = 0;
14402 if !self.map.is_empty() {
14403 len += 1;
14404 }
14405 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
14406 if !self.map.is_empty() {
14407 struct_ser.serialize_field("map", &self.map)?;
14408 }
14409 struct_ser.end()
14410 }
14411}
14412impl<'de> serde::Deserialize<'de> for RelationIdInfos {
14413 #[allow(deprecated)]
14414 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14415 where
14416 D: serde::Deserializer<'de>,
14417 {
14418 const FIELDS: &[&str] = &[
14419 "map",
14420 ];
14421
14422 #[allow(clippy::enum_variant_names)]
14423 enum GeneratedField {
14424 Map,
14425 }
14426 impl<'de> serde::Deserialize<'de> for GeneratedField {
14427 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14428 where
14429 D: serde::Deserializer<'de>,
14430 {
14431 struct GeneratedVisitor;
14432
14433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14434 type Value = GeneratedField;
14435
14436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14437 write!(formatter, "expected one of: {:?}", &FIELDS)
14438 }
14439
14440 #[allow(unused_variables)]
14441 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14442 where
14443 E: serde::de::Error,
14444 {
14445 match value {
14446 "map" => Ok(GeneratedField::Map),
14447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14448 }
14449 }
14450 }
14451 deserializer.deserialize_identifier(GeneratedVisitor)
14452 }
14453 }
14454 struct GeneratedVisitor;
14455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14456 type Value = RelationIdInfos;
14457
14458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14459 formatter.write_str("struct meta.RelationIdInfos")
14460 }
14461
14462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
14463 where
14464 V: serde::de::MapAccess<'de>,
14465 {
14466 let mut map__ = None;
14467 while let Some(k) = map_.next_key()? {
14468 match k {
14469 GeneratedField::Map => {
14470 if map__.is_some() {
14471 return Err(serde::de::Error::duplicate_field("map"));
14472 }
14473 map__ = Some(
14474 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14475 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14476 );
14477 }
14478 }
14479 }
14480 Ok(RelationIdInfos {
14481 map: map__.unwrap_or_default(),
14482 })
14483 }
14484 }
14485 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
14486 }
14487}
14488impl serde::Serialize for RescheduleRequest {
14489 #[allow(deprecated)]
14490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14491 where
14492 S: serde::Serializer,
14493 {
14494 use serde::ser::SerializeStruct;
14495 let mut len = 0;
14496 if self.revision != 0 {
14497 len += 1;
14498 }
14499 if self.resolve_no_shuffle_upstream {
14500 len += 1;
14501 }
14502 if !self.worker_reschedules.is_empty() {
14503 len += 1;
14504 }
14505 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
14506 if self.revision != 0 {
14507 #[allow(clippy::needless_borrow)]
14508 #[allow(clippy::needless_borrows_for_generic_args)]
14509 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
14510 }
14511 if self.resolve_no_shuffle_upstream {
14512 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
14513 }
14514 if !self.worker_reschedules.is_empty() {
14515 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
14516 }
14517 struct_ser.end()
14518 }
14519}
14520impl<'de> serde::Deserialize<'de> for RescheduleRequest {
14521 #[allow(deprecated)]
14522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14523 where
14524 D: serde::Deserializer<'de>,
14525 {
14526 const FIELDS: &[&str] = &[
14527 "revision",
14528 "resolve_no_shuffle_upstream",
14529 "resolveNoShuffleUpstream",
14530 "worker_reschedules",
14531 "workerReschedules",
14532 ];
14533
14534 #[allow(clippy::enum_variant_names)]
14535 enum GeneratedField {
14536 Revision,
14537 ResolveNoShuffleUpstream,
14538 WorkerReschedules,
14539 }
14540 impl<'de> serde::Deserialize<'de> for GeneratedField {
14541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14542 where
14543 D: serde::Deserializer<'de>,
14544 {
14545 struct GeneratedVisitor;
14546
14547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14548 type Value = GeneratedField;
14549
14550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14551 write!(formatter, "expected one of: {:?}", &FIELDS)
14552 }
14553
14554 #[allow(unused_variables)]
14555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14556 where
14557 E: serde::de::Error,
14558 {
14559 match value {
14560 "revision" => Ok(GeneratedField::Revision),
14561 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
14562 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
14563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14564 }
14565 }
14566 }
14567 deserializer.deserialize_identifier(GeneratedVisitor)
14568 }
14569 }
14570 struct GeneratedVisitor;
14571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14572 type Value = RescheduleRequest;
14573
14574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14575 formatter.write_str("struct meta.RescheduleRequest")
14576 }
14577
14578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
14579 where
14580 V: serde::de::MapAccess<'de>,
14581 {
14582 let mut revision__ = None;
14583 let mut resolve_no_shuffle_upstream__ = None;
14584 let mut worker_reschedules__ = None;
14585 while let Some(k) = map_.next_key()? {
14586 match k {
14587 GeneratedField::Revision => {
14588 if revision__.is_some() {
14589 return Err(serde::de::Error::duplicate_field("revision"));
14590 }
14591 revision__ =
14592 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14593 ;
14594 }
14595 GeneratedField::ResolveNoShuffleUpstream => {
14596 if resolve_no_shuffle_upstream__.is_some() {
14597 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
14598 }
14599 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
14600 }
14601 GeneratedField::WorkerReschedules => {
14602 if worker_reschedules__.is_some() {
14603 return Err(serde::de::Error::duplicate_field("workerReschedules"));
14604 }
14605 worker_reschedules__ = Some(
14606 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14607 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14608 );
14609 }
14610 }
14611 }
14612 Ok(RescheduleRequest {
14613 revision: revision__.unwrap_or_default(),
14614 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
14615 worker_reschedules: worker_reschedules__.unwrap_or_default(),
14616 })
14617 }
14618 }
14619 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
14620 }
14621}
14622impl serde::Serialize for RescheduleResponse {
14623 #[allow(deprecated)]
14624 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14625 where
14626 S: serde::Serializer,
14627 {
14628 use serde::ser::SerializeStruct;
14629 let mut len = 0;
14630 if self.success {
14631 len += 1;
14632 }
14633 if self.revision != 0 {
14634 len += 1;
14635 }
14636 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
14637 if self.success {
14638 struct_ser.serialize_field("success", &self.success)?;
14639 }
14640 if self.revision != 0 {
14641 #[allow(clippy::needless_borrow)]
14642 #[allow(clippy::needless_borrows_for_generic_args)]
14643 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
14644 }
14645 struct_ser.end()
14646 }
14647}
14648impl<'de> serde::Deserialize<'de> for RescheduleResponse {
14649 #[allow(deprecated)]
14650 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14651 where
14652 D: serde::Deserializer<'de>,
14653 {
14654 const FIELDS: &[&str] = &[
14655 "success",
14656 "revision",
14657 ];
14658
14659 #[allow(clippy::enum_variant_names)]
14660 enum GeneratedField {
14661 Success,
14662 Revision,
14663 }
14664 impl<'de> serde::Deserialize<'de> for GeneratedField {
14665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14666 where
14667 D: serde::Deserializer<'de>,
14668 {
14669 struct GeneratedVisitor;
14670
14671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14672 type Value = GeneratedField;
14673
14674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14675 write!(formatter, "expected one of: {:?}", &FIELDS)
14676 }
14677
14678 #[allow(unused_variables)]
14679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14680 where
14681 E: serde::de::Error,
14682 {
14683 match value {
14684 "success" => Ok(GeneratedField::Success),
14685 "revision" => Ok(GeneratedField::Revision),
14686 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14687 }
14688 }
14689 }
14690 deserializer.deserialize_identifier(GeneratedVisitor)
14691 }
14692 }
14693 struct GeneratedVisitor;
14694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14695 type Value = RescheduleResponse;
14696
14697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14698 formatter.write_str("struct meta.RescheduleResponse")
14699 }
14700
14701 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
14702 where
14703 V: serde::de::MapAccess<'de>,
14704 {
14705 let mut success__ = None;
14706 let mut revision__ = None;
14707 while let Some(k) = map_.next_key()? {
14708 match k {
14709 GeneratedField::Success => {
14710 if success__.is_some() {
14711 return Err(serde::de::Error::duplicate_field("success"));
14712 }
14713 success__ = Some(map_.next_value()?);
14714 }
14715 GeneratedField::Revision => {
14716 if revision__.is_some() {
14717 return Err(serde::de::Error::duplicate_field("revision"));
14718 }
14719 revision__ =
14720 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14721 ;
14722 }
14723 }
14724 }
14725 Ok(RescheduleResponse {
14726 success: success__.unwrap_or_default(),
14727 revision: revision__.unwrap_or_default(),
14728 })
14729 }
14730 }
14731 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
14732 }
14733}
14734impl serde::Serialize for ResumeRequest {
14735 #[allow(deprecated)]
14736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14737 where
14738 S: serde::Serializer,
14739 {
14740 use serde::ser::SerializeStruct;
14741 let len = 0;
14742 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
14743 struct_ser.end()
14744 }
14745}
14746impl<'de> serde::Deserialize<'de> for ResumeRequest {
14747 #[allow(deprecated)]
14748 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14749 where
14750 D: serde::Deserializer<'de>,
14751 {
14752 const FIELDS: &[&str] = &[
14753 ];
14754
14755 #[allow(clippy::enum_variant_names)]
14756 enum GeneratedField {
14757 }
14758 impl<'de> serde::Deserialize<'de> for GeneratedField {
14759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14760 where
14761 D: serde::Deserializer<'de>,
14762 {
14763 struct GeneratedVisitor;
14764
14765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14766 type Value = GeneratedField;
14767
14768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14769 write!(formatter, "expected one of: {:?}", &FIELDS)
14770 }
14771
14772 #[allow(unused_variables)]
14773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14774 where
14775 E: serde::de::Error,
14776 {
14777 Err(serde::de::Error::unknown_field(value, FIELDS))
14778 }
14779 }
14780 deserializer.deserialize_identifier(GeneratedVisitor)
14781 }
14782 }
14783 struct GeneratedVisitor;
14784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14785 type Value = ResumeRequest;
14786
14787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14788 formatter.write_str("struct meta.ResumeRequest")
14789 }
14790
14791 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
14792 where
14793 V: serde::de::MapAccess<'de>,
14794 {
14795 while map_.next_key::<GeneratedField>()?.is_some() {
14796 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14797 }
14798 Ok(ResumeRequest {
14799 })
14800 }
14801 }
14802 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
14803 }
14804}
14805impl serde::Serialize for ResumeResponse {
14806 #[allow(deprecated)]
14807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14808 where
14809 S: serde::Serializer,
14810 {
14811 use serde::ser::SerializeStruct;
14812 let len = 0;
14813 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
14814 struct_ser.end()
14815 }
14816}
14817impl<'de> serde::Deserialize<'de> for ResumeResponse {
14818 #[allow(deprecated)]
14819 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14820 where
14821 D: serde::Deserializer<'de>,
14822 {
14823 const FIELDS: &[&str] = &[
14824 ];
14825
14826 #[allow(clippy::enum_variant_names)]
14827 enum GeneratedField {
14828 }
14829 impl<'de> serde::Deserialize<'de> for GeneratedField {
14830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14831 where
14832 D: serde::Deserializer<'de>,
14833 {
14834 struct GeneratedVisitor;
14835
14836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14837 type Value = GeneratedField;
14838
14839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14840 write!(formatter, "expected one of: {:?}", &FIELDS)
14841 }
14842
14843 #[allow(unused_variables)]
14844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14845 where
14846 E: serde::de::Error,
14847 {
14848 Err(serde::de::Error::unknown_field(value, FIELDS))
14849 }
14850 }
14851 deserializer.deserialize_identifier(GeneratedVisitor)
14852 }
14853 }
14854 struct GeneratedVisitor;
14855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14856 type Value = ResumeResponse;
14857
14858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14859 formatter.write_str("struct meta.ResumeResponse")
14860 }
14861
14862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
14863 where
14864 V: serde::de::MapAccess<'de>,
14865 {
14866 while map_.next_key::<GeneratedField>()?.is_some() {
14867 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14868 }
14869 Ok(ResumeResponse {
14870 })
14871 }
14872 }
14873 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
14874 }
14875}
14876impl serde::Serialize for SetSessionParamRequest {
14877 #[allow(deprecated)]
14878 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14879 where
14880 S: serde::Serializer,
14881 {
14882 use serde::ser::SerializeStruct;
14883 let mut len = 0;
14884 if !self.param.is_empty() {
14885 len += 1;
14886 }
14887 if self.value.is_some() {
14888 len += 1;
14889 }
14890 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
14891 if !self.param.is_empty() {
14892 struct_ser.serialize_field("param", &self.param)?;
14893 }
14894 if let Some(v) = self.value.as_ref() {
14895 struct_ser.serialize_field("value", v)?;
14896 }
14897 struct_ser.end()
14898 }
14899}
14900impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
14901 #[allow(deprecated)]
14902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14903 where
14904 D: serde::Deserializer<'de>,
14905 {
14906 const FIELDS: &[&str] = &[
14907 "param",
14908 "value",
14909 ];
14910
14911 #[allow(clippy::enum_variant_names)]
14912 enum GeneratedField {
14913 Param,
14914 Value,
14915 }
14916 impl<'de> serde::Deserialize<'de> for GeneratedField {
14917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14918 where
14919 D: serde::Deserializer<'de>,
14920 {
14921 struct GeneratedVisitor;
14922
14923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14924 type Value = GeneratedField;
14925
14926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14927 write!(formatter, "expected one of: {:?}", &FIELDS)
14928 }
14929
14930 #[allow(unused_variables)]
14931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14932 where
14933 E: serde::de::Error,
14934 {
14935 match value {
14936 "param" => Ok(GeneratedField::Param),
14937 "value" => Ok(GeneratedField::Value),
14938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14939 }
14940 }
14941 }
14942 deserializer.deserialize_identifier(GeneratedVisitor)
14943 }
14944 }
14945 struct GeneratedVisitor;
14946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14947 type Value = SetSessionParamRequest;
14948
14949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14950 formatter.write_str("struct meta.SetSessionParamRequest")
14951 }
14952
14953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
14954 where
14955 V: serde::de::MapAccess<'de>,
14956 {
14957 let mut param__ = None;
14958 let mut value__ = None;
14959 while let Some(k) = map_.next_key()? {
14960 match k {
14961 GeneratedField::Param => {
14962 if param__.is_some() {
14963 return Err(serde::de::Error::duplicate_field("param"));
14964 }
14965 param__ = Some(map_.next_value()?);
14966 }
14967 GeneratedField::Value => {
14968 if value__.is_some() {
14969 return Err(serde::de::Error::duplicate_field("value"));
14970 }
14971 value__ = map_.next_value()?;
14972 }
14973 }
14974 }
14975 Ok(SetSessionParamRequest {
14976 param: param__.unwrap_or_default(),
14977 value: value__,
14978 })
14979 }
14980 }
14981 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
14982 }
14983}
14984impl serde::Serialize for SetSessionParamResponse {
14985 #[allow(deprecated)]
14986 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14987 where
14988 S: serde::Serializer,
14989 {
14990 use serde::ser::SerializeStruct;
14991 let mut len = 0;
14992 if !self.param.is_empty() {
14993 len += 1;
14994 }
14995 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
14996 if !self.param.is_empty() {
14997 struct_ser.serialize_field("param", &self.param)?;
14998 }
14999 struct_ser.end()
15000 }
15001}
15002impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
15003 #[allow(deprecated)]
15004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15005 where
15006 D: serde::Deserializer<'de>,
15007 {
15008 const FIELDS: &[&str] = &[
15009 "param",
15010 ];
15011
15012 #[allow(clippy::enum_variant_names)]
15013 enum GeneratedField {
15014 Param,
15015 }
15016 impl<'de> serde::Deserialize<'de> for GeneratedField {
15017 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15018 where
15019 D: serde::Deserializer<'de>,
15020 {
15021 struct GeneratedVisitor;
15022
15023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15024 type Value = GeneratedField;
15025
15026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15027 write!(formatter, "expected one of: {:?}", &FIELDS)
15028 }
15029
15030 #[allow(unused_variables)]
15031 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15032 where
15033 E: serde::de::Error,
15034 {
15035 match value {
15036 "param" => Ok(GeneratedField::Param),
15037 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15038 }
15039 }
15040 }
15041 deserializer.deserialize_identifier(GeneratedVisitor)
15042 }
15043 }
15044 struct GeneratedVisitor;
15045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15046 type Value = SetSessionParamResponse;
15047
15048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15049 formatter.write_str("struct meta.SetSessionParamResponse")
15050 }
15051
15052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
15053 where
15054 V: serde::de::MapAccess<'de>,
15055 {
15056 let mut param__ = None;
15057 while let Some(k) = map_.next_key()? {
15058 match k {
15059 GeneratedField::Param => {
15060 if param__.is_some() {
15061 return Err(serde::de::Error::duplicate_field("param"));
15062 }
15063 param__ = Some(map_.next_value()?);
15064 }
15065 }
15066 }
15067 Ok(SetSessionParamResponse {
15068 param: param__.unwrap_or_default(),
15069 })
15070 }
15071 }
15072 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
15073 }
15074}
15075impl serde::Serialize for SetSyncLogStoreAlignedRequest {
15076 #[allow(deprecated)]
15077 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15078 where
15079 S: serde::Serializer,
15080 {
15081 use serde::ser::SerializeStruct;
15082 let mut len = 0;
15083 if self.job_id != 0 {
15084 len += 1;
15085 }
15086 if self.aligned {
15087 len += 1;
15088 }
15089 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
15090 if self.job_id != 0 {
15091 struct_ser.serialize_field("jobId", &self.job_id)?;
15092 }
15093 if self.aligned {
15094 struct_ser.serialize_field("aligned", &self.aligned)?;
15095 }
15096 struct_ser.end()
15097 }
15098}
15099impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
15100 #[allow(deprecated)]
15101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15102 where
15103 D: serde::Deserializer<'de>,
15104 {
15105 const FIELDS: &[&str] = &[
15106 "job_id",
15107 "jobId",
15108 "aligned",
15109 ];
15110
15111 #[allow(clippy::enum_variant_names)]
15112 enum GeneratedField {
15113 JobId,
15114 Aligned,
15115 }
15116 impl<'de> serde::Deserialize<'de> for GeneratedField {
15117 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15118 where
15119 D: serde::Deserializer<'de>,
15120 {
15121 struct GeneratedVisitor;
15122
15123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15124 type Value = GeneratedField;
15125
15126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15127 write!(formatter, "expected one of: {:?}", &FIELDS)
15128 }
15129
15130 #[allow(unused_variables)]
15131 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15132 where
15133 E: serde::de::Error,
15134 {
15135 match value {
15136 "jobId" | "job_id" => Ok(GeneratedField::JobId),
15137 "aligned" => Ok(GeneratedField::Aligned),
15138 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15139 }
15140 }
15141 }
15142 deserializer.deserialize_identifier(GeneratedVisitor)
15143 }
15144 }
15145 struct GeneratedVisitor;
15146 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15147 type Value = SetSyncLogStoreAlignedRequest;
15148
15149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15150 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
15151 }
15152
15153 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
15154 where
15155 V: serde::de::MapAccess<'de>,
15156 {
15157 let mut job_id__ = None;
15158 let mut aligned__ = None;
15159 while let Some(k) = map_.next_key()? {
15160 match k {
15161 GeneratedField::JobId => {
15162 if job_id__.is_some() {
15163 return Err(serde::de::Error::duplicate_field("jobId"));
15164 }
15165 job_id__ =
15166 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15167 ;
15168 }
15169 GeneratedField::Aligned => {
15170 if aligned__.is_some() {
15171 return Err(serde::de::Error::duplicate_field("aligned"));
15172 }
15173 aligned__ = Some(map_.next_value()?);
15174 }
15175 }
15176 }
15177 Ok(SetSyncLogStoreAlignedRequest {
15178 job_id: job_id__.unwrap_or_default(),
15179 aligned: aligned__.unwrap_or_default(),
15180 })
15181 }
15182 }
15183 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
15184 }
15185}
15186impl serde::Serialize for SetSyncLogStoreAlignedResponse {
15187 #[allow(deprecated)]
15188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15189 where
15190 S: serde::Serializer,
15191 {
15192 use serde::ser::SerializeStruct;
15193 let len = 0;
15194 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
15195 struct_ser.end()
15196 }
15197}
15198impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
15199 #[allow(deprecated)]
15200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15201 where
15202 D: serde::Deserializer<'de>,
15203 {
15204 const FIELDS: &[&str] = &[
15205 ];
15206
15207 #[allow(clippy::enum_variant_names)]
15208 enum GeneratedField {
15209 }
15210 impl<'de> serde::Deserialize<'de> for GeneratedField {
15211 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15212 where
15213 D: serde::Deserializer<'de>,
15214 {
15215 struct GeneratedVisitor;
15216
15217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15218 type Value = GeneratedField;
15219
15220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15221 write!(formatter, "expected one of: {:?}", &FIELDS)
15222 }
15223
15224 #[allow(unused_variables)]
15225 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15226 where
15227 E: serde::de::Error,
15228 {
15229 Err(serde::de::Error::unknown_field(value, FIELDS))
15230 }
15231 }
15232 deserializer.deserialize_identifier(GeneratedVisitor)
15233 }
15234 }
15235 struct GeneratedVisitor;
15236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15237 type Value = SetSyncLogStoreAlignedResponse;
15238
15239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15240 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
15241 }
15242
15243 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
15244 where
15245 V: serde::de::MapAccess<'de>,
15246 {
15247 while map_.next_key::<GeneratedField>()?.is_some() {
15248 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15249 }
15250 Ok(SetSyncLogStoreAlignedResponse {
15251 })
15252 }
15253 }
15254 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
15255 }
15256}
15257impl serde::Serialize for SetSystemParamRequest {
15258 #[allow(deprecated)]
15259 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15260 where
15261 S: serde::Serializer,
15262 {
15263 use serde::ser::SerializeStruct;
15264 let mut len = 0;
15265 if !self.param.is_empty() {
15266 len += 1;
15267 }
15268 if self.value.is_some() {
15269 len += 1;
15270 }
15271 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
15272 if !self.param.is_empty() {
15273 struct_ser.serialize_field("param", &self.param)?;
15274 }
15275 if let Some(v) = self.value.as_ref() {
15276 struct_ser.serialize_field("value", v)?;
15277 }
15278 struct_ser.end()
15279 }
15280}
15281impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
15282 #[allow(deprecated)]
15283 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15284 where
15285 D: serde::Deserializer<'de>,
15286 {
15287 const FIELDS: &[&str] = &[
15288 "param",
15289 "value",
15290 ];
15291
15292 #[allow(clippy::enum_variant_names)]
15293 enum GeneratedField {
15294 Param,
15295 Value,
15296 }
15297 impl<'de> serde::Deserialize<'de> for GeneratedField {
15298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15299 where
15300 D: serde::Deserializer<'de>,
15301 {
15302 struct GeneratedVisitor;
15303
15304 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15305 type Value = GeneratedField;
15306
15307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15308 write!(formatter, "expected one of: {:?}", &FIELDS)
15309 }
15310
15311 #[allow(unused_variables)]
15312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15313 where
15314 E: serde::de::Error,
15315 {
15316 match value {
15317 "param" => Ok(GeneratedField::Param),
15318 "value" => Ok(GeneratedField::Value),
15319 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15320 }
15321 }
15322 }
15323 deserializer.deserialize_identifier(GeneratedVisitor)
15324 }
15325 }
15326 struct GeneratedVisitor;
15327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15328 type Value = SetSystemParamRequest;
15329
15330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15331 formatter.write_str("struct meta.SetSystemParamRequest")
15332 }
15333
15334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
15335 where
15336 V: serde::de::MapAccess<'de>,
15337 {
15338 let mut param__ = None;
15339 let mut value__ = None;
15340 while let Some(k) = map_.next_key()? {
15341 match k {
15342 GeneratedField::Param => {
15343 if param__.is_some() {
15344 return Err(serde::de::Error::duplicate_field("param"));
15345 }
15346 param__ = Some(map_.next_value()?);
15347 }
15348 GeneratedField::Value => {
15349 if value__.is_some() {
15350 return Err(serde::de::Error::duplicate_field("value"));
15351 }
15352 value__ = map_.next_value()?;
15353 }
15354 }
15355 }
15356 Ok(SetSystemParamRequest {
15357 param: param__.unwrap_or_default(),
15358 value: value__,
15359 })
15360 }
15361 }
15362 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
15363 }
15364}
15365impl serde::Serialize for SetSystemParamResponse {
15366 #[allow(deprecated)]
15367 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15368 where
15369 S: serde::Serializer,
15370 {
15371 use serde::ser::SerializeStruct;
15372 let mut len = 0;
15373 if self.params.is_some() {
15374 len += 1;
15375 }
15376 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
15377 if let Some(v) = self.params.as_ref() {
15378 struct_ser.serialize_field("params", v)?;
15379 }
15380 struct_ser.end()
15381 }
15382}
15383impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
15384 #[allow(deprecated)]
15385 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15386 where
15387 D: serde::Deserializer<'de>,
15388 {
15389 const FIELDS: &[&str] = &[
15390 "params",
15391 ];
15392
15393 #[allow(clippy::enum_variant_names)]
15394 enum GeneratedField {
15395 Params,
15396 }
15397 impl<'de> serde::Deserialize<'de> for GeneratedField {
15398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15399 where
15400 D: serde::Deserializer<'de>,
15401 {
15402 struct GeneratedVisitor;
15403
15404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15405 type Value = GeneratedField;
15406
15407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15408 write!(formatter, "expected one of: {:?}", &FIELDS)
15409 }
15410
15411 #[allow(unused_variables)]
15412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15413 where
15414 E: serde::de::Error,
15415 {
15416 match value {
15417 "params" => Ok(GeneratedField::Params),
15418 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15419 }
15420 }
15421 }
15422 deserializer.deserialize_identifier(GeneratedVisitor)
15423 }
15424 }
15425 struct GeneratedVisitor;
15426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15427 type Value = SetSystemParamResponse;
15428
15429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15430 formatter.write_str("struct meta.SetSystemParamResponse")
15431 }
15432
15433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
15434 where
15435 V: serde::de::MapAccess<'de>,
15436 {
15437 let mut params__ = None;
15438 while let Some(k) = map_.next_key()? {
15439 match k {
15440 GeneratedField::Params => {
15441 if params__.is_some() {
15442 return Err(serde::de::Error::duplicate_field("params"));
15443 }
15444 params__ = map_.next_value()?;
15445 }
15446 }
15447 }
15448 Ok(SetSystemParamResponse {
15449 params: params__,
15450 })
15451 }
15452 }
15453 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
15454 }
15455}
15456impl serde::Serialize for SubscribeRequest {
15457 #[allow(deprecated)]
15458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15459 where
15460 S: serde::Serializer,
15461 {
15462 use serde::ser::SerializeStruct;
15463 let mut len = 0;
15464 if self.subscribe_type != 0 {
15465 len += 1;
15466 }
15467 if self.host.is_some() {
15468 len += 1;
15469 }
15470 if self.worker_id != 0 {
15471 len += 1;
15472 }
15473 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
15474 if self.subscribe_type != 0 {
15475 let v = SubscribeType::try_from(self.subscribe_type)
15476 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
15477 struct_ser.serialize_field("subscribeType", &v)?;
15478 }
15479 if let Some(v) = self.host.as_ref() {
15480 struct_ser.serialize_field("host", v)?;
15481 }
15482 if self.worker_id != 0 {
15483 struct_ser.serialize_field("workerId", &self.worker_id)?;
15484 }
15485 struct_ser.end()
15486 }
15487}
15488impl<'de> serde::Deserialize<'de> for SubscribeRequest {
15489 #[allow(deprecated)]
15490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15491 where
15492 D: serde::Deserializer<'de>,
15493 {
15494 const FIELDS: &[&str] = &[
15495 "subscribe_type",
15496 "subscribeType",
15497 "host",
15498 "worker_id",
15499 "workerId",
15500 ];
15501
15502 #[allow(clippy::enum_variant_names)]
15503 enum GeneratedField {
15504 SubscribeType,
15505 Host,
15506 WorkerId,
15507 }
15508 impl<'de> serde::Deserialize<'de> for GeneratedField {
15509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15510 where
15511 D: serde::Deserializer<'de>,
15512 {
15513 struct GeneratedVisitor;
15514
15515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15516 type Value = GeneratedField;
15517
15518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15519 write!(formatter, "expected one of: {:?}", &FIELDS)
15520 }
15521
15522 #[allow(unused_variables)]
15523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15524 where
15525 E: serde::de::Error,
15526 {
15527 match value {
15528 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
15529 "host" => Ok(GeneratedField::Host),
15530 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
15531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15532 }
15533 }
15534 }
15535 deserializer.deserialize_identifier(GeneratedVisitor)
15536 }
15537 }
15538 struct GeneratedVisitor;
15539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15540 type Value = SubscribeRequest;
15541
15542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15543 formatter.write_str("struct meta.SubscribeRequest")
15544 }
15545
15546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
15547 where
15548 V: serde::de::MapAccess<'de>,
15549 {
15550 let mut subscribe_type__ = None;
15551 let mut host__ = None;
15552 let mut worker_id__ = None;
15553 while let Some(k) = map_.next_key()? {
15554 match k {
15555 GeneratedField::SubscribeType => {
15556 if subscribe_type__.is_some() {
15557 return Err(serde::de::Error::duplicate_field("subscribeType"));
15558 }
15559 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
15560 }
15561 GeneratedField::Host => {
15562 if host__.is_some() {
15563 return Err(serde::de::Error::duplicate_field("host"));
15564 }
15565 host__ = map_.next_value()?;
15566 }
15567 GeneratedField::WorkerId => {
15568 if worker_id__.is_some() {
15569 return Err(serde::de::Error::duplicate_field("workerId"));
15570 }
15571 worker_id__ =
15572 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15573 ;
15574 }
15575 }
15576 }
15577 Ok(SubscribeRequest {
15578 subscribe_type: subscribe_type__.unwrap_or_default(),
15579 host: host__,
15580 worker_id: worker_id__.unwrap_or_default(),
15581 })
15582 }
15583 }
15584 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
15585 }
15586}
15587impl serde::Serialize for SubscribeResponse {
15588 #[allow(deprecated)]
15589 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15590 where
15591 S: serde::Serializer,
15592 {
15593 use serde::ser::SerializeStruct;
15594 let mut len = 0;
15595 if self.status.is_some() {
15596 len += 1;
15597 }
15598 if self.operation != 0 {
15599 len += 1;
15600 }
15601 if self.version != 0 {
15602 len += 1;
15603 }
15604 if self.info.is_some() {
15605 len += 1;
15606 }
15607 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
15608 if let Some(v) = self.status.as_ref() {
15609 struct_ser.serialize_field("status", v)?;
15610 }
15611 if self.operation != 0 {
15612 let v = subscribe_response::Operation::try_from(self.operation)
15613 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
15614 struct_ser.serialize_field("operation", &v)?;
15615 }
15616 if self.version != 0 {
15617 #[allow(clippy::needless_borrow)]
15618 #[allow(clippy::needless_borrows_for_generic_args)]
15619 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
15620 }
15621 if let Some(v) = self.info.as_ref() {
15622 match v {
15623 subscribe_response::Info::Database(v) => {
15624 struct_ser.serialize_field("database", v)?;
15625 }
15626 subscribe_response::Info::Schema(v) => {
15627 struct_ser.serialize_field("schema", v)?;
15628 }
15629 subscribe_response::Info::Function(v) => {
15630 struct_ser.serialize_field("function", v)?;
15631 }
15632 subscribe_response::Info::User(v) => {
15633 struct_ser.serialize_field("user", v)?;
15634 }
15635 subscribe_response::Info::SessionParam(v) => {
15636 struct_ser.serialize_field("sessionParam", v)?;
15637 }
15638 subscribe_response::Info::Node(v) => {
15639 struct_ser.serialize_field("node", v)?;
15640 }
15641 subscribe_response::Info::HummockVersionDeltas(v) => {
15642 struct_ser.serialize_field("hummockVersionDeltas", v)?;
15643 }
15644 subscribe_response::Info::Snapshot(v) => {
15645 struct_ser.serialize_field("snapshot", v)?;
15646 }
15647 subscribe_response::Info::MetaBackupManifestId(v) => {
15648 struct_ser.serialize_field("metaBackupManifestId", v)?;
15649 }
15650 subscribe_response::Info::SystemParams(v) => {
15651 struct_ser.serialize_field("systemParams", v)?;
15652 }
15653 subscribe_response::Info::HummockWriteLimits(v) => {
15654 struct_ser.serialize_field("hummockWriteLimits", v)?;
15655 }
15656 subscribe_response::Info::ObjectGroup(v) => {
15657 struct_ser.serialize_field("objectGroup", v)?;
15658 }
15659 subscribe_response::Info::Connection(v) => {
15660 struct_ser.serialize_field("connection", v)?;
15661 }
15662 subscribe_response::Info::HummockStats(v) => {
15663 struct_ser.serialize_field("hummockStats", v)?;
15664 }
15665 subscribe_response::Info::Recovery(v) => {
15666 struct_ser.serialize_field("recovery", v)?;
15667 }
15668 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
15669 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
15670 }
15671 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
15672 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
15673 }
15674 subscribe_response::Info::Secret(v) => {
15675 struct_ser.serialize_field("secret", v)?;
15676 }
15677 subscribe_response::Info::ClusterResource(v) => {
15678 struct_ser.serialize_field("clusterResource", v)?;
15679 }
15680 }
15681 }
15682 struct_ser.end()
15683 }
15684}
15685impl<'de> serde::Deserialize<'de> for SubscribeResponse {
15686 #[allow(deprecated)]
15687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15688 where
15689 D: serde::Deserializer<'de>,
15690 {
15691 const FIELDS: &[&str] = &[
15692 "status",
15693 "operation",
15694 "version",
15695 "database",
15696 "schema",
15697 "function",
15698 "user",
15699 "session_param",
15700 "sessionParam",
15701 "node",
15702 "hummock_version_deltas",
15703 "hummockVersionDeltas",
15704 "snapshot",
15705 "meta_backup_manifest_id",
15706 "metaBackupManifestId",
15707 "system_params",
15708 "systemParams",
15709 "hummock_write_limits",
15710 "hummockWriteLimits",
15711 "object_group",
15712 "objectGroup",
15713 "connection",
15714 "hummock_stats",
15715 "hummockStats",
15716 "recovery",
15717 "streaming_worker_slot_mapping",
15718 "streamingWorkerSlotMapping",
15719 "serving_worker_slot_mappings",
15720 "servingWorkerSlotMappings",
15721 "secret",
15722 "cluster_resource",
15723 "clusterResource",
15724 ];
15725
15726 #[allow(clippy::enum_variant_names)]
15727 enum GeneratedField {
15728 Status,
15729 Operation,
15730 Version,
15731 Database,
15732 Schema,
15733 Function,
15734 User,
15735 SessionParam,
15736 Node,
15737 HummockVersionDeltas,
15738 Snapshot,
15739 MetaBackupManifestId,
15740 SystemParams,
15741 HummockWriteLimits,
15742 ObjectGroup,
15743 Connection,
15744 HummockStats,
15745 Recovery,
15746 StreamingWorkerSlotMapping,
15747 ServingWorkerSlotMappings,
15748 Secret,
15749 ClusterResource,
15750 }
15751 impl<'de> serde::Deserialize<'de> for GeneratedField {
15752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15753 where
15754 D: serde::Deserializer<'de>,
15755 {
15756 struct GeneratedVisitor;
15757
15758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15759 type Value = GeneratedField;
15760
15761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15762 write!(formatter, "expected one of: {:?}", &FIELDS)
15763 }
15764
15765 #[allow(unused_variables)]
15766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15767 where
15768 E: serde::de::Error,
15769 {
15770 match value {
15771 "status" => Ok(GeneratedField::Status),
15772 "operation" => Ok(GeneratedField::Operation),
15773 "version" => Ok(GeneratedField::Version),
15774 "database" => Ok(GeneratedField::Database),
15775 "schema" => Ok(GeneratedField::Schema),
15776 "function" => Ok(GeneratedField::Function),
15777 "user" => Ok(GeneratedField::User),
15778 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
15779 "node" => Ok(GeneratedField::Node),
15780 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
15781 "snapshot" => Ok(GeneratedField::Snapshot),
15782 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
15783 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
15784 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
15785 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
15786 "connection" => Ok(GeneratedField::Connection),
15787 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
15788 "recovery" => Ok(GeneratedField::Recovery),
15789 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
15790 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
15791 "secret" => Ok(GeneratedField::Secret),
15792 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
15793 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15794 }
15795 }
15796 }
15797 deserializer.deserialize_identifier(GeneratedVisitor)
15798 }
15799 }
15800 struct GeneratedVisitor;
15801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15802 type Value = SubscribeResponse;
15803
15804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15805 formatter.write_str("struct meta.SubscribeResponse")
15806 }
15807
15808 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
15809 where
15810 V: serde::de::MapAccess<'de>,
15811 {
15812 let mut status__ = None;
15813 let mut operation__ = None;
15814 let mut version__ = None;
15815 let mut info__ = None;
15816 while let Some(k) = map_.next_key()? {
15817 match k {
15818 GeneratedField::Status => {
15819 if status__.is_some() {
15820 return Err(serde::de::Error::duplicate_field("status"));
15821 }
15822 status__ = map_.next_value()?;
15823 }
15824 GeneratedField::Operation => {
15825 if operation__.is_some() {
15826 return Err(serde::de::Error::duplicate_field("operation"));
15827 }
15828 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
15829 }
15830 GeneratedField::Version => {
15831 if version__.is_some() {
15832 return Err(serde::de::Error::duplicate_field("version"));
15833 }
15834 version__ =
15835 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15836 ;
15837 }
15838 GeneratedField::Database => {
15839 if info__.is_some() {
15840 return Err(serde::de::Error::duplicate_field("database"));
15841 }
15842 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
15843;
15844 }
15845 GeneratedField::Schema => {
15846 if info__.is_some() {
15847 return Err(serde::de::Error::duplicate_field("schema"));
15848 }
15849 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
15850;
15851 }
15852 GeneratedField::Function => {
15853 if info__.is_some() {
15854 return Err(serde::de::Error::duplicate_field("function"));
15855 }
15856 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
15857;
15858 }
15859 GeneratedField::User => {
15860 if info__.is_some() {
15861 return Err(serde::de::Error::duplicate_field("user"));
15862 }
15863 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
15864;
15865 }
15866 GeneratedField::SessionParam => {
15867 if info__.is_some() {
15868 return Err(serde::de::Error::duplicate_field("sessionParam"));
15869 }
15870 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
15871;
15872 }
15873 GeneratedField::Node => {
15874 if info__.is_some() {
15875 return Err(serde::de::Error::duplicate_field("node"));
15876 }
15877 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
15878;
15879 }
15880 GeneratedField::HummockVersionDeltas => {
15881 if info__.is_some() {
15882 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
15883 }
15884 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
15885;
15886 }
15887 GeneratedField::Snapshot => {
15888 if info__.is_some() {
15889 return Err(serde::de::Error::duplicate_field("snapshot"));
15890 }
15891 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
15892;
15893 }
15894 GeneratedField::MetaBackupManifestId => {
15895 if info__.is_some() {
15896 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
15897 }
15898 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
15899;
15900 }
15901 GeneratedField::SystemParams => {
15902 if info__.is_some() {
15903 return Err(serde::de::Error::duplicate_field("systemParams"));
15904 }
15905 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
15906;
15907 }
15908 GeneratedField::HummockWriteLimits => {
15909 if info__.is_some() {
15910 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
15911 }
15912 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
15913;
15914 }
15915 GeneratedField::ObjectGroup => {
15916 if info__.is_some() {
15917 return Err(serde::de::Error::duplicate_field("objectGroup"));
15918 }
15919 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
15920;
15921 }
15922 GeneratedField::Connection => {
15923 if info__.is_some() {
15924 return Err(serde::de::Error::duplicate_field("connection"));
15925 }
15926 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
15927;
15928 }
15929 GeneratedField::HummockStats => {
15930 if info__.is_some() {
15931 return Err(serde::de::Error::duplicate_field("hummockStats"));
15932 }
15933 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
15934;
15935 }
15936 GeneratedField::Recovery => {
15937 if info__.is_some() {
15938 return Err(serde::de::Error::duplicate_field("recovery"));
15939 }
15940 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
15941;
15942 }
15943 GeneratedField::StreamingWorkerSlotMapping => {
15944 if info__.is_some() {
15945 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
15946 }
15947 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
15948;
15949 }
15950 GeneratedField::ServingWorkerSlotMappings => {
15951 if info__.is_some() {
15952 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
15953 }
15954 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
15955;
15956 }
15957 GeneratedField::Secret => {
15958 if info__.is_some() {
15959 return Err(serde::de::Error::duplicate_field("secret"));
15960 }
15961 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
15962;
15963 }
15964 GeneratedField::ClusterResource => {
15965 if info__.is_some() {
15966 return Err(serde::de::Error::duplicate_field("clusterResource"));
15967 }
15968 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
15969;
15970 }
15971 }
15972 }
15973 Ok(SubscribeResponse {
15974 status: status__,
15975 operation: operation__.unwrap_or_default(),
15976 version: version__.unwrap_or_default(),
15977 info: info__,
15978 })
15979 }
15980 }
15981 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
15982 }
15983}
15984impl serde::Serialize for subscribe_response::Operation {
15985 #[allow(deprecated)]
15986 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15987 where
15988 S: serde::Serializer,
15989 {
15990 let variant = match self {
15991 Self::Unspecified => "UNSPECIFIED",
15992 Self::Add => "ADD",
15993 Self::Delete => "DELETE",
15994 Self::Update => "UPDATE",
15995 Self::Snapshot => "SNAPSHOT",
15996 };
15997 serializer.serialize_str(variant)
15998 }
15999}
16000impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
16001 #[allow(deprecated)]
16002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16003 where
16004 D: serde::Deserializer<'de>,
16005 {
16006 const FIELDS: &[&str] = &[
16007 "UNSPECIFIED",
16008 "ADD",
16009 "DELETE",
16010 "UPDATE",
16011 "SNAPSHOT",
16012 ];
16013
16014 struct GeneratedVisitor;
16015
16016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16017 type Value = subscribe_response::Operation;
16018
16019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16020 write!(formatter, "expected one of: {:?}", &FIELDS)
16021 }
16022
16023 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16024 where
16025 E: serde::de::Error,
16026 {
16027 i32::try_from(v)
16028 .ok()
16029 .and_then(|x| x.try_into().ok())
16030 .ok_or_else(|| {
16031 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16032 })
16033 }
16034
16035 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16036 where
16037 E: serde::de::Error,
16038 {
16039 i32::try_from(v)
16040 .ok()
16041 .and_then(|x| x.try_into().ok())
16042 .ok_or_else(|| {
16043 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16044 })
16045 }
16046
16047 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16048 where
16049 E: serde::de::Error,
16050 {
16051 match value {
16052 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
16053 "ADD" => Ok(subscribe_response::Operation::Add),
16054 "DELETE" => Ok(subscribe_response::Operation::Delete),
16055 "UPDATE" => Ok(subscribe_response::Operation::Update),
16056 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
16057 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16058 }
16059 }
16060 }
16061 deserializer.deserialize_any(GeneratedVisitor)
16062 }
16063}
16064impl serde::Serialize for SubscribeType {
16065 #[allow(deprecated)]
16066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16067 where
16068 S: serde::Serializer,
16069 {
16070 let variant = match self {
16071 Self::Unspecified => "UNSPECIFIED",
16072 Self::Frontend => "FRONTEND",
16073 Self::Hummock => "HUMMOCK",
16074 Self::Compactor => "COMPACTOR",
16075 Self::Compute => "COMPUTE",
16076 };
16077 serializer.serialize_str(variant)
16078 }
16079}
16080impl<'de> serde::Deserialize<'de> for SubscribeType {
16081 #[allow(deprecated)]
16082 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16083 where
16084 D: serde::Deserializer<'de>,
16085 {
16086 const FIELDS: &[&str] = &[
16087 "UNSPECIFIED",
16088 "FRONTEND",
16089 "HUMMOCK",
16090 "COMPACTOR",
16091 "COMPUTE",
16092 ];
16093
16094 struct GeneratedVisitor;
16095
16096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16097 type Value = SubscribeType;
16098
16099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16100 write!(formatter, "expected one of: {:?}", &FIELDS)
16101 }
16102
16103 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16104 where
16105 E: serde::de::Error,
16106 {
16107 i32::try_from(v)
16108 .ok()
16109 .and_then(|x| x.try_into().ok())
16110 .ok_or_else(|| {
16111 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16112 })
16113 }
16114
16115 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16116 where
16117 E: serde::de::Error,
16118 {
16119 i32::try_from(v)
16120 .ok()
16121 .and_then(|x| x.try_into().ok())
16122 .ok_or_else(|| {
16123 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16124 })
16125 }
16126
16127 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16128 where
16129 E: serde::de::Error,
16130 {
16131 match value {
16132 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
16133 "FRONTEND" => Ok(SubscribeType::Frontend),
16134 "HUMMOCK" => Ok(SubscribeType::Hummock),
16135 "COMPACTOR" => Ok(SubscribeType::Compactor),
16136 "COMPUTE" => Ok(SubscribeType::Compute),
16137 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16138 }
16139 }
16140 }
16141 deserializer.deserialize_any(GeneratedVisitor)
16142 }
16143}
16144impl serde::Serialize for SystemParams {
16145 #[allow(deprecated)]
16146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16147 where
16148 S: serde::Serializer,
16149 {
16150 use serde::ser::SerializeStruct;
16151 let mut len = 0;
16152 if self.barrier_interval_ms.is_some() {
16153 len += 1;
16154 }
16155 if self.checkpoint_frequency.is_some() {
16156 len += 1;
16157 }
16158 if self.sstable_size_mb.is_some() {
16159 len += 1;
16160 }
16161 if self.block_size_kb.is_some() {
16162 len += 1;
16163 }
16164 if self.bloom_false_positive.is_some() {
16165 len += 1;
16166 }
16167 if self.state_store.is_some() {
16168 len += 1;
16169 }
16170 if self.data_directory.is_some() {
16171 len += 1;
16172 }
16173 if self.backup_storage_url.is_some() {
16174 len += 1;
16175 }
16176 if self.backup_storage_directory.is_some() {
16177 len += 1;
16178 }
16179 if self.telemetry_enabled.is_some() {
16180 len += 1;
16181 }
16182 if self.parallel_compact_size_mb.is_some() {
16183 len += 1;
16184 }
16185 if self.max_concurrent_creating_streaming_jobs.is_some() {
16186 len += 1;
16187 }
16188 if self.pause_on_next_bootstrap.is_some() {
16189 len += 1;
16190 }
16191 if self.wasm_storage_url.is_some() {
16192 len += 1;
16193 }
16194 if self.enable_tracing.is_some() {
16195 len += 1;
16196 }
16197 if self.use_new_object_prefix_strategy.is_some() {
16198 len += 1;
16199 }
16200 if self.license_key.is_some() {
16201 len += 1;
16202 }
16203 if self.time_travel_retention_ms.is_some() {
16204 len += 1;
16205 }
16206 if self.adaptive_parallelism_strategy.is_some() {
16207 len += 1;
16208 }
16209 if self.per_database_isolation.is_some() {
16210 len += 1;
16211 }
16212 if self.enforce_secret.is_some() {
16213 len += 1;
16214 }
16215 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
16216 if let Some(v) = self.barrier_interval_ms.as_ref() {
16217 struct_ser.serialize_field("barrierIntervalMs", v)?;
16218 }
16219 if let Some(v) = self.checkpoint_frequency.as_ref() {
16220 #[allow(clippy::needless_borrow)]
16221 #[allow(clippy::needless_borrows_for_generic_args)]
16222 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
16223 }
16224 if let Some(v) = self.sstable_size_mb.as_ref() {
16225 struct_ser.serialize_field("sstableSizeMb", v)?;
16226 }
16227 if let Some(v) = self.block_size_kb.as_ref() {
16228 struct_ser.serialize_field("blockSizeKb", v)?;
16229 }
16230 if let Some(v) = self.bloom_false_positive.as_ref() {
16231 struct_ser.serialize_field("bloomFalsePositive", v)?;
16232 }
16233 if let Some(v) = self.state_store.as_ref() {
16234 struct_ser.serialize_field("stateStore", v)?;
16235 }
16236 if let Some(v) = self.data_directory.as_ref() {
16237 struct_ser.serialize_field("dataDirectory", v)?;
16238 }
16239 if let Some(v) = self.backup_storage_url.as_ref() {
16240 struct_ser.serialize_field("backupStorageUrl", v)?;
16241 }
16242 if let Some(v) = self.backup_storage_directory.as_ref() {
16243 struct_ser.serialize_field("backupStorageDirectory", v)?;
16244 }
16245 if let Some(v) = self.telemetry_enabled.as_ref() {
16246 struct_ser.serialize_field("telemetryEnabled", v)?;
16247 }
16248 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
16249 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
16250 }
16251 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
16252 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
16253 }
16254 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
16255 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
16256 }
16257 if let Some(v) = self.wasm_storage_url.as_ref() {
16258 struct_ser.serialize_field("wasmStorageUrl", v)?;
16259 }
16260 if let Some(v) = self.enable_tracing.as_ref() {
16261 struct_ser.serialize_field("enableTracing", v)?;
16262 }
16263 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
16264 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
16265 }
16266 if let Some(v) = self.license_key.as_ref() {
16267 struct_ser.serialize_field("licenseKey", v)?;
16268 }
16269 if let Some(v) = self.time_travel_retention_ms.as_ref() {
16270 #[allow(clippy::needless_borrow)]
16271 #[allow(clippy::needless_borrows_for_generic_args)]
16272 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
16273 }
16274 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
16275 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
16276 }
16277 if let Some(v) = self.per_database_isolation.as_ref() {
16278 struct_ser.serialize_field("perDatabaseIsolation", v)?;
16279 }
16280 if let Some(v) = self.enforce_secret.as_ref() {
16281 struct_ser.serialize_field("enforceSecret", v)?;
16282 }
16283 struct_ser.end()
16284 }
16285}
16286impl<'de> serde::Deserialize<'de> for SystemParams {
16287 #[allow(deprecated)]
16288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16289 where
16290 D: serde::Deserializer<'de>,
16291 {
16292 const FIELDS: &[&str] = &[
16293 "barrier_interval_ms",
16294 "barrierIntervalMs",
16295 "checkpoint_frequency",
16296 "checkpointFrequency",
16297 "sstable_size_mb",
16298 "sstableSizeMb",
16299 "block_size_kb",
16300 "blockSizeKb",
16301 "bloom_false_positive",
16302 "bloomFalsePositive",
16303 "state_store",
16304 "stateStore",
16305 "data_directory",
16306 "dataDirectory",
16307 "backup_storage_url",
16308 "backupStorageUrl",
16309 "backup_storage_directory",
16310 "backupStorageDirectory",
16311 "telemetry_enabled",
16312 "telemetryEnabled",
16313 "parallel_compact_size_mb",
16314 "parallelCompactSizeMb",
16315 "max_concurrent_creating_streaming_jobs",
16316 "maxConcurrentCreatingStreamingJobs",
16317 "pause_on_next_bootstrap",
16318 "pauseOnNextBootstrap",
16319 "wasm_storage_url",
16320 "wasmStorageUrl",
16321 "enable_tracing",
16322 "enableTracing",
16323 "use_new_object_prefix_strategy",
16324 "useNewObjectPrefixStrategy",
16325 "license_key",
16326 "licenseKey",
16327 "time_travel_retention_ms",
16328 "timeTravelRetentionMs",
16329 "adaptive_parallelism_strategy",
16330 "adaptiveParallelismStrategy",
16331 "per_database_isolation",
16332 "perDatabaseIsolation",
16333 "enforce_secret",
16334 "enforceSecret",
16335 ];
16336
16337 #[allow(clippy::enum_variant_names)]
16338 enum GeneratedField {
16339 BarrierIntervalMs,
16340 CheckpointFrequency,
16341 SstableSizeMb,
16342 BlockSizeKb,
16343 BloomFalsePositive,
16344 StateStore,
16345 DataDirectory,
16346 BackupStorageUrl,
16347 BackupStorageDirectory,
16348 TelemetryEnabled,
16349 ParallelCompactSizeMb,
16350 MaxConcurrentCreatingStreamingJobs,
16351 PauseOnNextBootstrap,
16352 WasmStorageUrl,
16353 EnableTracing,
16354 UseNewObjectPrefixStrategy,
16355 LicenseKey,
16356 TimeTravelRetentionMs,
16357 AdaptiveParallelismStrategy,
16358 PerDatabaseIsolation,
16359 EnforceSecret,
16360 }
16361 impl<'de> serde::Deserialize<'de> for GeneratedField {
16362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16363 where
16364 D: serde::Deserializer<'de>,
16365 {
16366 struct GeneratedVisitor;
16367
16368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16369 type Value = GeneratedField;
16370
16371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16372 write!(formatter, "expected one of: {:?}", &FIELDS)
16373 }
16374
16375 #[allow(unused_variables)]
16376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16377 where
16378 E: serde::de::Error,
16379 {
16380 match value {
16381 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
16382 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
16383 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
16384 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
16385 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
16386 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
16387 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
16388 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
16389 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
16390 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
16391 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
16392 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
16393 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
16394 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
16395 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
16396 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
16397 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
16398 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
16399 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
16400 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
16401 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
16402 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16403 }
16404 }
16405 }
16406 deserializer.deserialize_identifier(GeneratedVisitor)
16407 }
16408 }
16409 struct GeneratedVisitor;
16410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16411 type Value = SystemParams;
16412
16413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16414 formatter.write_str("struct meta.SystemParams")
16415 }
16416
16417 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
16418 where
16419 V: serde::de::MapAccess<'de>,
16420 {
16421 let mut barrier_interval_ms__ = None;
16422 let mut checkpoint_frequency__ = None;
16423 let mut sstable_size_mb__ = None;
16424 let mut block_size_kb__ = None;
16425 let mut bloom_false_positive__ = None;
16426 let mut state_store__ = None;
16427 let mut data_directory__ = None;
16428 let mut backup_storage_url__ = None;
16429 let mut backup_storage_directory__ = None;
16430 let mut telemetry_enabled__ = None;
16431 let mut parallel_compact_size_mb__ = None;
16432 let mut max_concurrent_creating_streaming_jobs__ = None;
16433 let mut pause_on_next_bootstrap__ = None;
16434 let mut wasm_storage_url__ = None;
16435 let mut enable_tracing__ = None;
16436 let mut use_new_object_prefix_strategy__ = None;
16437 let mut license_key__ = None;
16438 let mut time_travel_retention_ms__ = None;
16439 let mut adaptive_parallelism_strategy__ = None;
16440 let mut per_database_isolation__ = None;
16441 let mut enforce_secret__ = None;
16442 while let Some(k) = map_.next_key()? {
16443 match k {
16444 GeneratedField::BarrierIntervalMs => {
16445 if barrier_interval_ms__.is_some() {
16446 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
16447 }
16448 barrier_interval_ms__ =
16449 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16450 ;
16451 }
16452 GeneratedField::CheckpointFrequency => {
16453 if checkpoint_frequency__.is_some() {
16454 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
16455 }
16456 checkpoint_frequency__ =
16457 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16458 ;
16459 }
16460 GeneratedField::SstableSizeMb => {
16461 if sstable_size_mb__.is_some() {
16462 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
16463 }
16464 sstable_size_mb__ =
16465 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16466 ;
16467 }
16468 GeneratedField::BlockSizeKb => {
16469 if block_size_kb__.is_some() {
16470 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
16471 }
16472 block_size_kb__ =
16473 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16474 ;
16475 }
16476 GeneratedField::BloomFalsePositive => {
16477 if bloom_false_positive__.is_some() {
16478 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
16479 }
16480 bloom_false_positive__ =
16481 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16482 ;
16483 }
16484 GeneratedField::StateStore => {
16485 if state_store__.is_some() {
16486 return Err(serde::de::Error::duplicate_field("stateStore"));
16487 }
16488 state_store__ = map_.next_value()?;
16489 }
16490 GeneratedField::DataDirectory => {
16491 if data_directory__.is_some() {
16492 return Err(serde::de::Error::duplicate_field("dataDirectory"));
16493 }
16494 data_directory__ = map_.next_value()?;
16495 }
16496 GeneratedField::BackupStorageUrl => {
16497 if backup_storage_url__.is_some() {
16498 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
16499 }
16500 backup_storage_url__ = map_.next_value()?;
16501 }
16502 GeneratedField::BackupStorageDirectory => {
16503 if backup_storage_directory__.is_some() {
16504 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
16505 }
16506 backup_storage_directory__ = map_.next_value()?;
16507 }
16508 GeneratedField::TelemetryEnabled => {
16509 if telemetry_enabled__.is_some() {
16510 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
16511 }
16512 telemetry_enabled__ = map_.next_value()?;
16513 }
16514 GeneratedField::ParallelCompactSizeMb => {
16515 if parallel_compact_size_mb__.is_some() {
16516 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
16517 }
16518 parallel_compact_size_mb__ =
16519 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16520 ;
16521 }
16522 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
16523 if max_concurrent_creating_streaming_jobs__.is_some() {
16524 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
16525 }
16526 max_concurrent_creating_streaming_jobs__ =
16527 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16528 ;
16529 }
16530 GeneratedField::PauseOnNextBootstrap => {
16531 if pause_on_next_bootstrap__.is_some() {
16532 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
16533 }
16534 pause_on_next_bootstrap__ = map_.next_value()?;
16535 }
16536 GeneratedField::WasmStorageUrl => {
16537 if wasm_storage_url__.is_some() {
16538 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
16539 }
16540 wasm_storage_url__ = map_.next_value()?;
16541 }
16542 GeneratedField::EnableTracing => {
16543 if enable_tracing__.is_some() {
16544 return Err(serde::de::Error::duplicate_field("enableTracing"));
16545 }
16546 enable_tracing__ = map_.next_value()?;
16547 }
16548 GeneratedField::UseNewObjectPrefixStrategy => {
16549 if use_new_object_prefix_strategy__.is_some() {
16550 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
16551 }
16552 use_new_object_prefix_strategy__ = map_.next_value()?;
16553 }
16554 GeneratedField::LicenseKey => {
16555 if license_key__.is_some() {
16556 return Err(serde::de::Error::duplicate_field("licenseKey"));
16557 }
16558 license_key__ = map_.next_value()?;
16559 }
16560 GeneratedField::TimeTravelRetentionMs => {
16561 if time_travel_retention_ms__.is_some() {
16562 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
16563 }
16564 time_travel_retention_ms__ =
16565 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16566 ;
16567 }
16568 GeneratedField::AdaptiveParallelismStrategy => {
16569 if adaptive_parallelism_strategy__.is_some() {
16570 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
16571 }
16572 adaptive_parallelism_strategy__ = map_.next_value()?;
16573 }
16574 GeneratedField::PerDatabaseIsolation => {
16575 if per_database_isolation__.is_some() {
16576 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
16577 }
16578 per_database_isolation__ = map_.next_value()?;
16579 }
16580 GeneratedField::EnforceSecret => {
16581 if enforce_secret__.is_some() {
16582 return Err(serde::de::Error::duplicate_field("enforceSecret"));
16583 }
16584 enforce_secret__ = map_.next_value()?;
16585 }
16586 }
16587 }
16588 Ok(SystemParams {
16589 barrier_interval_ms: barrier_interval_ms__,
16590 checkpoint_frequency: checkpoint_frequency__,
16591 sstable_size_mb: sstable_size_mb__,
16592 block_size_kb: block_size_kb__,
16593 bloom_false_positive: bloom_false_positive__,
16594 state_store: state_store__,
16595 data_directory: data_directory__,
16596 backup_storage_url: backup_storage_url__,
16597 backup_storage_directory: backup_storage_directory__,
16598 telemetry_enabled: telemetry_enabled__,
16599 parallel_compact_size_mb: parallel_compact_size_mb__,
16600 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
16601 pause_on_next_bootstrap: pause_on_next_bootstrap__,
16602 wasm_storage_url: wasm_storage_url__,
16603 enable_tracing: enable_tracing__,
16604 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
16605 license_key: license_key__,
16606 time_travel_retention_ms: time_travel_retention_ms__,
16607 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
16608 per_database_isolation: per_database_isolation__,
16609 enforce_secret: enforce_secret__,
16610 })
16611 }
16612 }
16613 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
16614 }
16615}
16616impl serde::Serialize for TableFragments {
16617 #[allow(deprecated)]
16618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16619 where
16620 S: serde::Serializer,
16621 {
16622 use serde::ser::SerializeStruct;
16623 let mut len = 0;
16624 if self.table_id != 0 {
16625 len += 1;
16626 }
16627 if self.state != 0 {
16628 len += 1;
16629 }
16630 if !self.fragments.is_empty() {
16631 len += 1;
16632 }
16633 if !self.actor_status.is_empty() {
16634 len += 1;
16635 }
16636 if self.ctx.is_some() {
16637 len += 1;
16638 }
16639 if self.parallelism.is_some() {
16640 len += 1;
16641 }
16642 if self.max_parallelism.is_some() {
16643 len += 1;
16644 }
16645 if !self.node_label.is_empty() {
16646 len += 1;
16647 }
16648 if self.backfill_done {
16649 len += 1;
16650 }
16651 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
16652 if self.table_id != 0 {
16653 struct_ser.serialize_field("tableId", &self.table_id)?;
16654 }
16655 if self.state != 0 {
16656 let v = table_fragments::State::try_from(self.state)
16657 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
16658 struct_ser.serialize_field("state", &v)?;
16659 }
16660 if !self.fragments.is_empty() {
16661 struct_ser.serialize_field("fragments", &self.fragments)?;
16662 }
16663 if !self.actor_status.is_empty() {
16664 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
16665 }
16666 if let Some(v) = self.ctx.as_ref() {
16667 struct_ser.serialize_field("ctx", v)?;
16668 }
16669 if let Some(v) = self.parallelism.as_ref() {
16670 struct_ser.serialize_field("parallelism", v)?;
16671 }
16672 if let Some(v) = self.max_parallelism.as_ref() {
16673 struct_ser.serialize_field("maxParallelism", v)?;
16674 }
16675 if !self.node_label.is_empty() {
16676 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16677 }
16678 if self.backfill_done {
16679 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
16680 }
16681 struct_ser.end()
16682 }
16683}
16684impl<'de> serde::Deserialize<'de> for TableFragments {
16685 #[allow(deprecated)]
16686 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16687 where
16688 D: serde::Deserializer<'de>,
16689 {
16690 const FIELDS: &[&str] = &[
16691 "table_id",
16692 "tableId",
16693 "state",
16694 "fragments",
16695 "actor_status",
16696 "actorStatus",
16697 "ctx",
16698 "parallelism",
16699 "max_parallelism",
16700 "maxParallelism",
16701 "node_label",
16702 "nodeLabel",
16703 "backfill_done",
16704 "backfillDone",
16705 ];
16706
16707 #[allow(clippy::enum_variant_names)]
16708 enum GeneratedField {
16709 TableId,
16710 State,
16711 Fragments,
16712 ActorStatus,
16713 Ctx,
16714 Parallelism,
16715 MaxParallelism,
16716 NodeLabel,
16717 BackfillDone,
16718 }
16719 impl<'de> serde::Deserialize<'de> for GeneratedField {
16720 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16721 where
16722 D: serde::Deserializer<'de>,
16723 {
16724 struct GeneratedVisitor;
16725
16726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16727 type Value = GeneratedField;
16728
16729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16730 write!(formatter, "expected one of: {:?}", &FIELDS)
16731 }
16732
16733 #[allow(unused_variables)]
16734 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16735 where
16736 E: serde::de::Error,
16737 {
16738 match value {
16739 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16740 "state" => Ok(GeneratedField::State),
16741 "fragments" => Ok(GeneratedField::Fragments),
16742 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
16743 "ctx" => Ok(GeneratedField::Ctx),
16744 "parallelism" => Ok(GeneratedField::Parallelism),
16745 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
16746 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16747 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
16748 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16749 }
16750 }
16751 }
16752 deserializer.deserialize_identifier(GeneratedVisitor)
16753 }
16754 }
16755 struct GeneratedVisitor;
16756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16757 type Value = TableFragments;
16758
16759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16760 formatter.write_str("struct meta.TableFragments")
16761 }
16762
16763 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
16764 where
16765 V: serde::de::MapAccess<'de>,
16766 {
16767 let mut table_id__ = None;
16768 let mut state__ = None;
16769 let mut fragments__ = None;
16770 let mut actor_status__ = None;
16771 let mut ctx__ = None;
16772 let mut parallelism__ = None;
16773 let mut max_parallelism__ = None;
16774 let mut node_label__ = None;
16775 let mut backfill_done__ = None;
16776 while let Some(k) = map_.next_key()? {
16777 match k {
16778 GeneratedField::TableId => {
16779 if table_id__.is_some() {
16780 return Err(serde::de::Error::duplicate_field("tableId"));
16781 }
16782 table_id__ =
16783 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16784 ;
16785 }
16786 GeneratedField::State => {
16787 if state__.is_some() {
16788 return Err(serde::de::Error::duplicate_field("state"));
16789 }
16790 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
16791 }
16792 GeneratedField::Fragments => {
16793 if fragments__.is_some() {
16794 return Err(serde::de::Error::duplicate_field("fragments"));
16795 }
16796 fragments__ = Some(
16797 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16798 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16799 );
16800 }
16801 GeneratedField::ActorStatus => {
16802 if actor_status__.is_some() {
16803 return Err(serde::de::Error::duplicate_field("actorStatus"));
16804 }
16805 actor_status__ = Some(
16806 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16807 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16808 );
16809 }
16810 GeneratedField::Ctx => {
16811 if ctx__.is_some() {
16812 return Err(serde::de::Error::duplicate_field("ctx"));
16813 }
16814 ctx__ = map_.next_value()?;
16815 }
16816 GeneratedField::Parallelism => {
16817 if parallelism__.is_some() {
16818 return Err(serde::de::Error::duplicate_field("parallelism"));
16819 }
16820 parallelism__ = map_.next_value()?;
16821 }
16822 GeneratedField::MaxParallelism => {
16823 if max_parallelism__.is_some() {
16824 return Err(serde::de::Error::duplicate_field("maxParallelism"));
16825 }
16826 max_parallelism__ =
16827 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16828 ;
16829 }
16830 GeneratedField::NodeLabel => {
16831 if node_label__.is_some() {
16832 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16833 }
16834 node_label__ = Some(map_.next_value()?);
16835 }
16836 GeneratedField::BackfillDone => {
16837 if backfill_done__.is_some() {
16838 return Err(serde::de::Error::duplicate_field("backfillDone"));
16839 }
16840 backfill_done__ = Some(map_.next_value()?);
16841 }
16842 }
16843 }
16844 Ok(TableFragments {
16845 table_id: table_id__.unwrap_or_default(),
16846 state: state__.unwrap_or_default(),
16847 fragments: fragments__.unwrap_or_default(),
16848 actor_status: actor_status__.unwrap_or_default(),
16849 ctx: ctx__,
16850 parallelism: parallelism__,
16851 max_parallelism: max_parallelism__,
16852 node_label: node_label__.unwrap_or_default(),
16853 backfill_done: backfill_done__.unwrap_or_default(),
16854 })
16855 }
16856 }
16857 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
16858 }
16859}
16860impl serde::Serialize for table_fragments::ActorStatus {
16861 #[allow(deprecated)]
16862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16863 where
16864 S: serde::Serializer,
16865 {
16866 use serde::ser::SerializeStruct;
16867 let mut len = 0;
16868 if self.location.is_some() {
16869 len += 1;
16870 }
16871 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
16872 if let Some(v) = self.location.as_ref() {
16873 struct_ser.serialize_field("location", v)?;
16874 }
16875 struct_ser.end()
16876 }
16877}
16878impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
16879 #[allow(deprecated)]
16880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16881 where
16882 D: serde::Deserializer<'de>,
16883 {
16884 const FIELDS: &[&str] = &[
16885 "location",
16886 ];
16887
16888 #[allow(clippy::enum_variant_names)]
16889 enum GeneratedField {
16890 Location,
16891 }
16892 impl<'de> serde::Deserialize<'de> for GeneratedField {
16893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16894 where
16895 D: serde::Deserializer<'de>,
16896 {
16897 struct GeneratedVisitor;
16898
16899 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16900 type Value = GeneratedField;
16901
16902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16903 write!(formatter, "expected one of: {:?}", &FIELDS)
16904 }
16905
16906 #[allow(unused_variables)]
16907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16908 where
16909 E: serde::de::Error,
16910 {
16911 match value {
16912 "location" => Ok(GeneratedField::Location),
16913 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16914 }
16915 }
16916 }
16917 deserializer.deserialize_identifier(GeneratedVisitor)
16918 }
16919 }
16920 struct GeneratedVisitor;
16921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16922 type Value = table_fragments::ActorStatus;
16923
16924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16925 formatter.write_str("struct meta.TableFragments.ActorStatus")
16926 }
16927
16928 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
16929 where
16930 V: serde::de::MapAccess<'de>,
16931 {
16932 let mut location__ = None;
16933 while let Some(k) = map_.next_key()? {
16934 match k {
16935 GeneratedField::Location => {
16936 if location__.is_some() {
16937 return Err(serde::de::Error::duplicate_field("location"));
16938 }
16939 location__ = map_.next_value()?;
16940 }
16941 }
16942 }
16943 Ok(table_fragments::ActorStatus {
16944 location: location__,
16945 })
16946 }
16947 }
16948 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
16949 }
16950}
16951impl serde::Serialize for table_fragments::Fragment {
16952 #[allow(deprecated)]
16953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16954 where
16955 S: serde::Serializer,
16956 {
16957 use serde::ser::SerializeStruct;
16958 let mut len = 0;
16959 if self.fragment_id != 0 {
16960 len += 1;
16961 }
16962 if self.fragment_type_mask != 0 {
16963 len += 1;
16964 }
16965 if self.distribution_type != 0 {
16966 len += 1;
16967 }
16968 if !self.actors.is_empty() {
16969 len += 1;
16970 }
16971 if !self.state_table_ids.is_empty() {
16972 len += 1;
16973 }
16974 if !self.upstream_fragment_ids.is_empty() {
16975 len += 1;
16976 }
16977 if self.maybe_vnode_count.is_some() {
16978 len += 1;
16979 }
16980 if self.nodes.is_some() {
16981 len += 1;
16982 }
16983 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
16984 if self.fragment_id != 0 {
16985 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
16986 }
16987 if self.fragment_type_mask != 0 {
16988 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
16989 }
16990 if self.distribution_type != 0 {
16991 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
16992 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
16993 struct_ser.serialize_field("distributionType", &v)?;
16994 }
16995 if !self.actors.is_empty() {
16996 struct_ser.serialize_field("actors", &self.actors)?;
16997 }
16998 if !self.state_table_ids.is_empty() {
16999 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
17000 }
17001 if !self.upstream_fragment_ids.is_empty() {
17002 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
17003 }
17004 if let Some(v) = self.maybe_vnode_count.as_ref() {
17005 struct_ser.serialize_field("maybeVnodeCount", v)?;
17006 }
17007 if let Some(v) = self.nodes.as_ref() {
17008 struct_ser.serialize_field("nodes", v)?;
17009 }
17010 struct_ser.end()
17011 }
17012}
17013impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
17014 #[allow(deprecated)]
17015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17016 where
17017 D: serde::Deserializer<'de>,
17018 {
17019 const FIELDS: &[&str] = &[
17020 "fragment_id",
17021 "fragmentId",
17022 "fragment_type_mask",
17023 "fragmentTypeMask",
17024 "distribution_type",
17025 "distributionType",
17026 "actors",
17027 "state_table_ids",
17028 "stateTableIds",
17029 "upstream_fragment_ids",
17030 "upstreamFragmentIds",
17031 "maybe_vnode_count",
17032 "maybeVnodeCount",
17033 "nodes",
17034 ];
17035
17036 #[allow(clippy::enum_variant_names)]
17037 enum GeneratedField {
17038 FragmentId,
17039 FragmentTypeMask,
17040 DistributionType,
17041 Actors,
17042 StateTableIds,
17043 UpstreamFragmentIds,
17044 MaybeVnodeCount,
17045 Nodes,
17046 }
17047 impl<'de> serde::Deserialize<'de> for GeneratedField {
17048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17049 where
17050 D: serde::Deserializer<'de>,
17051 {
17052 struct GeneratedVisitor;
17053
17054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17055 type Value = GeneratedField;
17056
17057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17058 write!(formatter, "expected one of: {:?}", &FIELDS)
17059 }
17060
17061 #[allow(unused_variables)]
17062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17063 where
17064 E: serde::de::Error,
17065 {
17066 match value {
17067 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
17068 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
17069 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
17070 "actors" => Ok(GeneratedField::Actors),
17071 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
17072 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
17073 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
17074 "nodes" => Ok(GeneratedField::Nodes),
17075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17076 }
17077 }
17078 }
17079 deserializer.deserialize_identifier(GeneratedVisitor)
17080 }
17081 }
17082 struct GeneratedVisitor;
17083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17084 type Value = table_fragments::Fragment;
17085
17086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17087 formatter.write_str("struct meta.TableFragments.Fragment")
17088 }
17089
17090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
17091 where
17092 V: serde::de::MapAccess<'de>,
17093 {
17094 let mut fragment_id__ = None;
17095 let mut fragment_type_mask__ = None;
17096 let mut distribution_type__ = None;
17097 let mut actors__ = None;
17098 let mut state_table_ids__ = None;
17099 let mut upstream_fragment_ids__ = None;
17100 let mut maybe_vnode_count__ = None;
17101 let mut nodes__ = None;
17102 while let Some(k) = map_.next_key()? {
17103 match k {
17104 GeneratedField::FragmentId => {
17105 if fragment_id__.is_some() {
17106 return Err(serde::de::Error::duplicate_field("fragmentId"));
17107 }
17108 fragment_id__ =
17109 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17110 ;
17111 }
17112 GeneratedField::FragmentTypeMask => {
17113 if fragment_type_mask__.is_some() {
17114 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
17115 }
17116 fragment_type_mask__ =
17117 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17118 ;
17119 }
17120 GeneratedField::DistributionType => {
17121 if distribution_type__.is_some() {
17122 return Err(serde::de::Error::duplicate_field("distributionType"));
17123 }
17124 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
17125 }
17126 GeneratedField::Actors => {
17127 if actors__.is_some() {
17128 return Err(serde::de::Error::duplicate_field("actors"));
17129 }
17130 actors__ = Some(map_.next_value()?);
17131 }
17132 GeneratedField::StateTableIds => {
17133 if state_table_ids__.is_some() {
17134 return Err(serde::de::Error::duplicate_field("stateTableIds"));
17135 }
17136 state_table_ids__ =
17137 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17138 .into_iter().map(|x| x.0).collect())
17139 ;
17140 }
17141 GeneratedField::UpstreamFragmentIds => {
17142 if upstream_fragment_ids__.is_some() {
17143 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
17144 }
17145 upstream_fragment_ids__ =
17146 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17147 .into_iter().map(|x| x.0).collect())
17148 ;
17149 }
17150 GeneratedField::MaybeVnodeCount => {
17151 if maybe_vnode_count__.is_some() {
17152 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
17153 }
17154 maybe_vnode_count__ =
17155 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17156 ;
17157 }
17158 GeneratedField::Nodes => {
17159 if nodes__.is_some() {
17160 return Err(serde::de::Error::duplicate_field("nodes"));
17161 }
17162 nodes__ = map_.next_value()?;
17163 }
17164 }
17165 }
17166 Ok(table_fragments::Fragment {
17167 fragment_id: fragment_id__.unwrap_or_default(),
17168 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
17169 distribution_type: distribution_type__.unwrap_or_default(),
17170 actors: actors__.unwrap_or_default(),
17171 state_table_ids: state_table_ids__.unwrap_or_default(),
17172 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
17173 maybe_vnode_count: maybe_vnode_count__,
17174 nodes: nodes__,
17175 })
17176 }
17177 }
17178 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
17179 }
17180}
17181impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
17182 #[allow(deprecated)]
17183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17184 where
17185 S: serde::Serializer,
17186 {
17187 let variant = match self {
17188 Self::Unspecified => "UNSPECIFIED",
17189 Self::Single => "SINGLE",
17190 Self::Hash => "HASH",
17191 };
17192 serializer.serialize_str(variant)
17193 }
17194}
17195impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
17196 #[allow(deprecated)]
17197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17198 where
17199 D: serde::Deserializer<'de>,
17200 {
17201 const FIELDS: &[&str] = &[
17202 "UNSPECIFIED",
17203 "SINGLE",
17204 "HASH",
17205 ];
17206
17207 struct GeneratedVisitor;
17208
17209 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17210 type Value = table_fragments::fragment::FragmentDistributionType;
17211
17212 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17213 write!(formatter, "expected one of: {:?}", &FIELDS)
17214 }
17215
17216 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17217 where
17218 E: serde::de::Error,
17219 {
17220 i32::try_from(v)
17221 .ok()
17222 .and_then(|x| x.try_into().ok())
17223 .ok_or_else(|| {
17224 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17225 })
17226 }
17227
17228 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17229 where
17230 E: serde::de::Error,
17231 {
17232 i32::try_from(v)
17233 .ok()
17234 .and_then(|x| x.try_into().ok())
17235 .ok_or_else(|| {
17236 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17237 })
17238 }
17239
17240 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17241 where
17242 E: serde::de::Error,
17243 {
17244 match value {
17245 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
17246 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
17247 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
17248 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17249 }
17250 }
17251 }
17252 deserializer.deserialize_any(GeneratedVisitor)
17253 }
17254}
17255impl serde::Serialize for table_fragments::State {
17256 #[allow(deprecated)]
17257 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17258 where
17259 S: serde::Serializer,
17260 {
17261 let variant = match self {
17262 Self::Unspecified => "UNSPECIFIED",
17263 Self::Initial => "INITIAL",
17264 Self::Creating => "CREATING",
17265 Self::Created => "CREATED",
17266 };
17267 serializer.serialize_str(variant)
17268 }
17269}
17270impl<'de> serde::Deserialize<'de> for table_fragments::State {
17271 #[allow(deprecated)]
17272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17273 where
17274 D: serde::Deserializer<'de>,
17275 {
17276 const FIELDS: &[&str] = &[
17277 "UNSPECIFIED",
17278 "INITIAL",
17279 "CREATING",
17280 "CREATED",
17281 ];
17282
17283 struct GeneratedVisitor;
17284
17285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17286 type Value = table_fragments::State;
17287
17288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17289 write!(formatter, "expected one of: {:?}", &FIELDS)
17290 }
17291
17292 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17293 where
17294 E: serde::de::Error,
17295 {
17296 i32::try_from(v)
17297 .ok()
17298 .and_then(|x| x.try_into().ok())
17299 .ok_or_else(|| {
17300 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17301 })
17302 }
17303
17304 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17305 where
17306 E: serde::de::Error,
17307 {
17308 i32::try_from(v)
17309 .ok()
17310 .and_then(|x| x.try_into().ok())
17311 .ok_or_else(|| {
17312 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17313 })
17314 }
17315
17316 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17317 where
17318 E: serde::de::Error,
17319 {
17320 match value {
17321 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
17322 "INITIAL" => Ok(table_fragments::State::Initial),
17323 "CREATING" => Ok(table_fragments::State::Creating),
17324 "CREATED" => Ok(table_fragments::State::Created),
17325 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17326 }
17327 }
17328 }
17329 deserializer.deserialize_any(GeneratedVisitor)
17330 }
17331}
17332impl serde::Serialize for TableParallelism {
17333 #[allow(deprecated)]
17334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17335 where
17336 S: serde::Serializer,
17337 {
17338 use serde::ser::SerializeStruct;
17339 let mut len = 0;
17340 if self.parallelism.is_some() {
17341 len += 1;
17342 }
17343 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
17344 if let Some(v) = self.parallelism.as_ref() {
17345 match v {
17346 table_parallelism::Parallelism::Fixed(v) => {
17347 struct_ser.serialize_field("fixed", v)?;
17348 }
17349 table_parallelism::Parallelism::Auto(v) => {
17350 struct_ser.serialize_field("auto", v)?;
17351 }
17352 table_parallelism::Parallelism::Custom(v) => {
17353 struct_ser.serialize_field("custom", v)?;
17354 }
17355 table_parallelism::Parallelism::Adaptive(v) => {
17356 struct_ser.serialize_field("adaptive", v)?;
17357 }
17358 }
17359 }
17360 struct_ser.end()
17361 }
17362}
17363impl<'de> serde::Deserialize<'de> for TableParallelism {
17364 #[allow(deprecated)]
17365 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17366 where
17367 D: serde::Deserializer<'de>,
17368 {
17369 const FIELDS: &[&str] = &[
17370 "fixed",
17371 "auto",
17372 "custom",
17373 "adaptive",
17374 ];
17375
17376 #[allow(clippy::enum_variant_names)]
17377 enum GeneratedField {
17378 Fixed,
17379 Auto,
17380 Custom,
17381 Adaptive,
17382 }
17383 impl<'de> serde::Deserialize<'de> for GeneratedField {
17384 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17385 where
17386 D: serde::Deserializer<'de>,
17387 {
17388 struct GeneratedVisitor;
17389
17390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17391 type Value = GeneratedField;
17392
17393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17394 write!(formatter, "expected one of: {:?}", &FIELDS)
17395 }
17396
17397 #[allow(unused_variables)]
17398 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17399 where
17400 E: serde::de::Error,
17401 {
17402 match value {
17403 "fixed" => Ok(GeneratedField::Fixed),
17404 "auto" => Ok(GeneratedField::Auto),
17405 "custom" => Ok(GeneratedField::Custom),
17406 "adaptive" => Ok(GeneratedField::Adaptive),
17407 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17408 }
17409 }
17410 }
17411 deserializer.deserialize_identifier(GeneratedVisitor)
17412 }
17413 }
17414 struct GeneratedVisitor;
17415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17416 type Value = TableParallelism;
17417
17418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17419 formatter.write_str("struct meta.TableParallelism")
17420 }
17421
17422 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
17423 where
17424 V: serde::de::MapAccess<'de>,
17425 {
17426 let mut parallelism__ = None;
17427 while let Some(k) = map_.next_key()? {
17428 match k {
17429 GeneratedField::Fixed => {
17430 if parallelism__.is_some() {
17431 return Err(serde::de::Error::duplicate_field("fixed"));
17432 }
17433 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
17434;
17435 }
17436 GeneratedField::Auto => {
17437 if parallelism__.is_some() {
17438 return Err(serde::de::Error::duplicate_field("auto"));
17439 }
17440 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
17441;
17442 }
17443 GeneratedField::Custom => {
17444 if parallelism__.is_some() {
17445 return Err(serde::de::Error::duplicate_field("custom"));
17446 }
17447 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
17448;
17449 }
17450 GeneratedField::Adaptive => {
17451 if parallelism__.is_some() {
17452 return Err(serde::de::Error::duplicate_field("adaptive"));
17453 }
17454 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
17455;
17456 }
17457 }
17458 }
17459 Ok(TableParallelism {
17460 parallelism: parallelism__,
17461 })
17462 }
17463 }
17464 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
17465 }
17466}
17467impl serde::Serialize for table_parallelism::AdaptiveParallelism {
17468 #[allow(deprecated)]
17469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17470 where
17471 S: serde::Serializer,
17472 {
17473 use serde::ser::SerializeStruct;
17474 let len = 0;
17475 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
17476 struct_ser.end()
17477 }
17478}
17479impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
17480 #[allow(deprecated)]
17481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17482 where
17483 D: serde::Deserializer<'de>,
17484 {
17485 const FIELDS: &[&str] = &[
17486 ];
17487
17488 #[allow(clippy::enum_variant_names)]
17489 enum GeneratedField {
17490 }
17491 impl<'de> serde::Deserialize<'de> for GeneratedField {
17492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17493 where
17494 D: serde::Deserializer<'de>,
17495 {
17496 struct GeneratedVisitor;
17497
17498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17499 type Value = GeneratedField;
17500
17501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17502 write!(formatter, "expected one of: {:?}", &FIELDS)
17503 }
17504
17505 #[allow(unused_variables)]
17506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17507 where
17508 E: serde::de::Error,
17509 {
17510 Err(serde::de::Error::unknown_field(value, FIELDS))
17511 }
17512 }
17513 deserializer.deserialize_identifier(GeneratedVisitor)
17514 }
17515 }
17516 struct GeneratedVisitor;
17517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17518 type Value = table_parallelism::AdaptiveParallelism;
17519
17520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17521 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
17522 }
17523
17524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
17525 where
17526 V: serde::de::MapAccess<'de>,
17527 {
17528 while map_.next_key::<GeneratedField>()?.is_some() {
17529 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17530 }
17531 Ok(table_parallelism::AdaptiveParallelism {
17532 })
17533 }
17534 }
17535 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
17536 }
17537}
17538impl serde::Serialize for table_parallelism::AutoParallelism {
17539 #[allow(deprecated)]
17540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17541 where
17542 S: serde::Serializer,
17543 {
17544 use serde::ser::SerializeStruct;
17545 let len = 0;
17546 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
17547 struct_ser.end()
17548 }
17549}
17550impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
17551 #[allow(deprecated)]
17552 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17553 where
17554 D: serde::Deserializer<'de>,
17555 {
17556 const FIELDS: &[&str] = &[
17557 ];
17558
17559 #[allow(clippy::enum_variant_names)]
17560 enum GeneratedField {
17561 }
17562 impl<'de> serde::Deserialize<'de> for GeneratedField {
17563 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17564 where
17565 D: serde::Deserializer<'de>,
17566 {
17567 struct GeneratedVisitor;
17568
17569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17570 type Value = GeneratedField;
17571
17572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17573 write!(formatter, "expected one of: {:?}", &FIELDS)
17574 }
17575
17576 #[allow(unused_variables)]
17577 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17578 where
17579 E: serde::de::Error,
17580 {
17581 Err(serde::de::Error::unknown_field(value, FIELDS))
17582 }
17583 }
17584 deserializer.deserialize_identifier(GeneratedVisitor)
17585 }
17586 }
17587 struct GeneratedVisitor;
17588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17589 type Value = table_parallelism::AutoParallelism;
17590
17591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17592 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
17593 }
17594
17595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
17596 where
17597 V: serde::de::MapAccess<'de>,
17598 {
17599 while map_.next_key::<GeneratedField>()?.is_some() {
17600 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17601 }
17602 Ok(table_parallelism::AutoParallelism {
17603 })
17604 }
17605 }
17606 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
17607 }
17608}
17609impl serde::Serialize for table_parallelism::CustomParallelism {
17610 #[allow(deprecated)]
17611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17612 where
17613 S: serde::Serializer,
17614 {
17615 use serde::ser::SerializeStruct;
17616 let len = 0;
17617 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
17618 struct_ser.end()
17619 }
17620}
17621impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
17622 #[allow(deprecated)]
17623 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17624 where
17625 D: serde::Deserializer<'de>,
17626 {
17627 const FIELDS: &[&str] = &[
17628 ];
17629
17630 #[allow(clippy::enum_variant_names)]
17631 enum GeneratedField {
17632 }
17633 impl<'de> serde::Deserialize<'de> for GeneratedField {
17634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17635 where
17636 D: serde::Deserializer<'de>,
17637 {
17638 struct GeneratedVisitor;
17639
17640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17641 type Value = GeneratedField;
17642
17643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17644 write!(formatter, "expected one of: {:?}", &FIELDS)
17645 }
17646
17647 #[allow(unused_variables)]
17648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17649 where
17650 E: serde::de::Error,
17651 {
17652 Err(serde::de::Error::unknown_field(value, FIELDS))
17653 }
17654 }
17655 deserializer.deserialize_identifier(GeneratedVisitor)
17656 }
17657 }
17658 struct GeneratedVisitor;
17659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17660 type Value = table_parallelism::CustomParallelism;
17661
17662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17663 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
17664 }
17665
17666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
17667 where
17668 V: serde::de::MapAccess<'de>,
17669 {
17670 while map_.next_key::<GeneratedField>()?.is_some() {
17671 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17672 }
17673 Ok(table_parallelism::CustomParallelism {
17674 })
17675 }
17676 }
17677 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
17678 }
17679}
17680impl serde::Serialize for table_parallelism::FixedParallelism {
17681 #[allow(deprecated)]
17682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17683 where
17684 S: serde::Serializer,
17685 {
17686 use serde::ser::SerializeStruct;
17687 let mut len = 0;
17688 if self.parallelism != 0 {
17689 len += 1;
17690 }
17691 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
17692 if self.parallelism != 0 {
17693 struct_ser.serialize_field("parallelism", &self.parallelism)?;
17694 }
17695 struct_ser.end()
17696 }
17697}
17698impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
17699 #[allow(deprecated)]
17700 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17701 where
17702 D: serde::Deserializer<'de>,
17703 {
17704 const FIELDS: &[&str] = &[
17705 "parallelism",
17706 ];
17707
17708 #[allow(clippy::enum_variant_names)]
17709 enum GeneratedField {
17710 Parallelism,
17711 }
17712 impl<'de> serde::Deserialize<'de> for GeneratedField {
17713 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17714 where
17715 D: serde::Deserializer<'de>,
17716 {
17717 struct GeneratedVisitor;
17718
17719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17720 type Value = GeneratedField;
17721
17722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17723 write!(formatter, "expected one of: {:?}", &FIELDS)
17724 }
17725
17726 #[allow(unused_variables)]
17727 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17728 where
17729 E: serde::de::Error,
17730 {
17731 match value {
17732 "parallelism" => Ok(GeneratedField::Parallelism),
17733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17734 }
17735 }
17736 }
17737 deserializer.deserialize_identifier(GeneratedVisitor)
17738 }
17739 }
17740 struct GeneratedVisitor;
17741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17742 type Value = table_parallelism::FixedParallelism;
17743
17744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17745 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
17746 }
17747
17748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
17749 where
17750 V: serde::de::MapAccess<'de>,
17751 {
17752 let mut parallelism__ = None;
17753 while let Some(k) = map_.next_key()? {
17754 match k {
17755 GeneratedField::Parallelism => {
17756 if parallelism__.is_some() {
17757 return Err(serde::de::Error::duplicate_field("parallelism"));
17758 }
17759 parallelism__ =
17760 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17761 ;
17762 }
17763 }
17764 }
17765 Ok(table_parallelism::FixedParallelism {
17766 parallelism: parallelism__.unwrap_or_default(),
17767 })
17768 }
17769 }
17770 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
17771 }
17772}
17773impl serde::Serialize for TelemetryInfoResponse {
17774 #[allow(deprecated)]
17775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17776 where
17777 S: serde::Serializer,
17778 {
17779 use serde::ser::SerializeStruct;
17780 let mut len = 0;
17781 if self.tracking_id.is_some() {
17782 len += 1;
17783 }
17784 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
17785 if let Some(v) = self.tracking_id.as_ref() {
17786 struct_ser.serialize_field("trackingId", v)?;
17787 }
17788 struct_ser.end()
17789 }
17790}
17791impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
17792 #[allow(deprecated)]
17793 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17794 where
17795 D: serde::Deserializer<'de>,
17796 {
17797 const FIELDS: &[&str] = &[
17798 "tracking_id",
17799 "trackingId",
17800 ];
17801
17802 #[allow(clippy::enum_variant_names)]
17803 enum GeneratedField {
17804 TrackingId,
17805 }
17806 impl<'de> serde::Deserialize<'de> for GeneratedField {
17807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17808 where
17809 D: serde::Deserializer<'de>,
17810 {
17811 struct GeneratedVisitor;
17812
17813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17814 type Value = GeneratedField;
17815
17816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17817 write!(formatter, "expected one of: {:?}", &FIELDS)
17818 }
17819
17820 #[allow(unused_variables)]
17821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17822 where
17823 E: serde::de::Error,
17824 {
17825 match value {
17826 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
17827 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17828 }
17829 }
17830 }
17831 deserializer.deserialize_identifier(GeneratedVisitor)
17832 }
17833 }
17834 struct GeneratedVisitor;
17835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17836 type Value = TelemetryInfoResponse;
17837
17838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17839 formatter.write_str("struct meta.TelemetryInfoResponse")
17840 }
17841
17842 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
17843 where
17844 V: serde::de::MapAccess<'de>,
17845 {
17846 let mut tracking_id__ = None;
17847 while let Some(k) = map_.next_key()? {
17848 match k {
17849 GeneratedField::TrackingId => {
17850 if tracking_id__.is_some() {
17851 return Err(serde::de::Error::duplicate_field("trackingId"));
17852 }
17853 tracking_id__ = map_.next_value()?;
17854 }
17855 }
17856 }
17857 Ok(TelemetryInfoResponse {
17858 tracking_id: tracking_id__,
17859 })
17860 }
17861 }
17862 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
17863 }
17864}
17865impl serde::Serialize for ThrottleTarget {
17866 #[allow(deprecated)]
17867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17868 where
17869 S: serde::Serializer,
17870 {
17871 let variant = match self {
17872 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
17873 Self::Source => "SOURCE",
17874 Self::Mv => "MV",
17875 Self::TableWithSource => "TABLE_WITH_SOURCE",
17876 Self::CdcTable => "CDC_TABLE",
17877 Self::TableDml => "TABLE_DML",
17878 Self::Sink => "SINK",
17879 Self::Fragment => "FRAGMENT",
17880 };
17881 serializer.serialize_str(variant)
17882 }
17883}
17884impl<'de> serde::Deserialize<'de> for ThrottleTarget {
17885 #[allow(deprecated)]
17886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17887 where
17888 D: serde::Deserializer<'de>,
17889 {
17890 const FIELDS: &[&str] = &[
17891 "THROTTLE_TARGET_UNSPECIFIED",
17892 "SOURCE",
17893 "MV",
17894 "TABLE_WITH_SOURCE",
17895 "CDC_TABLE",
17896 "TABLE_DML",
17897 "SINK",
17898 "FRAGMENT",
17899 ];
17900
17901 struct GeneratedVisitor;
17902
17903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17904 type Value = ThrottleTarget;
17905
17906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17907 write!(formatter, "expected one of: {:?}", &FIELDS)
17908 }
17909
17910 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17911 where
17912 E: serde::de::Error,
17913 {
17914 i32::try_from(v)
17915 .ok()
17916 .and_then(|x| x.try_into().ok())
17917 .ok_or_else(|| {
17918 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17919 })
17920 }
17921
17922 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17923 where
17924 E: serde::de::Error,
17925 {
17926 i32::try_from(v)
17927 .ok()
17928 .and_then(|x| x.try_into().ok())
17929 .ok_or_else(|| {
17930 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17931 })
17932 }
17933
17934 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17935 where
17936 E: serde::de::Error,
17937 {
17938 match value {
17939 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
17940 "SOURCE" => Ok(ThrottleTarget::Source),
17941 "MV" => Ok(ThrottleTarget::Mv),
17942 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
17943 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
17944 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
17945 "SINK" => Ok(ThrottleTarget::Sink),
17946 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
17947 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17948 }
17949 }
17950 }
17951 deserializer.deserialize_any(GeneratedVisitor)
17952 }
17953}
17954impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
17955 #[allow(deprecated)]
17956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17957 where
17958 S: serde::Serializer,
17959 {
17960 use serde::ser::SerializeStruct;
17961 let mut len = 0;
17962 if self.id != 0 {
17963 len += 1;
17964 }
17965 if !self.node_label.is_empty() {
17966 len += 1;
17967 }
17968 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
17969 if self.id != 0 {
17970 struct_ser.serialize_field("id", &self.id)?;
17971 }
17972 if !self.node_label.is_empty() {
17973 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
17974 }
17975 struct_ser.end()
17976 }
17977}
17978impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
17979 #[allow(deprecated)]
17980 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17981 where
17982 D: serde::Deserializer<'de>,
17983 {
17984 const FIELDS: &[&str] = &[
17985 "id",
17986 "node_label",
17987 "nodeLabel",
17988 ];
17989
17990 #[allow(clippy::enum_variant_names)]
17991 enum GeneratedField {
17992 Id,
17993 NodeLabel,
17994 }
17995 impl<'de> serde::Deserialize<'de> for GeneratedField {
17996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17997 where
17998 D: serde::Deserializer<'de>,
17999 {
18000 struct GeneratedVisitor;
18001
18002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18003 type Value = GeneratedField;
18004
18005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18006 write!(formatter, "expected one of: {:?}", &FIELDS)
18007 }
18008
18009 #[allow(unused_variables)]
18010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18011 where
18012 E: serde::de::Error,
18013 {
18014 match value {
18015 "id" => Ok(GeneratedField::Id),
18016 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18017 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18018 }
18019 }
18020 }
18021 deserializer.deserialize_identifier(GeneratedVisitor)
18022 }
18023 }
18024 struct GeneratedVisitor;
18025 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18026 type Value = UpdateStreamingJobNodeLabelsRequest;
18027
18028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18029 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
18030 }
18031
18032 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
18033 where
18034 V: serde::de::MapAccess<'de>,
18035 {
18036 let mut id__ = None;
18037 let mut node_label__ = None;
18038 while let Some(k) = map_.next_key()? {
18039 match k {
18040 GeneratedField::Id => {
18041 if id__.is_some() {
18042 return Err(serde::de::Error::duplicate_field("id"));
18043 }
18044 id__ =
18045 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18046 ;
18047 }
18048 GeneratedField::NodeLabel => {
18049 if node_label__.is_some() {
18050 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18051 }
18052 node_label__ = Some(map_.next_value()?);
18053 }
18054 }
18055 }
18056 Ok(UpdateStreamingJobNodeLabelsRequest {
18057 id: id__.unwrap_or_default(),
18058 node_label: node_label__.unwrap_or_default(),
18059 })
18060 }
18061 }
18062 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
18063 }
18064}
18065impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
18066 #[allow(deprecated)]
18067 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18068 where
18069 S: serde::Serializer,
18070 {
18071 use serde::ser::SerializeStruct;
18072 let len = 0;
18073 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
18074 struct_ser.end()
18075 }
18076}
18077impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
18078 #[allow(deprecated)]
18079 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18080 where
18081 D: serde::Deserializer<'de>,
18082 {
18083 const FIELDS: &[&str] = &[
18084 ];
18085
18086 #[allow(clippy::enum_variant_names)]
18087 enum GeneratedField {
18088 }
18089 impl<'de> serde::Deserialize<'de> for GeneratedField {
18090 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18091 where
18092 D: serde::Deserializer<'de>,
18093 {
18094 struct GeneratedVisitor;
18095
18096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18097 type Value = GeneratedField;
18098
18099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18100 write!(formatter, "expected one of: {:?}", &FIELDS)
18101 }
18102
18103 #[allow(unused_variables)]
18104 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18105 where
18106 E: serde::de::Error,
18107 {
18108 Err(serde::de::Error::unknown_field(value, FIELDS))
18109 }
18110 }
18111 deserializer.deserialize_identifier(GeneratedVisitor)
18112 }
18113 }
18114 struct GeneratedVisitor;
18115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18116 type Value = UpdateStreamingJobNodeLabelsResponse;
18117
18118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18119 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
18120 }
18121
18122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
18123 where
18124 V: serde::de::MapAccess<'de>,
18125 {
18126 while map_.next_key::<GeneratedField>()?.is_some() {
18127 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18128 }
18129 Ok(UpdateStreamingJobNodeLabelsResponse {
18130 })
18131 }
18132 }
18133 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
18134 }
18135}
18136impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
18137 #[allow(deprecated)]
18138 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18139 where
18140 S: serde::Serializer,
18141 {
18142 use serde::ser::SerializeStruct;
18143 let mut len = 0;
18144 if !self.worker_ids.is_empty() {
18145 len += 1;
18146 }
18147 if self.schedulability != 0 {
18148 len += 1;
18149 }
18150 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
18151 if !self.worker_ids.is_empty() {
18152 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
18153 }
18154 if self.schedulability != 0 {
18155 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
18156 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
18157 struct_ser.serialize_field("schedulability", &v)?;
18158 }
18159 struct_ser.end()
18160 }
18161}
18162impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
18163 #[allow(deprecated)]
18164 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18165 where
18166 D: serde::Deserializer<'de>,
18167 {
18168 const FIELDS: &[&str] = &[
18169 "worker_ids",
18170 "workerIds",
18171 "schedulability",
18172 ];
18173
18174 #[allow(clippy::enum_variant_names)]
18175 enum GeneratedField {
18176 WorkerIds,
18177 Schedulability,
18178 }
18179 impl<'de> serde::Deserialize<'de> for GeneratedField {
18180 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18181 where
18182 D: serde::Deserializer<'de>,
18183 {
18184 struct GeneratedVisitor;
18185
18186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18187 type Value = GeneratedField;
18188
18189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18190 write!(formatter, "expected one of: {:?}", &FIELDS)
18191 }
18192
18193 #[allow(unused_variables)]
18194 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18195 where
18196 E: serde::de::Error,
18197 {
18198 match value {
18199 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
18200 "schedulability" => Ok(GeneratedField::Schedulability),
18201 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18202 }
18203 }
18204 }
18205 deserializer.deserialize_identifier(GeneratedVisitor)
18206 }
18207 }
18208 struct GeneratedVisitor;
18209 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18210 type Value = UpdateWorkerNodeSchedulabilityRequest;
18211
18212 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18213 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
18214 }
18215
18216 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
18217 where
18218 V: serde::de::MapAccess<'de>,
18219 {
18220 let mut worker_ids__ = None;
18221 let mut schedulability__ = None;
18222 while let Some(k) = map_.next_key()? {
18223 match k {
18224 GeneratedField::WorkerIds => {
18225 if worker_ids__.is_some() {
18226 return Err(serde::de::Error::duplicate_field("workerIds"));
18227 }
18228 worker_ids__ =
18229 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18230 .into_iter().map(|x| x.0).collect())
18231 ;
18232 }
18233 GeneratedField::Schedulability => {
18234 if schedulability__.is_some() {
18235 return Err(serde::de::Error::duplicate_field("schedulability"));
18236 }
18237 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
18238 }
18239 }
18240 }
18241 Ok(UpdateWorkerNodeSchedulabilityRequest {
18242 worker_ids: worker_ids__.unwrap_or_default(),
18243 schedulability: schedulability__.unwrap_or_default(),
18244 })
18245 }
18246 }
18247 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
18248 }
18249}
18250impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
18251 #[allow(deprecated)]
18252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18253 where
18254 S: serde::Serializer,
18255 {
18256 let variant = match self {
18257 Self::Unspecified => "UNSPECIFIED",
18258 Self::Schedulable => "SCHEDULABLE",
18259 Self::Unschedulable => "UNSCHEDULABLE",
18260 };
18261 serializer.serialize_str(variant)
18262 }
18263}
18264impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
18265 #[allow(deprecated)]
18266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18267 where
18268 D: serde::Deserializer<'de>,
18269 {
18270 const FIELDS: &[&str] = &[
18271 "UNSPECIFIED",
18272 "SCHEDULABLE",
18273 "UNSCHEDULABLE",
18274 ];
18275
18276 struct GeneratedVisitor;
18277
18278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18279 type Value = update_worker_node_schedulability_request::Schedulability;
18280
18281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18282 write!(formatter, "expected one of: {:?}", &FIELDS)
18283 }
18284
18285 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18286 where
18287 E: serde::de::Error,
18288 {
18289 i32::try_from(v)
18290 .ok()
18291 .and_then(|x| x.try_into().ok())
18292 .ok_or_else(|| {
18293 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18294 })
18295 }
18296
18297 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18298 where
18299 E: serde::de::Error,
18300 {
18301 i32::try_from(v)
18302 .ok()
18303 .and_then(|x| x.try_into().ok())
18304 .ok_or_else(|| {
18305 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18306 })
18307 }
18308
18309 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18310 where
18311 E: serde::de::Error,
18312 {
18313 match value {
18314 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
18315 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
18316 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
18317 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18318 }
18319 }
18320 }
18321 deserializer.deserialize_any(GeneratedVisitor)
18322 }
18323}
18324impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
18325 #[allow(deprecated)]
18326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18327 where
18328 S: serde::Serializer,
18329 {
18330 use serde::ser::SerializeStruct;
18331 let mut len = 0;
18332 if self.status.is_some() {
18333 len += 1;
18334 }
18335 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
18336 if let Some(v) = self.status.as_ref() {
18337 struct_ser.serialize_field("status", v)?;
18338 }
18339 struct_ser.end()
18340 }
18341}
18342impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
18343 #[allow(deprecated)]
18344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18345 where
18346 D: serde::Deserializer<'de>,
18347 {
18348 const FIELDS: &[&str] = &[
18349 "status",
18350 ];
18351
18352 #[allow(clippy::enum_variant_names)]
18353 enum GeneratedField {
18354 Status,
18355 }
18356 impl<'de> serde::Deserialize<'de> for GeneratedField {
18357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18358 where
18359 D: serde::Deserializer<'de>,
18360 {
18361 struct GeneratedVisitor;
18362
18363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18364 type Value = GeneratedField;
18365
18366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18367 write!(formatter, "expected one of: {:?}", &FIELDS)
18368 }
18369
18370 #[allow(unused_variables)]
18371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18372 where
18373 E: serde::de::Error,
18374 {
18375 match value {
18376 "status" => Ok(GeneratedField::Status),
18377 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18378 }
18379 }
18380 }
18381 deserializer.deserialize_identifier(GeneratedVisitor)
18382 }
18383 }
18384 struct GeneratedVisitor;
18385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18386 type Value = UpdateWorkerNodeSchedulabilityResponse;
18387
18388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18389 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
18390 }
18391
18392 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
18393 where
18394 V: serde::de::MapAccess<'de>,
18395 {
18396 let mut status__ = None;
18397 while let Some(k) = map_.next_key()? {
18398 match k {
18399 GeneratedField::Status => {
18400 if status__.is_some() {
18401 return Err(serde::de::Error::duplicate_field("status"));
18402 }
18403 status__ = map_.next_value()?;
18404 }
18405 }
18406 }
18407 Ok(UpdateWorkerNodeSchedulabilityResponse {
18408 status: status__,
18409 })
18410 }
18411 }
18412 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
18413 }
18414}
18415impl serde::Serialize for WorkerReschedule {
18416 #[allow(deprecated)]
18417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18418 where
18419 S: serde::Serializer,
18420 {
18421 use serde::ser::SerializeStruct;
18422 let mut len = 0;
18423 if !self.worker_actor_diff.is_empty() {
18424 len += 1;
18425 }
18426 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
18427 if !self.worker_actor_diff.is_empty() {
18428 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
18429 }
18430 struct_ser.end()
18431 }
18432}
18433impl<'de> serde::Deserialize<'de> for WorkerReschedule {
18434 #[allow(deprecated)]
18435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18436 where
18437 D: serde::Deserializer<'de>,
18438 {
18439 const FIELDS: &[&str] = &[
18440 "worker_actor_diff",
18441 "workerActorDiff",
18442 ];
18443
18444 #[allow(clippy::enum_variant_names)]
18445 enum GeneratedField {
18446 WorkerActorDiff,
18447 }
18448 impl<'de> serde::Deserialize<'de> for GeneratedField {
18449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18450 where
18451 D: serde::Deserializer<'de>,
18452 {
18453 struct GeneratedVisitor;
18454
18455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18456 type Value = GeneratedField;
18457
18458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18459 write!(formatter, "expected one of: {:?}", &FIELDS)
18460 }
18461
18462 #[allow(unused_variables)]
18463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18464 where
18465 E: serde::de::Error,
18466 {
18467 match value {
18468 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
18469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18470 }
18471 }
18472 }
18473 deserializer.deserialize_identifier(GeneratedVisitor)
18474 }
18475 }
18476 struct GeneratedVisitor;
18477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18478 type Value = WorkerReschedule;
18479
18480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18481 formatter.write_str("struct meta.WorkerReschedule")
18482 }
18483
18484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
18485 where
18486 V: serde::de::MapAccess<'de>,
18487 {
18488 let mut worker_actor_diff__ = None;
18489 while let Some(k) = map_.next_key()? {
18490 match k {
18491 GeneratedField::WorkerActorDiff => {
18492 if worker_actor_diff__.is_some() {
18493 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
18494 }
18495 worker_actor_diff__ = Some(
18496 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
18497 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
18498 );
18499 }
18500 }
18501 }
18502 Ok(WorkerReschedule {
18503 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
18504 })
18505 }
18506 }
18507 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
18508 }
18509}