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.config_override.is_empty() {
11487 len += 1;
11488 }
11489 if self.database_id != 0 {
11490 len += 1;
11491 }
11492 if self.schema_id != 0 {
11493 len += 1;
11494 }
11495 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
11496 if self.table_id != 0 {
11497 struct_ser.serialize_field("tableId", &self.table_id)?;
11498 }
11499 if self.state != 0 {
11500 let v = table_fragments::State::try_from(self.state)
11501 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
11502 struct_ser.serialize_field("state", &v)?;
11503 }
11504 if let Some(v) = self.parallelism.as_ref() {
11505 struct_ser.serialize_field("parallelism", v)?;
11506 }
11507 if self.max_parallelism != 0 {
11508 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11509 }
11510 if !self.name.is_empty() {
11511 struct_ser.serialize_field("name", &self.name)?;
11512 }
11513 if !self.resource_group.is_empty() {
11514 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
11515 }
11516 if !self.config_override.is_empty() {
11517 struct_ser.serialize_field("configOverride", &self.config_override)?;
11518 }
11519 if self.database_id != 0 {
11520 struct_ser.serialize_field("databaseId", &self.database_id)?;
11521 }
11522 if self.schema_id != 0 {
11523 struct_ser.serialize_field("schemaId", &self.schema_id)?;
11524 }
11525 struct_ser.end()
11526 }
11527}
11528impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
11529 #[allow(deprecated)]
11530 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11531 where
11532 D: serde::Deserializer<'de>,
11533 {
11534 const FIELDS: &[&str] = &[
11535 "table_id",
11536 "tableId",
11537 "state",
11538 "parallelism",
11539 "max_parallelism",
11540 "maxParallelism",
11541 "name",
11542 "resource_group",
11543 "resourceGroup",
11544 "config_override",
11545 "configOverride",
11546 "database_id",
11547 "databaseId",
11548 "schema_id",
11549 "schemaId",
11550 ];
11551
11552 #[allow(clippy::enum_variant_names)]
11553 enum GeneratedField {
11554 TableId,
11555 State,
11556 Parallelism,
11557 MaxParallelism,
11558 Name,
11559 ResourceGroup,
11560 ConfigOverride,
11561 DatabaseId,
11562 SchemaId,
11563 }
11564 impl<'de> serde::Deserialize<'de> for GeneratedField {
11565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11566 where
11567 D: serde::Deserializer<'de>,
11568 {
11569 struct GeneratedVisitor;
11570
11571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11572 type Value = GeneratedField;
11573
11574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11575 write!(formatter, "expected one of: {:?}", &FIELDS)
11576 }
11577
11578 #[allow(unused_variables)]
11579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11580 where
11581 E: serde::de::Error,
11582 {
11583 match value {
11584 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11585 "state" => Ok(GeneratedField::State),
11586 "parallelism" => Ok(GeneratedField::Parallelism),
11587 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11588 "name" => Ok(GeneratedField::Name),
11589 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
11590 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
11591 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
11592 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
11593 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11594 }
11595 }
11596 }
11597 deserializer.deserialize_identifier(GeneratedVisitor)
11598 }
11599 }
11600 struct GeneratedVisitor;
11601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11602 type Value = list_streaming_job_states_response::StreamingJobState;
11603
11604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11605 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
11606 }
11607
11608 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
11609 where
11610 V: serde::de::MapAccess<'de>,
11611 {
11612 let mut table_id__ = None;
11613 let mut state__ = None;
11614 let mut parallelism__ = None;
11615 let mut max_parallelism__ = None;
11616 let mut name__ = None;
11617 let mut resource_group__ = None;
11618 let mut config_override__ = None;
11619 let mut database_id__ = None;
11620 let mut schema_id__ = None;
11621 while let Some(k) = map_.next_key()? {
11622 match k {
11623 GeneratedField::TableId => {
11624 if table_id__.is_some() {
11625 return Err(serde::de::Error::duplicate_field("tableId"));
11626 }
11627 table_id__ =
11628 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11629 ;
11630 }
11631 GeneratedField::State => {
11632 if state__.is_some() {
11633 return Err(serde::de::Error::duplicate_field("state"));
11634 }
11635 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
11636 }
11637 GeneratedField::Parallelism => {
11638 if parallelism__.is_some() {
11639 return Err(serde::de::Error::duplicate_field("parallelism"));
11640 }
11641 parallelism__ = map_.next_value()?;
11642 }
11643 GeneratedField::MaxParallelism => {
11644 if max_parallelism__.is_some() {
11645 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11646 }
11647 max_parallelism__ =
11648 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11649 ;
11650 }
11651 GeneratedField::Name => {
11652 if name__.is_some() {
11653 return Err(serde::de::Error::duplicate_field("name"));
11654 }
11655 name__ = Some(map_.next_value()?);
11656 }
11657 GeneratedField::ResourceGroup => {
11658 if resource_group__.is_some() {
11659 return Err(serde::de::Error::duplicate_field("resourceGroup"));
11660 }
11661 resource_group__ = Some(map_.next_value()?);
11662 }
11663 GeneratedField::ConfigOverride => {
11664 if config_override__.is_some() {
11665 return Err(serde::de::Error::duplicate_field("configOverride"));
11666 }
11667 config_override__ = Some(map_.next_value()?);
11668 }
11669 GeneratedField::DatabaseId => {
11670 if database_id__.is_some() {
11671 return Err(serde::de::Error::duplicate_field("databaseId"));
11672 }
11673 database_id__ =
11674 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11675 ;
11676 }
11677 GeneratedField::SchemaId => {
11678 if schema_id__.is_some() {
11679 return Err(serde::de::Error::duplicate_field("schemaId"));
11680 }
11681 schema_id__ =
11682 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11683 ;
11684 }
11685 }
11686 }
11687 Ok(list_streaming_job_states_response::StreamingJobState {
11688 table_id: table_id__.unwrap_or_default(),
11689 state: state__.unwrap_or_default(),
11690 parallelism: parallelism__,
11691 max_parallelism: max_parallelism__.unwrap_or_default(),
11692 name: name__.unwrap_or_default(),
11693 resource_group: resource_group__.unwrap_or_default(),
11694 config_override: config_override__.unwrap_or_default(),
11695 database_id: database_id__.unwrap_or_default(),
11696 schema_id: schema_id__.unwrap_or_default(),
11697 })
11698 }
11699 }
11700 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
11701 }
11702}
11703impl serde::Serialize for ListTableFragmentsRequest {
11704 #[allow(deprecated)]
11705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11706 where
11707 S: serde::Serializer,
11708 {
11709 use serde::ser::SerializeStruct;
11710 let mut len = 0;
11711 if !self.table_ids.is_empty() {
11712 len += 1;
11713 }
11714 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
11715 if !self.table_ids.is_empty() {
11716 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11717 }
11718 struct_ser.end()
11719 }
11720}
11721impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
11722 #[allow(deprecated)]
11723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11724 where
11725 D: serde::Deserializer<'de>,
11726 {
11727 const FIELDS: &[&str] = &[
11728 "table_ids",
11729 "tableIds",
11730 ];
11731
11732 #[allow(clippy::enum_variant_names)]
11733 enum GeneratedField {
11734 TableIds,
11735 }
11736 impl<'de> serde::Deserialize<'de> for GeneratedField {
11737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11738 where
11739 D: serde::Deserializer<'de>,
11740 {
11741 struct GeneratedVisitor;
11742
11743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11744 type Value = GeneratedField;
11745
11746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11747 write!(formatter, "expected one of: {:?}", &FIELDS)
11748 }
11749
11750 #[allow(unused_variables)]
11751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11752 where
11753 E: serde::de::Error,
11754 {
11755 match value {
11756 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11758 }
11759 }
11760 }
11761 deserializer.deserialize_identifier(GeneratedVisitor)
11762 }
11763 }
11764 struct GeneratedVisitor;
11765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11766 type Value = ListTableFragmentsRequest;
11767
11768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11769 formatter.write_str("struct meta.ListTableFragmentsRequest")
11770 }
11771
11772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
11773 where
11774 V: serde::de::MapAccess<'de>,
11775 {
11776 let mut table_ids__ = None;
11777 while let Some(k) = map_.next_key()? {
11778 match k {
11779 GeneratedField::TableIds => {
11780 if table_ids__.is_some() {
11781 return Err(serde::de::Error::duplicate_field("tableIds"));
11782 }
11783 table_ids__ =
11784 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11785 .into_iter().map(|x| x.0).collect())
11786 ;
11787 }
11788 }
11789 }
11790 Ok(ListTableFragmentsRequest {
11791 table_ids: table_ids__.unwrap_or_default(),
11792 })
11793 }
11794 }
11795 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
11796 }
11797}
11798impl serde::Serialize for ListTableFragmentsResponse {
11799 #[allow(deprecated)]
11800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11801 where
11802 S: serde::Serializer,
11803 {
11804 use serde::ser::SerializeStruct;
11805 let mut len = 0;
11806 if !self.table_fragments.is_empty() {
11807 len += 1;
11808 }
11809 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
11810 if !self.table_fragments.is_empty() {
11811 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
11812 }
11813 struct_ser.end()
11814 }
11815}
11816impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
11817 #[allow(deprecated)]
11818 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11819 where
11820 D: serde::Deserializer<'de>,
11821 {
11822 const FIELDS: &[&str] = &[
11823 "table_fragments",
11824 "tableFragments",
11825 ];
11826
11827 #[allow(clippy::enum_variant_names)]
11828 enum GeneratedField {
11829 TableFragments,
11830 }
11831 impl<'de> serde::Deserialize<'de> for GeneratedField {
11832 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11833 where
11834 D: serde::Deserializer<'de>,
11835 {
11836 struct GeneratedVisitor;
11837
11838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11839 type Value = GeneratedField;
11840
11841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11842 write!(formatter, "expected one of: {:?}", &FIELDS)
11843 }
11844
11845 #[allow(unused_variables)]
11846 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11847 where
11848 E: serde::de::Error,
11849 {
11850 match value {
11851 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
11852 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11853 }
11854 }
11855 }
11856 deserializer.deserialize_identifier(GeneratedVisitor)
11857 }
11858 }
11859 struct GeneratedVisitor;
11860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11861 type Value = ListTableFragmentsResponse;
11862
11863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11864 formatter.write_str("struct meta.ListTableFragmentsResponse")
11865 }
11866
11867 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
11868 where
11869 V: serde::de::MapAccess<'de>,
11870 {
11871 let mut table_fragments__ = None;
11872 while let Some(k) = map_.next_key()? {
11873 match k {
11874 GeneratedField::TableFragments => {
11875 if table_fragments__.is_some() {
11876 return Err(serde::de::Error::duplicate_field("tableFragments"));
11877 }
11878 table_fragments__ = Some(
11879 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11880 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11881 );
11882 }
11883 }
11884 }
11885 Ok(ListTableFragmentsResponse {
11886 table_fragments: table_fragments__.unwrap_or_default(),
11887 })
11888 }
11889 }
11890 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
11891 }
11892}
11893impl serde::Serialize for list_table_fragments_response::ActorInfo {
11894 #[allow(deprecated)]
11895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11896 where
11897 S: serde::Serializer,
11898 {
11899 use serde::ser::SerializeStruct;
11900 let mut len = 0;
11901 if self.id != 0 {
11902 len += 1;
11903 }
11904 if self.node.is_some() {
11905 len += 1;
11906 }
11907 if !self.dispatcher.is_empty() {
11908 len += 1;
11909 }
11910 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
11911 if self.id != 0 {
11912 struct_ser.serialize_field("id", &self.id)?;
11913 }
11914 if let Some(v) = self.node.as_ref() {
11915 struct_ser.serialize_field("node", v)?;
11916 }
11917 if !self.dispatcher.is_empty() {
11918 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11919 }
11920 struct_ser.end()
11921 }
11922}
11923impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
11924 #[allow(deprecated)]
11925 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11926 where
11927 D: serde::Deserializer<'de>,
11928 {
11929 const FIELDS: &[&str] = &[
11930 "id",
11931 "node",
11932 "dispatcher",
11933 ];
11934
11935 #[allow(clippy::enum_variant_names)]
11936 enum GeneratedField {
11937 Id,
11938 Node,
11939 Dispatcher,
11940 }
11941 impl<'de> serde::Deserialize<'de> for GeneratedField {
11942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11943 where
11944 D: serde::Deserializer<'de>,
11945 {
11946 struct GeneratedVisitor;
11947
11948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11949 type Value = GeneratedField;
11950
11951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11952 write!(formatter, "expected one of: {:?}", &FIELDS)
11953 }
11954
11955 #[allow(unused_variables)]
11956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11957 where
11958 E: serde::de::Error,
11959 {
11960 match value {
11961 "id" => Ok(GeneratedField::Id),
11962 "node" => Ok(GeneratedField::Node),
11963 "dispatcher" => Ok(GeneratedField::Dispatcher),
11964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11965 }
11966 }
11967 }
11968 deserializer.deserialize_identifier(GeneratedVisitor)
11969 }
11970 }
11971 struct GeneratedVisitor;
11972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11973 type Value = list_table_fragments_response::ActorInfo;
11974
11975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11976 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
11977 }
11978
11979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
11980 where
11981 V: serde::de::MapAccess<'de>,
11982 {
11983 let mut id__ = None;
11984 let mut node__ = None;
11985 let mut dispatcher__ = None;
11986 while let Some(k) = map_.next_key()? {
11987 match k {
11988 GeneratedField::Id => {
11989 if id__.is_some() {
11990 return Err(serde::de::Error::duplicate_field("id"));
11991 }
11992 id__ =
11993 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11994 ;
11995 }
11996 GeneratedField::Node => {
11997 if node__.is_some() {
11998 return Err(serde::de::Error::duplicate_field("node"));
11999 }
12000 node__ = map_.next_value()?;
12001 }
12002 GeneratedField::Dispatcher => {
12003 if dispatcher__.is_some() {
12004 return Err(serde::de::Error::duplicate_field("dispatcher"));
12005 }
12006 dispatcher__ = Some(map_.next_value()?);
12007 }
12008 }
12009 }
12010 Ok(list_table_fragments_response::ActorInfo {
12011 id: id__.unwrap_or_default(),
12012 node: node__,
12013 dispatcher: dispatcher__.unwrap_or_default(),
12014 })
12015 }
12016 }
12017 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
12018 }
12019}
12020impl serde::Serialize for list_table_fragments_response::FragmentInfo {
12021 #[allow(deprecated)]
12022 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12023 where
12024 S: serde::Serializer,
12025 {
12026 use serde::ser::SerializeStruct;
12027 let mut len = 0;
12028 if self.id != 0 {
12029 len += 1;
12030 }
12031 if !self.actors.is_empty() {
12032 len += 1;
12033 }
12034 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
12035 if self.id != 0 {
12036 struct_ser.serialize_field("id", &self.id)?;
12037 }
12038 if !self.actors.is_empty() {
12039 struct_ser.serialize_field("actors", &self.actors)?;
12040 }
12041 struct_ser.end()
12042 }
12043}
12044impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
12045 #[allow(deprecated)]
12046 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12047 where
12048 D: serde::Deserializer<'de>,
12049 {
12050 const FIELDS: &[&str] = &[
12051 "id",
12052 "actors",
12053 ];
12054
12055 #[allow(clippy::enum_variant_names)]
12056 enum GeneratedField {
12057 Id,
12058 Actors,
12059 }
12060 impl<'de> serde::Deserialize<'de> for GeneratedField {
12061 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12062 where
12063 D: serde::Deserializer<'de>,
12064 {
12065 struct GeneratedVisitor;
12066
12067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12068 type Value = GeneratedField;
12069
12070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12071 write!(formatter, "expected one of: {:?}", &FIELDS)
12072 }
12073
12074 #[allow(unused_variables)]
12075 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12076 where
12077 E: serde::de::Error,
12078 {
12079 match value {
12080 "id" => Ok(GeneratedField::Id),
12081 "actors" => Ok(GeneratedField::Actors),
12082 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12083 }
12084 }
12085 }
12086 deserializer.deserialize_identifier(GeneratedVisitor)
12087 }
12088 }
12089 struct GeneratedVisitor;
12090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12091 type Value = list_table_fragments_response::FragmentInfo;
12092
12093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12094 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
12095 }
12096
12097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
12098 where
12099 V: serde::de::MapAccess<'de>,
12100 {
12101 let mut id__ = None;
12102 let mut actors__ = None;
12103 while let Some(k) = map_.next_key()? {
12104 match k {
12105 GeneratedField::Id => {
12106 if id__.is_some() {
12107 return Err(serde::de::Error::duplicate_field("id"));
12108 }
12109 id__ =
12110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12111 ;
12112 }
12113 GeneratedField::Actors => {
12114 if actors__.is_some() {
12115 return Err(serde::de::Error::duplicate_field("actors"));
12116 }
12117 actors__ = Some(map_.next_value()?);
12118 }
12119 }
12120 }
12121 Ok(list_table_fragments_response::FragmentInfo {
12122 id: id__.unwrap_or_default(),
12123 actors: actors__.unwrap_or_default(),
12124 })
12125 }
12126 }
12127 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
12128 }
12129}
12130impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
12131 #[allow(deprecated)]
12132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12133 where
12134 S: serde::Serializer,
12135 {
12136 use serde::ser::SerializeStruct;
12137 let mut len = 0;
12138 if !self.fragments.is_empty() {
12139 len += 1;
12140 }
12141 if self.ctx.is_some() {
12142 len += 1;
12143 }
12144 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
12145 if !self.fragments.is_empty() {
12146 struct_ser.serialize_field("fragments", &self.fragments)?;
12147 }
12148 if let Some(v) = self.ctx.as_ref() {
12149 struct_ser.serialize_field("ctx", v)?;
12150 }
12151 struct_ser.end()
12152 }
12153}
12154impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
12155 #[allow(deprecated)]
12156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12157 where
12158 D: serde::Deserializer<'de>,
12159 {
12160 const FIELDS: &[&str] = &[
12161 "fragments",
12162 "ctx",
12163 ];
12164
12165 #[allow(clippy::enum_variant_names)]
12166 enum GeneratedField {
12167 Fragments,
12168 Ctx,
12169 }
12170 impl<'de> serde::Deserialize<'de> for GeneratedField {
12171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12172 where
12173 D: serde::Deserializer<'de>,
12174 {
12175 struct GeneratedVisitor;
12176
12177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12178 type Value = GeneratedField;
12179
12180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12181 write!(formatter, "expected one of: {:?}", &FIELDS)
12182 }
12183
12184 #[allow(unused_variables)]
12185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12186 where
12187 E: serde::de::Error,
12188 {
12189 match value {
12190 "fragments" => Ok(GeneratedField::Fragments),
12191 "ctx" => Ok(GeneratedField::Ctx),
12192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12193 }
12194 }
12195 }
12196 deserializer.deserialize_identifier(GeneratedVisitor)
12197 }
12198 }
12199 struct GeneratedVisitor;
12200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12201 type Value = list_table_fragments_response::TableFragmentInfo;
12202
12203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12204 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
12205 }
12206
12207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
12208 where
12209 V: serde::de::MapAccess<'de>,
12210 {
12211 let mut fragments__ = None;
12212 let mut ctx__ = None;
12213 while let Some(k) = map_.next_key()? {
12214 match k {
12215 GeneratedField::Fragments => {
12216 if fragments__.is_some() {
12217 return Err(serde::de::Error::duplicate_field("fragments"));
12218 }
12219 fragments__ = Some(map_.next_value()?);
12220 }
12221 GeneratedField::Ctx => {
12222 if ctx__.is_some() {
12223 return Err(serde::de::Error::duplicate_field("ctx"));
12224 }
12225 ctx__ = map_.next_value()?;
12226 }
12227 }
12228 }
12229 Ok(list_table_fragments_response::TableFragmentInfo {
12230 fragments: fragments__.unwrap_or_default(),
12231 ctx: ctx__,
12232 })
12233 }
12234 }
12235 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
12236 }
12237}
12238impl serde::Serialize for ListUnmigratedTablesRequest {
12239 #[allow(deprecated)]
12240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12241 where
12242 S: serde::Serializer,
12243 {
12244 use serde::ser::SerializeStruct;
12245 let len = 0;
12246 let struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesRequest", len)?;
12247 struct_ser.end()
12248 }
12249}
12250impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesRequest {
12251 #[allow(deprecated)]
12252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12253 where
12254 D: serde::Deserializer<'de>,
12255 {
12256 const FIELDS: &[&str] = &[
12257 ];
12258
12259 #[allow(clippy::enum_variant_names)]
12260 enum GeneratedField {
12261 }
12262 impl<'de> serde::Deserialize<'de> for GeneratedField {
12263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12264 where
12265 D: serde::Deserializer<'de>,
12266 {
12267 struct GeneratedVisitor;
12268
12269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12270 type Value = GeneratedField;
12271
12272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12273 write!(formatter, "expected one of: {:?}", &FIELDS)
12274 }
12275
12276 #[allow(unused_variables)]
12277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12278 where
12279 E: serde::de::Error,
12280 {
12281 Err(serde::de::Error::unknown_field(value, FIELDS))
12282 }
12283 }
12284 deserializer.deserialize_identifier(GeneratedVisitor)
12285 }
12286 }
12287 struct GeneratedVisitor;
12288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12289 type Value = ListUnmigratedTablesRequest;
12290
12291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12292 formatter.write_str("struct meta.ListUnmigratedTablesRequest")
12293 }
12294
12295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesRequest, V::Error>
12296 where
12297 V: serde::de::MapAccess<'de>,
12298 {
12299 while map_.next_key::<GeneratedField>()?.is_some() {
12300 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12301 }
12302 Ok(ListUnmigratedTablesRequest {
12303 })
12304 }
12305 }
12306 deserializer.deserialize_struct("meta.ListUnmigratedTablesRequest", FIELDS, GeneratedVisitor)
12307 }
12308}
12309impl serde::Serialize for ListUnmigratedTablesResponse {
12310 #[allow(deprecated)]
12311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12312 where
12313 S: serde::Serializer,
12314 {
12315 use serde::ser::SerializeStruct;
12316 let mut len = 0;
12317 if !self.tables.is_empty() {
12318 len += 1;
12319 }
12320 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse", len)?;
12321 if !self.tables.is_empty() {
12322 struct_ser.serialize_field("tables", &self.tables)?;
12323 }
12324 struct_ser.end()
12325 }
12326}
12327impl<'de> serde::Deserialize<'de> for ListUnmigratedTablesResponse {
12328 #[allow(deprecated)]
12329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12330 where
12331 D: serde::Deserializer<'de>,
12332 {
12333 const FIELDS: &[&str] = &[
12334 "tables",
12335 ];
12336
12337 #[allow(clippy::enum_variant_names)]
12338 enum GeneratedField {
12339 Tables,
12340 }
12341 impl<'de> serde::Deserialize<'de> for GeneratedField {
12342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12343 where
12344 D: serde::Deserializer<'de>,
12345 {
12346 struct GeneratedVisitor;
12347
12348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12349 type Value = GeneratedField;
12350
12351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12352 write!(formatter, "expected one of: {:?}", &FIELDS)
12353 }
12354
12355 #[allow(unused_variables)]
12356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12357 where
12358 E: serde::de::Error,
12359 {
12360 match value {
12361 "tables" => Ok(GeneratedField::Tables),
12362 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12363 }
12364 }
12365 }
12366 deserializer.deserialize_identifier(GeneratedVisitor)
12367 }
12368 }
12369 struct GeneratedVisitor;
12370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12371 type Value = ListUnmigratedTablesResponse;
12372
12373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12374 formatter.write_str("struct meta.ListUnmigratedTablesResponse")
12375 }
12376
12377 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListUnmigratedTablesResponse, V::Error>
12378 where
12379 V: serde::de::MapAccess<'de>,
12380 {
12381 let mut tables__ = None;
12382 while let Some(k) = map_.next_key()? {
12383 match k {
12384 GeneratedField::Tables => {
12385 if tables__.is_some() {
12386 return Err(serde::de::Error::duplicate_field("tables"));
12387 }
12388 tables__ = Some(map_.next_value()?);
12389 }
12390 }
12391 }
12392 Ok(ListUnmigratedTablesResponse {
12393 tables: tables__.unwrap_or_default(),
12394 })
12395 }
12396 }
12397 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse", FIELDS, GeneratedVisitor)
12398 }
12399}
12400impl serde::Serialize for list_unmigrated_tables_response::UnmigratedTable {
12401 #[allow(deprecated)]
12402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12403 where
12404 S: serde::Serializer,
12405 {
12406 use serde::ser::SerializeStruct;
12407 let mut len = 0;
12408 if self.table_id != 0 {
12409 len += 1;
12410 }
12411 if !self.table_name.is_empty() {
12412 len += 1;
12413 }
12414 let mut struct_ser = serializer.serialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", len)?;
12415 if self.table_id != 0 {
12416 struct_ser.serialize_field("tableId", &self.table_id)?;
12417 }
12418 if !self.table_name.is_empty() {
12419 struct_ser.serialize_field("tableName", &self.table_name)?;
12420 }
12421 struct_ser.end()
12422 }
12423}
12424impl<'de> serde::Deserialize<'de> for list_unmigrated_tables_response::UnmigratedTable {
12425 #[allow(deprecated)]
12426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12427 where
12428 D: serde::Deserializer<'de>,
12429 {
12430 const FIELDS: &[&str] = &[
12431 "table_id",
12432 "tableId",
12433 "table_name",
12434 "tableName",
12435 ];
12436
12437 #[allow(clippy::enum_variant_names)]
12438 enum GeneratedField {
12439 TableId,
12440 TableName,
12441 }
12442 impl<'de> serde::Deserialize<'de> for GeneratedField {
12443 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12444 where
12445 D: serde::Deserializer<'de>,
12446 {
12447 struct GeneratedVisitor;
12448
12449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12450 type Value = GeneratedField;
12451
12452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12453 write!(formatter, "expected one of: {:?}", &FIELDS)
12454 }
12455
12456 #[allow(unused_variables)]
12457 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12458 where
12459 E: serde::de::Error,
12460 {
12461 match value {
12462 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12463 "tableName" | "table_name" => Ok(GeneratedField::TableName),
12464 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12465 }
12466 }
12467 }
12468 deserializer.deserialize_identifier(GeneratedVisitor)
12469 }
12470 }
12471 struct GeneratedVisitor;
12472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12473 type Value = list_unmigrated_tables_response::UnmigratedTable;
12474
12475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12476 formatter.write_str("struct meta.ListUnmigratedTablesResponse.UnmigratedTable")
12477 }
12478
12479 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_unmigrated_tables_response::UnmigratedTable, V::Error>
12480 where
12481 V: serde::de::MapAccess<'de>,
12482 {
12483 let mut table_id__ = None;
12484 let mut table_name__ = None;
12485 while let Some(k) = map_.next_key()? {
12486 match k {
12487 GeneratedField::TableId => {
12488 if table_id__.is_some() {
12489 return Err(serde::de::Error::duplicate_field("tableId"));
12490 }
12491 table_id__ =
12492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12493 ;
12494 }
12495 GeneratedField::TableName => {
12496 if table_name__.is_some() {
12497 return Err(serde::de::Error::duplicate_field("tableName"));
12498 }
12499 table_name__ = Some(map_.next_value()?);
12500 }
12501 }
12502 }
12503 Ok(list_unmigrated_tables_response::UnmigratedTable {
12504 table_id: table_id__.unwrap_or_default(),
12505 table_name: table_name__.unwrap_or_default(),
12506 })
12507 }
12508 }
12509 deserializer.deserialize_struct("meta.ListUnmigratedTablesResponse.UnmigratedTable", FIELDS, GeneratedVisitor)
12510 }
12511}
12512impl serde::Serialize for MembersRequest {
12513 #[allow(deprecated)]
12514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12515 where
12516 S: serde::Serializer,
12517 {
12518 use serde::ser::SerializeStruct;
12519 let len = 0;
12520 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
12521 struct_ser.end()
12522 }
12523}
12524impl<'de> serde::Deserialize<'de> for MembersRequest {
12525 #[allow(deprecated)]
12526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12527 where
12528 D: serde::Deserializer<'de>,
12529 {
12530 const FIELDS: &[&str] = &[
12531 ];
12532
12533 #[allow(clippy::enum_variant_names)]
12534 enum GeneratedField {
12535 }
12536 impl<'de> serde::Deserialize<'de> for GeneratedField {
12537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12538 where
12539 D: serde::Deserializer<'de>,
12540 {
12541 struct GeneratedVisitor;
12542
12543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12544 type Value = GeneratedField;
12545
12546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12547 write!(formatter, "expected one of: {:?}", &FIELDS)
12548 }
12549
12550 #[allow(unused_variables)]
12551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12552 where
12553 E: serde::de::Error,
12554 {
12555 Err(serde::de::Error::unknown_field(value, FIELDS))
12556 }
12557 }
12558 deserializer.deserialize_identifier(GeneratedVisitor)
12559 }
12560 }
12561 struct GeneratedVisitor;
12562 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12563 type Value = MembersRequest;
12564
12565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12566 formatter.write_str("struct meta.MembersRequest")
12567 }
12568
12569 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
12570 where
12571 V: serde::de::MapAccess<'de>,
12572 {
12573 while map_.next_key::<GeneratedField>()?.is_some() {
12574 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12575 }
12576 Ok(MembersRequest {
12577 })
12578 }
12579 }
12580 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
12581 }
12582}
12583impl serde::Serialize for MembersResponse {
12584 #[allow(deprecated)]
12585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12586 where
12587 S: serde::Serializer,
12588 {
12589 use serde::ser::SerializeStruct;
12590 let mut len = 0;
12591 if !self.members.is_empty() {
12592 len += 1;
12593 }
12594 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
12595 if !self.members.is_empty() {
12596 struct_ser.serialize_field("members", &self.members)?;
12597 }
12598 struct_ser.end()
12599 }
12600}
12601impl<'de> serde::Deserialize<'de> for MembersResponse {
12602 #[allow(deprecated)]
12603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12604 where
12605 D: serde::Deserializer<'de>,
12606 {
12607 const FIELDS: &[&str] = &[
12608 "members",
12609 ];
12610
12611 #[allow(clippy::enum_variant_names)]
12612 enum GeneratedField {
12613 Members,
12614 }
12615 impl<'de> serde::Deserialize<'de> for GeneratedField {
12616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12617 where
12618 D: serde::Deserializer<'de>,
12619 {
12620 struct GeneratedVisitor;
12621
12622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12623 type Value = GeneratedField;
12624
12625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12626 write!(formatter, "expected one of: {:?}", &FIELDS)
12627 }
12628
12629 #[allow(unused_variables)]
12630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12631 where
12632 E: serde::de::Error,
12633 {
12634 match value {
12635 "members" => Ok(GeneratedField::Members),
12636 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12637 }
12638 }
12639 }
12640 deserializer.deserialize_identifier(GeneratedVisitor)
12641 }
12642 }
12643 struct GeneratedVisitor;
12644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12645 type Value = MembersResponse;
12646
12647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12648 formatter.write_str("struct meta.MembersResponse")
12649 }
12650
12651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
12652 where
12653 V: serde::de::MapAccess<'de>,
12654 {
12655 let mut members__ = None;
12656 while let Some(k) = map_.next_key()? {
12657 match k {
12658 GeneratedField::Members => {
12659 if members__.is_some() {
12660 return Err(serde::de::Error::duplicate_field("members"));
12661 }
12662 members__ = Some(map_.next_value()?);
12663 }
12664 }
12665 }
12666 Ok(MembersResponse {
12667 members: members__.unwrap_or_default(),
12668 })
12669 }
12670 }
12671 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
12672 }
12673}
12674impl serde::Serialize for MetaMember {
12675 #[allow(deprecated)]
12676 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12677 where
12678 S: serde::Serializer,
12679 {
12680 use serde::ser::SerializeStruct;
12681 let mut len = 0;
12682 if self.address.is_some() {
12683 len += 1;
12684 }
12685 if self.is_leader {
12686 len += 1;
12687 }
12688 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
12689 if let Some(v) = self.address.as_ref() {
12690 struct_ser.serialize_field("address", v)?;
12691 }
12692 if self.is_leader {
12693 struct_ser.serialize_field("isLeader", &self.is_leader)?;
12694 }
12695 struct_ser.end()
12696 }
12697}
12698impl<'de> serde::Deserialize<'de> for MetaMember {
12699 #[allow(deprecated)]
12700 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12701 where
12702 D: serde::Deserializer<'de>,
12703 {
12704 const FIELDS: &[&str] = &[
12705 "address",
12706 "is_leader",
12707 "isLeader",
12708 ];
12709
12710 #[allow(clippy::enum_variant_names)]
12711 enum GeneratedField {
12712 Address,
12713 IsLeader,
12714 }
12715 impl<'de> serde::Deserialize<'de> for GeneratedField {
12716 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12717 where
12718 D: serde::Deserializer<'de>,
12719 {
12720 struct GeneratedVisitor;
12721
12722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12723 type Value = GeneratedField;
12724
12725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12726 write!(formatter, "expected one of: {:?}", &FIELDS)
12727 }
12728
12729 #[allow(unused_variables)]
12730 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12731 where
12732 E: serde::de::Error,
12733 {
12734 match value {
12735 "address" => Ok(GeneratedField::Address),
12736 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
12737 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12738 }
12739 }
12740 }
12741 deserializer.deserialize_identifier(GeneratedVisitor)
12742 }
12743 }
12744 struct GeneratedVisitor;
12745 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12746 type Value = MetaMember;
12747
12748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12749 formatter.write_str("struct meta.MetaMember")
12750 }
12751
12752 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
12753 where
12754 V: serde::de::MapAccess<'de>,
12755 {
12756 let mut address__ = None;
12757 let mut is_leader__ = None;
12758 while let Some(k) = map_.next_key()? {
12759 match k {
12760 GeneratedField::Address => {
12761 if address__.is_some() {
12762 return Err(serde::de::Error::duplicate_field("address"));
12763 }
12764 address__ = map_.next_value()?;
12765 }
12766 GeneratedField::IsLeader => {
12767 if is_leader__.is_some() {
12768 return Err(serde::de::Error::duplicate_field("isLeader"));
12769 }
12770 is_leader__ = Some(map_.next_value()?);
12771 }
12772 }
12773 }
12774 Ok(MetaMember {
12775 address: address__,
12776 is_leader: is_leader__.unwrap_or_default(),
12777 })
12778 }
12779 }
12780 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
12781 }
12782}
12783impl serde::Serialize for MetaSnapshot {
12784 #[allow(deprecated)]
12785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12786 where
12787 S: serde::Serializer,
12788 {
12789 use serde::ser::SerializeStruct;
12790 let mut len = 0;
12791 if !self.databases.is_empty() {
12792 len += 1;
12793 }
12794 if !self.schemas.is_empty() {
12795 len += 1;
12796 }
12797 if !self.sources.is_empty() {
12798 len += 1;
12799 }
12800 if !self.sinks.is_empty() {
12801 len += 1;
12802 }
12803 if !self.tables.is_empty() {
12804 len += 1;
12805 }
12806 if !self.indexes.is_empty() {
12807 len += 1;
12808 }
12809 if !self.views.is_empty() {
12810 len += 1;
12811 }
12812 if !self.functions.is_empty() {
12813 len += 1;
12814 }
12815 if !self.connections.is_empty() {
12816 len += 1;
12817 }
12818 if !self.subscriptions.is_empty() {
12819 len += 1;
12820 }
12821 if !self.users.is_empty() {
12822 len += 1;
12823 }
12824 if self.session_params.is_some() {
12825 len += 1;
12826 }
12827 if !self.secrets.is_empty() {
12828 len += 1;
12829 }
12830 if self.cluster_resource.is_some() {
12831 len += 1;
12832 }
12833 if !self.nodes.is_empty() {
12834 len += 1;
12835 }
12836 if self.hummock_version.is_some() {
12837 len += 1;
12838 }
12839 if self.meta_backup_manifest_id.is_some() {
12840 len += 1;
12841 }
12842 if self.hummock_write_limits.is_some() {
12843 len += 1;
12844 }
12845 if !self.streaming_worker_slot_mappings.is_empty() {
12846 len += 1;
12847 }
12848 if !self.serving_worker_slot_mappings.is_empty() {
12849 len += 1;
12850 }
12851 if self.version.is_some() {
12852 len += 1;
12853 }
12854 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
12855 if !self.databases.is_empty() {
12856 struct_ser.serialize_field("databases", &self.databases)?;
12857 }
12858 if !self.schemas.is_empty() {
12859 struct_ser.serialize_field("schemas", &self.schemas)?;
12860 }
12861 if !self.sources.is_empty() {
12862 struct_ser.serialize_field("sources", &self.sources)?;
12863 }
12864 if !self.sinks.is_empty() {
12865 struct_ser.serialize_field("sinks", &self.sinks)?;
12866 }
12867 if !self.tables.is_empty() {
12868 struct_ser.serialize_field("tables", &self.tables)?;
12869 }
12870 if !self.indexes.is_empty() {
12871 struct_ser.serialize_field("indexes", &self.indexes)?;
12872 }
12873 if !self.views.is_empty() {
12874 struct_ser.serialize_field("views", &self.views)?;
12875 }
12876 if !self.functions.is_empty() {
12877 struct_ser.serialize_field("functions", &self.functions)?;
12878 }
12879 if !self.connections.is_empty() {
12880 struct_ser.serialize_field("connections", &self.connections)?;
12881 }
12882 if !self.subscriptions.is_empty() {
12883 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
12884 }
12885 if !self.users.is_empty() {
12886 struct_ser.serialize_field("users", &self.users)?;
12887 }
12888 if let Some(v) = self.session_params.as_ref() {
12889 struct_ser.serialize_field("sessionParams", v)?;
12890 }
12891 if !self.secrets.is_empty() {
12892 struct_ser.serialize_field("secrets", &self.secrets)?;
12893 }
12894 if let Some(v) = self.cluster_resource.as_ref() {
12895 struct_ser.serialize_field("clusterResource", v)?;
12896 }
12897 if !self.nodes.is_empty() {
12898 struct_ser.serialize_field("nodes", &self.nodes)?;
12899 }
12900 if let Some(v) = self.hummock_version.as_ref() {
12901 struct_ser.serialize_field("hummockVersion", v)?;
12902 }
12903 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
12904 struct_ser.serialize_field("metaBackupManifestId", v)?;
12905 }
12906 if let Some(v) = self.hummock_write_limits.as_ref() {
12907 struct_ser.serialize_field("hummockWriteLimits", v)?;
12908 }
12909 if !self.streaming_worker_slot_mappings.is_empty() {
12910 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
12911 }
12912 if !self.serving_worker_slot_mappings.is_empty() {
12913 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
12914 }
12915 if let Some(v) = self.version.as_ref() {
12916 struct_ser.serialize_field("version", v)?;
12917 }
12918 struct_ser.end()
12919 }
12920}
12921impl<'de> serde::Deserialize<'de> for MetaSnapshot {
12922 #[allow(deprecated)]
12923 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12924 where
12925 D: serde::Deserializer<'de>,
12926 {
12927 const FIELDS: &[&str] = &[
12928 "databases",
12929 "schemas",
12930 "sources",
12931 "sinks",
12932 "tables",
12933 "indexes",
12934 "views",
12935 "functions",
12936 "connections",
12937 "subscriptions",
12938 "users",
12939 "session_params",
12940 "sessionParams",
12941 "secrets",
12942 "cluster_resource",
12943 "clusterResource",
12944 "nodes",
12945 "hummock_version",
12946 "hummockVersion",
12947 "meta_backup_manifest_id",
12948 "metaBackupManifestId",
12949 "hummock_write_limits",
12950 "hummockWriteLimits",
12951 "streaming_worker_slot_mappings",
12952 "streamingWorkerSlotMappings",
12953 "serving_worker_slot_mappings",
12954 "servingWorkerSlotMappings",
12955 "version",
12956 ];
12957
12958 #[allow(clippy::enum_variant_names)]
12959 enum GeneratedField {
12960 Databases,
12961 Schemas,
12962 Sources,
12963 Sinks,
12964 Tables,
12965 Indexes,
12966 Views,
12967 Functions,
12968 Connections,
12969 Subscriptions,
12970 Users,
12971 SessionParams,
12972 Secrets,
12973 ClusterResource,
12974 Nodes,
12975 HummockVersion,
12976 MetaBackupManifestId,
12977 HummockWriteLimits,
12978 StreamingWorkerSlotMappings,
12979 ServingWorkerSlotMappings,
12980 Version,
12981 }
12982 impl<'de> serde::Deserialize<'de> for GeneratedField {
12983 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12984 where
12985 D: serde::Deserializer<'de>,
12986 {
12987 struct GeneratedVisitor;
12988
12989 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12990 type Value = GeneratedField;
12991
12992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12993 write!(formatter, "expected one of: {:?}", &FIELDS)
12994 }
12995
12996 #[allow(unused_variables)]
12997 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12998 where
12999 E: serde::de::Error,
13000 {
13001 match value {
13002 "databases" => Ok(GeneratedField::Databases),
13003 "schemas" => Ok(GeneratedField::Schemas),
13004 "sources" => Ok(GeneratedField::Sources),
13005 "sinks" => Ok(GeneratedField::Sinks),
13006 "tables" => Ok(GeneratedField::Tables),
13007 "indexes" => Ok(GeneratedField::Indexes),
13008 "views" => Ok(GeneratedField::Views),
13009 "functions" => Ok(GeneratedField::Functions),
13010 "connections" => Ok(GeneratedField::Connections),
13011 "subscriptions" => Ok(GeneratedField::Subscriptions),
13012 "users" => Ok(GeneratedField::Users),
13013 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
13014 "secrets" => Ok(GeneratedField::Secrets),
13015 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
13016 "nodes" => Ok(GeneratedField::Nodes),
13017 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
13018 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13019 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13020 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
13021 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13022 "version" => Ok(GeneratedField::Version),
13023 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13024 }
13025 }
13026 }
13027 deserializer.deserialize_identifier(GeneratedVisitor)
13028 }
13029 }
13030 struct GeneratedVisitor;
13031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13032 type Value = MetaSnapshot;
13033
13034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13035 formatter.write_str("struct meta.MetaSnapshot")
13036 }
13037
13038 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
13039 where
13040 V: serde::de::MapAccess<'de>,
13041 {
13042 let mut databases__ = None;
13043 let mut schemas__ = None;
13044 let mut sources__ = None;
13045 let mut sinks__ = None;
13046 let mut tables__ = None;
13047 let mut indexes__ = None;
13048 let mut views__ = None;
13049 let mut functions__ = None;
13050 let mut connections__ = None;
13051 let mut subscriptions__ = None;
13052 let mut users__ = None;
13053 let mut session_params__ = None;
13054 let mut secrets__ = None;
13055 let mut cluster_resource__ = None;
13056 let mut nodes__ = None;
13057 let mut hummock_version__ = None;
13058 let mut meta_backup_manifest_id__ = None;
13059 let mut hummock_write_limits__ = None;
13060 let mut streaming_worker_slot_mappings__ = None;
13061 let mut serving_worker_slot_mappings__ = None;
13062 let mut version__ = None;
13063 while let Some(k) = map_.next_key()? {
13064 match k {
13065 GeneratedField::Databases => {
13066 if databases__.is_some() {
13067 return Err(serde::de::Error::duplicate_field("databases"));
13068 }
13069 databases__ = Some(map_.next_value()?);
13070 }
13071 GeneratedField::Schemas => {
13072 if schemas__.is_some() {
13073 return Err(serde::de::Error::duplicate_field("schemas"));
13074 }
13075 schemas__ = Some(map_.next_value()?);
13076 }
13077 GeneratedField::Sources => {
13078 if sources__.is_some() {
13079 return Err(serde::de::Error::duplicate_field("sources"));
13080 }
13081 sources__ = Some(map_.next_value()?);
13082 }
13083 GeneratedField::Sinks => {
13084 if sinks__.is_some() {
13085 return Err(serde::de::Error::duplicate_field("sinks"));
13086 }
13087 sinks__ = Some(map_.next_value()?);
13088 }
13089 GeneratedField::Tables => {
13090 if tables__.is_some() {
13091 return Err(serde::de::Error::duplicate_field("tables"));
13092 }
13093 tables__ = Some(map_.next_value()?);
13094 }
13095 GeneratedField::Indexes => {
13096 if indexes__.is_some() {
13097 return Err(serde::de::Error::duplicate_field("indexes"));
13098 }
13099 indexes__ = Some(map_.next_value()?);
13100 }
13101 GeneratedField::Views => {
13102 if views__.is_some() {
13103 return Err(serde::de::Error::duplicate_field("views"));
13104 }
13105 views__ = Some(map_.next_value()?);
13106 }
13107 GeneratedField::Functions => {
13108 if functions__.is_some() {
13109 return Err(serde::de::Error::duplicate_field("functions"));
13110 }
13111 functions__ = Some(map_.next_value()?);
13112 }
13113 GeneratedField::Connections => {
13114 if connections__.is_some() {
13115 return Err(serde::de::Error::duplicate_field("connections"));
13116 }
13117 connections__ = Some(map_.next_value()?);
13118 }
13119 GeneratedField::Subscriptions => {
13120 if subscriptions__.is_some() {
13121 return Err(serde::de::Error::duplicate_field("subscriptions"));
13122 }
13123 subscriptions__ = Some(map_.next_value()?);
13124 }
13125 GeneratedField::Users => {
13126 if users__.is_some() {
13127 return Err(serde::de::Error::duplicate_field("users"));
13128 }
13129 users__ = Some(map_.next_value()?);
13130 }
13131 GeneratedField::SessionParams => {
13132 if session_params__.is_some() {
13133 return Err(serde::de::Error::duplicate_field("sessionParams"));
13134 }
13135 session_params__ = map_.next_value()?;
13136 }
13137 GeneratedField::Secrets => {
13138 if secrets__.is_some() {
13139 return Err(serde::de::Error::duplicate_field("secrets"));
13140 }
13141 secrets__ = Some(map_.next_value()?);
13142 }
13143 GeneratedField::ClusterResource => {
13144 if cluster_resource__.is_some() {
13145 return Err(serde::de::Error::duplicate_field("clusterResource"));
13146 }
13147 cluster_resource__ = map_.next_value()?;
13148 }
13149 GeneratedField::Nodes => {
13150 if nodes__.is_some() {
13151 return Err(serde::de::Error::duplicate_field("nodes"));
13152 }
13153 nodes__ = Some(map_.next_value()?);
13154 }
13155 GeneratedField::HummockVersion => {
13156 if hummock_version__.is_some() {
13157 return Err(serde::de::Error::duplicate_field("hummockVersion"));
13158 }
13159 hummock_version__ = map_.next_value()?;
13160 }
13161 GeneratedField::MetaBackupManifestId => {
13162 if meta_backup_manifest_id__.is_some() {
13163 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
13164 }
13165 meta_backup_manifest_id__ = map_.next_value()?;
13166 }
13167 GeneratedField::HummockWriteLimits => {
13168 if hummock_write_limits__.is_some() {
13169 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
13170 }
13171 hummock_write_limits__ = map_.next_value()?;
13172 }
13173 GeneratedField::StreamingWorkerSlotMappings => {
13174 if streaming_worker_slot_mappings__.is_some() {
13175 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
13176 }
13177 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
13178 }
13179 GeneratedField::ServingWorkerSlotMappings => {
13180 if serving_worker_slot_mappings__.is_some() {
13181 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
13182 }
13183 serving_worker_slot_mappings__ = Some(map_.next_value()?);
13184 }
13185 GeneratedField::Version => {
13186 if version__.is_some() {
13187 return Err(serde::de::Error::duplicate_field("version"));
13188 }
13189 version__ = map_.next_value()?;
13190 }
13191 }
13192 }
13193 Ok(MetaSnapshot {
13194 databases: databases__.unwrap_or_default(),
13195 schemas: schemas__.unwrap_or_default(),
13196 sources: sources__.unwrap_or_default(),
13197 sinks: sinks__.unwrap_or_default(),
13198 tables: tables__.unwrap_or_default(),
13199 indexes: indexes__.unwrap_or_default(),
13200 views: views__.unwrap_or_default(),
13201 functions: functions__.unwrap_or_default(),
13202 connections: connections__.unwrap_or_default(),
13203 subscriptions: subscriptions__.unwrap_or_default(),
13204 users: users__.unwrap_or_default(),
13205 session_params: session_params__,
13206 secrets: secrets__.unwrap_or_default(),
13207 cluster_resource: cluster_resource__,
13208 nodes: nodes__.unwrap_or_default(),
13209 hummock_version: hummock_version__,
13210 meta_backup_manifest_id: meta_backup_manifest_id__,
13211 hummock_write_limits: hummock_write_limits__,
13212 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
13213 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
13214 version: version__,
13215 })
13216 }
13217 }
13218 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
13219 }
13220}
13221impl serde::Serialize for meta_snapshot::SnapshotVersion {
13222 #[allow(deprecated)]
13223 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13224 where
13225 S: serde::Serializer,
13226 {
13227 use serde::ser::SerializeStruct;
13228 let mut len = 0;
13229 if self.catalog_version != 0 {
13230 len += 1;
13231 }
13232 if self.worker_node_version != 0 {
13233 len += 1;
13234 }
13235 if self.streaming_worker_slot_mapping_version != 0 {
13236 len += 1;
13237 }
13238 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
13239 if self.catalog_version != 0 {
13240 #[allow(clippy::needless_borrow)]
13241 #[allow(clippy::needless_borrows_for_generic_args)]
13242 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13243 }
13244 if self.worker_node_version != 0 {
13245 #[allow(clippy::needless_borrow)]
13246 #[allow(clippy::needless_borrows_for_generic_args)]
13247 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
13248 }
13249 if self.streaming_worker_slot_mapping_version != 0 {
13250 #[allow(clippy::needless_borrow)]
13251 #[allow(clippy::needless_borrows_for_generic_args)]
13252 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
13253 }
13254 struct_ser.end()
13255 }
13256}
13257impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
13258 #[allow(deprecated)]
13259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13260 where
13261 D: serde::Deserializer<'de>,
13262 {
13263 const FIELDS: &[&str] = &[
13264 "catalog_version",
13265 "catalogVersion",
13266 "worker_node_version",
13267 "workerNodeVersion",
13268 "streaming_worker_slot_mapping_version",
13269 "streamingWorkerSlotMappingVersion",
13270 ];
13271
13272 #[allow(clippy::enum_variant_names)]
13273 enum GeneratedField {
13274 CatalogVersion,
13275 WorkerNodeVersion,
13276 StreamingWorkerSlotMappingVersion,
13277 }
13278 impl<'de> serde::Deserialize<'de> for GeneratedField {
13279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13280 where
13281 D: serde::Deserializer<'de>,
13282 {
13283 struct GeneratedVisitor;
13284
13285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13286 type Value = GeneratedField;
13287
13288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13289 write!(formatter, "expected one of: {:?}", &FIELDS)
13290 }
13291
13292 #[allow(unused_variables)]
13293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13294 where
13295 E: serde::de::Error,
13296 {
13297 match value {
13298 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13299 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
13300 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
13301 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13302 }
13303 }
13304 }
13305 deserializer.deserialize_identifier(GeneratedVisitor)
13306 }
13307 }
13308 struct GeneratedVisitor;
13309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13310 type Value = meta_snapshot::SnapshotVersion;
13311
13312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13313 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
13314 }
13315
13316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
13317 where
13318 V: serde::de::MapAccess<'de>,
13319 {
13320 let mut catalog_version__ = None;
13321 let mut worker_node_version__ = None;
13322 let mut streaming_worker_slot_mapping_version__ = None;
13323 while let Some(k) = map_.next_key()? {
13324 match k {
13325 GeneratedField::CatalogVersion => {
13326 if catalog_version__.is_some() {
13327 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13328 }
13329 catalog_version__ =
13330 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13331 ;
13332 }
13333 GeneratedField::WorkerNodeVersion => {
13334 if worker_node_version__.is_some() {
13335 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
13336 }
13337 worker_node_version__ =
13338 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13339 ;
13340 }
13341 GeneratedField::StreamingWorkerSlotMappingVersion => {
13342 if streaming_worker_slot_mapping_version__.is_some() {
13343 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
13344 }
13345 streaming_worker_slot_mapping_version__ =
13346 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13347 ;
13348 }
13349 }
13350 }
13351 Ok(meta_snapshot::SnapshotVersion {
13352 catalog_version: catalog_version__.unwrap_or_default(),
13353 worker_node_version: worker_node_version__.unwrap_or_default(),
13354 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
13355 })
13356 }
13357 }
13358 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
13359 }
13360}
13361impl serde::Serialize for MigrationPlan {
13362 #[allow(deprecated)]
13363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13364 where
13365 S: serde::Serializer,
13366 {
13367 use serde::ser::SerializeStruct;
13368 let mut len = 0;
13369 if !self.worker_slot_migration_plan.is_empty() {
13370 len += 1;
13371 }
13372 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
13373 if !self.worker_slot_migration_plan.is_empty() {
13374 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
13375 .map(|(k, v)| (k, v.to_string())).collect();
13376 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
13377 }
13378 struct_ser.end()
13379 }
13380}
13381impl<'de> serde::Deserialize<'de> for MigrationPlan {
13382 #[allow(deprecated)]
13383 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13384 where
13385 D: serde::Deserializer<'de>,
13386 {
13387 const FIELDS: &[&str] = &[
13388 "worker_slot_migration_plan",
13389 "workerSlotMigrationPlan",
13390 ];
13391
13392 #[allow(clippy::enum_variant_names)]
13393 enum GeneratedField {
13394 WorkerSlotMigrationPlan,
13395 }
13396 impl<'de> serde::Deserialize<'de> for GeneratedField {
13397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13398 where
13399 D: serde::Deserializer<'de>,
13400 {
13401 struct GeneratedVisitor;
13402
13403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13404 type Value = GeneratedField;
13405
13406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13407 write!(formatter, "expected one of: {:?}", &FIELDS)
13408 }
13409
13410 #[allow(unused_variables)]
13411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13412 where
13413 E: serde::de::Error,
13414 {
13415 match value {
13416 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
13417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13418 }
13419 }
13420 }
13421 deserializer.deserialize_identifier(GeneratedVisitor)
13422 }
13423 }
13424 struct GeneratedVisitor;
13425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13426 type Value = MigrationPlan;
13427
13428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13429 formatter.write_str("struct meta.MigrationPlan")
13430 }
13431
13432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
13433 where
13434 V: serde::de::MapAccess<'de>,
13435 {
13436 let mut worker_slot_migration_plan__ = None;
13437 while let Some(k) = map_.next_key()? {
13438 match k {
13439 GeneratedField::WorkerSlotMigrationPlan => {
13440 if worker_slot_migration_plan__.is_some() {
13441 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
13442 }
13443 worker_slot_migration_plan__ = Some(
13444 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
13445 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
13446 );
13447 }
13448 }
13449 }
13450 Ok(MigrationPlan {
13451 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
13452 })
13453 }
13454 }
13455 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
13456 }
13457}
13458impl serde::Serialize for Object {
13459 #[allow(deprecated)]
13460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13461 where
13462 S: serde::Serializer,
13463 {
13464 use serde::ser::SerializeStruct;
13465 let mut len = 0;
13466 if self.object_info.is_some() {
13467 len += 1;
13468 }
13469 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
13470 if let Some(v) = self.object_info.as_ref() {
13471 match v {
13472 object::ObjectInfo::Database(v) => {
13473 struct_ser.serialize_field("database", v)?;
13474 }
13475 object::ObjectInfo::Schema(v) => {
13476 struct_ser.serialize_field("schema", v)?;
13477 }
13478 object::ObjectInfo::Table(v) => {
13479 struct_ser.serialize_field("table", v)?;
13480 }
13481 object::ObjectInfo::Index(v) => {
13482 struct_ser.serialize_field("index", v)?;
13483 }
13484 object::ObjectInfo::Source(v) => {
13485 struct_ser.serialize_field("source", v)?;
13486 }
13487 object::ObjectInfo::Sink(v) => {
13488 struct_ser.serialize_field("sink", v)?;
13489 }
13490 object::ObjectInfo::View(v) => {
13491 struct_ser.serialize_field("view", v)?;
13492 }
13493 object::ObjectInfo::Function(v) => {
13494 struct_ser.serialize_field("function", v)?;
13495 }
13496 object::ObjectInfo::Connection(v) => {
13497 struct_ser.serialize_field("connection", v)?;
13498 }
13499 object::ObjectInfo::Subscription(v) => {
13500 struct_ser.serialize_field("subscription", v)?;
13501 }
13502 object::ObjectInfo::Secret(v) => {
13503 struct_ser.serialize_field("secret", v)?;
13504 }
13505 }
13506 }
13507 struct_ser.end()
13508 }
13509}
13510impl<'de> serde::Deserialize<'de> for Object {
13511 #[allow(deprecated)]
13512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13513 where
13514 D: serde::Deserializer<'de>,
13515 {
13516 const FIELDS: &[&str] = &[
13517 "database",
13518 "schema",
13519 "table",
13520 "index",
13521 "source",
13522 "sink",
13523 "view",
13524 "function",
13525 "connection",
13526 "subscription",
13527 "secret",
13528 ];
13529
13530 #[allow(clippy::enum_variant_names)]
13531 enum GeneratedField {
13532 Database,
13533 Schema,
13534 Table,
13535 Index,
13536 Source,
13537 Sink,
13538 View,
13539 Function,
13540 Connection,
13541 Subscription,
13542 Secret,
13543 }
13544 impl<'de> serde::Deserialize<'de> for GeneratedField {
13545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13546 where
13547 D: serde::Deserializer<'de>,
13548 {
13549 struct GeneratedVisitor;
13550
13551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13552 type Value = GeneratedField;
13553
13554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13555 write!(formatter, "expected one of: {:?}", &FIELDS)
13556 }
13557
13558 #[allow(unused_variables)]
13559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13560 where
13561 E: serde::de::Error,
13562 {
13563 match value {
13564 "database" => Ok(GeneratedField::Database),
13565 "schema" => Ok(GeneratedField::Schema),
13566 "table" => Ok(GeneratedField::Table),
13567 "index" => Ok(GeneratedField::Index),
13568 "source" => Ok(GeneratedField::Source),
13569 "sink" => Ok(GeneratedField::Sink),
13570 "view" => Ok(GeneratedField::View),
13571 "function" => Ok(GeneratedField::Function),
13572 "connection" => Ok(GeneratedField::Connection),
13573 "subscription" => Ok(GeneratedField::Subscription),
13574 "secret" => Ok(GeneratedField::Secret),
13575 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13576 }
13577 }
13578 }
13579 deserializer.deserialize_identifier(GeneratedVisitor)
13580 }
13581 }
13582 struct GeneratedVisitor;
13583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13584 type Value = Object;
13585
13586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13587 formatter.write_str("struct meta.Object")
13588 }
13589
13590 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
13591 where
13592 V: serde::de::MapAccess<'de>,
13593 {
13594 let mut object_info__ = None;
13595 while let Some(k) = map_.next_key()? {
13596 match k {
13597 GeneratedField::Database => {
13598 if object_info__.is_some() {
13599 return Err(serde::de::Error::duplicate_field("database"));
13600 }
13601 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
13602;
13603 }
13604 GeneratedField::Schema => {
13605 if object_info__.is_some() {
13606 return Err(serde::de::Error::duplicate_field("schema"));
13607 }
13608 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
13609;
13610 }
13611 GeneratedField::Table => {
13612 if object_info__.is_some() {
13613 return Err(serde::de::Error::duplicate_field("table"));
13614 }
13615 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
13616;
13617 }
13618 GeneratedField::Index => {
13619 if object_info__.is_some() {
13620 return Err(serde::de::Error::duplicate_field("index"));
13621 }
13622 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
13623;
13624 }
13625 GeneratedField::Source => {
13626 if object_info__.is_some() {
13627 return Err(serde::de::Error::duplicate_field("source"));
13628 }
13629 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
13630;
13631 }
13632 GeneratedField::Sink => {
13633 if object_info__.is_some() {
13634 return Err(serde::de::Error::duplicate_field("sink"));
13635 }
13636 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
13637;
13638 }
13639 GeneratedField::View => {
13640 if object_info__.is_some() {
13641 return Err(serde::de::Error::duplicate_field("view"));
13642 }
13643 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
13644;
13645 }
13646 GeneratedField::Function => {
13647 if object_info__.is_some() {
13648 return Err(serde::de::Error::duplicate_field("function"));
13649 }
13650 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
13651;
13652 }
13653 GeneratedField::Connection => {
13654 if object_info__.is_some() {
13655 return Err(serde::de::Error::duplicate_field("connection"));
13656 }
13657 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
13658;
13659 }
13660 GeneratedField::Subscription => {
13661 if object_info__.is_some() {
13662 return Err(serde::de::Error::duplicate_field("subscription"));
13663 }
13664 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
13665;
13666 }
13667 GeneratedField::Secret => {
13668 if object_info__.is_some() {
13669 return Err(serde::de::Error::duplicate_field("secret"));
13670 }
13671 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
13672;
13673 }
13674 }
13675 }
13676 Ok(Object {
13677 object_info: object_info__,
13678 })
13679 }
13680 }
13681 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
13682 }
13683}
13684impl serde::Serialize for ObjectGroup {
13685 #[allow(deprecated)]
13686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13687 where
13688 S: serde::Serializer,
13689 {
13690 use serde::ser::SerializeStruct;
13691 let mut len = 0;
13692 if !self.objects.is_empty() {
13693 len += 1;
13694 }
13695 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
13696 if !self.objects.is_empty() {
13697 struct_ser.serialize_field("objects", &self.objects)?;
13698 }
13699 struct_ser.end()
13700 }
13701}
13702impl<'de> serde::Deserialize<'de> for ObjectGroup {
13703 #[allow(deprecated)]
13704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13705 where
13706 D: serde::Deserializer<'de>,
13707 {
13708 const FIELDS: &[&str] = &[
13709 "objects",
13710 ];
13711
13712 #[allow(clippy::enum_variant_names)]
13713 enum GeneratedField {
13714 Objects,
13715 }
13716 impl<'de> serde::Deserialize<'de> for GeneratedField {
13717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13718 where
13719 D: serde::Deserializer<'de>,
13720 {
13721 struct GeneratedVisitor;
13722
13723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13724 type Value = GeneratedField;
13725
13726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13727 write!(formatter, "expected one of: {:?}", &FIELDS)
13728 }
13729
13730 #[allow(unused_variables)]
13731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13732 where
13733 E: serde::de::Error,
13734 {
13735 match value {
13736 "objects" => Ok(GeneratedField::Objects),
13737 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13738 }
13739 }
13740 }
13741 deserializer.deserialize_identifier(GeneratedVisitor)
13742 }
13743 }
13744 struct GeneratedVisitor;
13745 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13746 type Value = ObjectGroup;
13747
13748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13749 formatter.write_str("struct meta.ObjectGroup")
13750 }
13751
13752 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
13753 where
13754 V: serde::de::MapAccess<'de>,
13755 {
13756 let mut objects__ = None;
13757 while let Some(k) = map_.next_key()? {
13758 match k {
13759 GeneratedField::Objects => {
13760 if objects__.is_some() {
13761 return Err(serde::de::Error::duplicate_field("objects"));
13762 }
13763 objects__ = Some(map_.next_value()?);
13764 }
13765 }
13766 }
13767 Ok(ObjectGroup {
13768 objects: objects__.unwrap_or_default(),
13769 })
13770 }
13771 }
13772 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
13773 }
13774}
13775impl serde::Serialize for PauseRequest {
13776 #[allow(deprecated)]
13777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13778 where
13779 S: serde::Serializer,
13780 {
13781 use serde::ser::SerializeStruct;
13782 let len = 0;
13783 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
13784 struct_ser.end()
13785 }
13786}
13787impl<'de> serde::Deserialize<'de> for PauseRequest {
13788 #[allow(deprecated)]
13789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13790 where
13791 D: serde::Deserializer<'de>,
13792 {
13793 const FIELDS: &[&str] = &[
13794 ];
13795
13796 #[allow(clippy::enum_variant_names)]
13797 enum GeneratedField {
13798 }
13799 impl<'de> serde::Deserialize<'de> for GeneratedField {
13800 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13801 where
13802 D: serde::Deserializer<'de>,
13803 {
13804 struct GeneratedVisitor;
13805
13806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13807 type Value = GeneratedField;
13808
13809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13810 write!(formatter, "expected one of: {:?}", &FIELDS)
13811 }
13812
13813 #[allow(unused_variables)]
13814 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13815 where
13816 E: serde::de::Error,
13817 {
13818 Err(serde::de::Error::unknown_field(value, FIELDS))
13819 }
13820 }
13821 deserializer.deserialize_identifier(GeneratedVisitor)
13822 }
13823 }
13824 struct GeneratedVisitor;
13825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13826 type Value = PauseRequest;
13827
13828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13829 formatter.write_str("struct meta.PauseRequest")
13830 }
13831
13832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
13833 where
13834 V: serde::de::MapAccess<'de>,
13835 {
13836 while map_.next_key::<GeneratedField>()?.is_some() {
13837 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13838 }
13839 Ok(PauseRequest {
13840 })
13841 }
13842 }
13843 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
13844 }
13845}
13846impl serde::Serialize for PauseResponse {
13847 #[allow(deprecated)]
13848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13849 where
13850 S: serde::Serializer,
13851 {
13852 use serde::ser::SerializeStruct;
13853 let len = 0;
13854 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
13855 struct_ser.end()
13856 }
13857}
13858impl<'de> serde::Deserialize<'de> for PauseResponse {
13859 #[allow(deprecated)]
13860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13861 where
13862 D: serde::Deserializer<'de>,
13863 {
13864 const FIELDS: &[&str] = &[
13865 ];
13866
13867 #[allow(clippy::enum_variant_names)]
13868 enum GeneratedField {
13869 }
13870 impl<'de> serde::Deserialize<'de> for GeneratedField {
13871 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13872 where
13873 D: serde::Deserializer<'de>,
13874 {
13875 struct GeneratedVisitor;
13876
13877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13878 type Value = GeneratedField;
13879
13880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13881 write!(formatter, "expected one of: {:?}", &FIELDS)
13882 }
13883
13884 #[allow(unused_variables)]
13885 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13886 where
13887 E: serde::de::Error,
13888 {
13889 Err(serde::de::Error::unknown_field(value, FIELDS))
13890 }
13891 }
13892 deserializer.deserialize_identifier(GeneratedVisitor)
13893 }
13894 }
13895 struct GeneratedVisitor;
13896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13897 type Value = PauseResponse;
13898
13899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13900 formatter.write_str("struct meta.PauseResponse")
13901 }
13902
13903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
13904 where
13905 V: serde::de::MapAccess<'de>,
13906 {
13907 while map_.next_key::<GeneratedField>()?.is_some() {
13908 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13909 }
13910 Ok(PauseResponse {
13911 })
13912 }
13913 }
13914 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
13915 }
13916}
13917impl serde::Serialize for RecoverRequest {
13918 #[allow(deprecated)]
13919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13920 where
13921 S: serde::Serializer,
13922 {
13923 use serde::ser::SerializeStruct;
13924 let len = 0;
13925 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
13926 struct_ser.end()
13927 }
13928}
13929impl<'de> serde::Deserialize<'de> for RecoverRequest {
13930 #[allow(deprecated)]
13931 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13932 where
13933 D: serde::Deserializer<'de>,
13934 {
13935 const FIELDS: &[&str] = &[
13936 ];
13937
13938 #[allow(clippy::enum_variant_names)]
13939 enum GeneratedField {
13940 }
13941 impl<'de> serde::Deserialize<'de> for GeneratedField {
13942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13943 where
13944 D: serde::Deserializer<'de>,
13945 {
13946 struct GeneratedVisitor;
13947
13948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13949 type Value = GeneratedField;
13950
13951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13952 write!(formatter, "expected one of: {:?}", &FIELDS)
13953 }
13954
13955 #[allow(unused_variables)]
13956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13957 where
13958 E: serde::de::Error,
13959 {
13960 Err(serde::de::Error::unknown_field(value, FIELDS))
13961 }
13962 }
13963 deserializer.deserialize_identifier(GeneratedVisitor)
13964 }
13965 }
13966 struct GeneratedVisitor;
13967 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13968 type Value = RecoverRequest;
13969
13970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13971 formatter.write_str("struct meta.RecoverRequest")
13972 }
13973
13974 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
13975 where
13976 V: serde::de::MapAccess<'de>,
13977 {
13978 while map_.next_key::<GeneratedField>()?.is_some() {
13979 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13980 }
13981 Ok(RecoverRequest {
13982 })
13983 }
13984 }
13985 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
13986 }
13987}
13988impl serde::Serialize for RecoverResponse {
13989 #[allow(deprecated)]
13990 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13991 where
13992 S: serde::Serializer,
13993 {
13994 use serde::ser::SerializeStruct;
13995 let len = 0;
13996 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
13997 struct_ser.end()
13998 }
13999}
14000impl<'de> serde::Deserialize<'de> for RecoverResponse {
14001 #[allow(deprecated)]
14002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14003 where
14004 D: serde::Deserializer<'de>,
14005 {
14006 const FIELDS: &[&str] = &[
14007 ];
14008
14009 #[allow(clippy::enum_variant_names)]
14010 enum GeneratedField {
14011 }
14012 impl<'de> serde::Deserialize<'de> for GeneratedField {
14013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14014 where
14015 D: serde::Deserializer<'de>,
14016 {
14017 struct GeneratedVisitor;
14018
14019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14020 type Value = GeneratedField;
14021
14022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14023 write!(formatter, "expected one of: {:?}", &FIELDS)
14024 }
14025
14026 #[allow(unused_variables)]
14027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14028 where
14029 E: serde::de::Error,
14030 {
14031 Err(serde::de::Error::unknown_field(value, FIELDS))
14032 }
14033 }
14034 deserializer.deserialize_identifier(GeneratedVisitor)
14035 }
14036 }
14037 struct GeneratedVisitor;
14038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14039 type Value = RecoverResponse;
14040
14041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14042 formatter.write_str("struct meta.RecoverResponse")
14043 }
14044
14045 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
14046 where
14047 V: serde::de::MapAccess<'de>,
14048 {
14049 while map_.next_key::<GeneratedField>()?.is_some() {
14050 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14051 }
14052 Ok(RecoverResponse {
14053 })
14054 }
14055 }
14056 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
14057 }
14058}
14059impl serde::Serialize for Recovery {
14060 #[allow(deprecated)]
14061 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14062 where
14063 S: serde::Serializer,
14064 {
14065 use serde::ser::SerializeStruct;
14066 let len = 0;
14067 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
14068 struct_ser.end()
14069 }
14070}
14071impl<'de> serde::Deserialize<'de> for Recovery {
14072 #[allow(deprecated)]
14073 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14074 where
14075 D: serde::Deserializer<'de>,
14076 {
14077 const FIELDS: &[&str] = &[
14078 ];
14079
14080 #[allow(clippy::enum_variant_names)]
14081 enum GeneratedField {
14082 }
14083 impl<'de> serde::Deserialize<'de> for GeneratedField {
14084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14085 where
14086 D: serde::Deserializer<'de>,
14087 {
14088 struct GeneratedVisitor;
14089
14090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14091 type Value = GeneratedField;
14092
14093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14094 write!(formatter, "expected one of: {:?}", &FIELDS)
14095 }
14096
14097 #[allow(unused_variables)]
14098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14099 where
14100 E: serde::de::Error,
14101 {
14102 Err(serde::de::Error::unknown_field(value, FIELDS))
14103 }
14104 }
14105 deserializer.deserialize_identifier(GeneratedVisitor)
14106 }
14107 }
14108 struct GeneratedVisitor;
14109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14110 type Value = Recovery;
14111
14112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14113 formatter.write_str("struct meta.Recovery")
14114 }
14115
14116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
14117 where
14118 V: serde::de::MapAccess<'de>,
14119 {
14120 while map_.next_key::<GeneratedField>()?.is_some() {
14121 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14122 }
14123 Ok(Recovery {
14124 })
14125 }
14126 }
14127 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
14128 }
14129}
14130impl serde::Serialize for RecoveryStatus {
14131 #[allow(deprecated)]
14132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14133 where
14134 S: serde::Serializer,
14135 {
14136 let variant = match self {
14137 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
14138 Self::StatusStarting => "STATUS_STARTING",
14139 Self::StatusRecovering => "STATUS_RECOVERING",
14140 Self::StatusRunning => "STATUS_RUNNING",
14141 };
14142 serializer.serialize_str(variant)
14143 }
14144}
14145impl<'de> serde::Deserialize<'de> for RecoveryStatus {
14146 #[allow(deprecated)]
14147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14148 where
14149 D: serde::Deserializer<'de>,
14150 {
14151 const FIELDS: &[&str] = &[
14152 "STATUS_UNSPECIFIED",
14153 "STATUS_STARTING",
14154 "STATUS_RECOVERING",
14155 "STATUS_RUNNING",
14156 ];
14157
14158 struct GeneratedVisitor;
14159
14160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14161 type Value = RecoveryStatus;
14162
14163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14164 write!(formatter, "expected one of: {:?}", &FIELDS)
14165 }
14166
14167 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14168 where
14169 E: serde::de::Error,
14170 {
14171 i32::try_from(v)
14172 .ok()
14173 .and_then(|x| x.try_into().ok())
14174 .ok_or_else(|| {
14175 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14176 })
14177 }
14178
14179 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14180 where
14181 E: serde::de::Error,
14182 {
14183 i32::try_from(v)
14184 .ok()
14185 .and_then(|x| x.try_into().ok())
14186 .ok_or_else(|| {
14187 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14188 })
14189 }
14190
14191 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14192 where
14193 E: serde::de::Error,
14194 {
14195 match value {
14196 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
14197 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
14198 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
14199 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
14200 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14201 }
14202 }
14203 }
14204 deserializer.deserialize_any(GeneratedVisitor)
14205 }
14206}
14207impl serde::Serialize for RefreshRequest {
14208 #[allow(deprecated)]
14209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14210 where
14211 S: serde::Serializer,
14212 {
14213 use serde::ser::SerializeStruct;
14214 let mut len = 0;
14215 if self.table_id != 0 {
14216 len += 1;
14217 }
14218 if self.associated_source_id != 0 {
14219 len += 1;
14220 }
14221 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
14222 if self.table_id != 0 {
14223 struct_ser.serialize_field("tableId", &self.table_id)?;
14224 }
14225 if self.associated_source_id != 0 {
14226 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
14227 }
14228 struct_ser.end()
14229 }
14230}
14231impl<'de> serde::Deserialize<'de> for RefreshRequest {
14232 #[allow(deprecated)]
14233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14234 where
14235 D: serde::Deserializer<'de>,
14236 {
14237 const FIELDS: &[&str] = &[
14238 "table_id",
14239 "tableId",
14240 "associated_source_id",
14241 "associatedSourceId",
14242 ];
14243
14244 #[allow(clippy::enum_variant_names)]
14245 enum GeneratedField {
14246 TableId,
14247 AssociatedSourceId,
14248 }
14249 impl<'de> serde::Deserialize<'de> for GeneratedField {
14250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14251 where
14252 D: serde::Deserializer<'de>,
14253 {
14254 struct GeneratedVisitor;
14255
14256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14257 type Value = GeneratedField;
14258
14259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14260 write!(formatter, "expected one of: {:?}", &FIELDS)
14261 }
14262
14263 #[allow(unused_variables)]
14264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14265 where
14266 E: serde::de::Error,
14267 {
14268 match value {
14269 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14270 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
14271 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14272 }
14273 }
14274 }
14275 deserializer.deserialize_identifier(GeneratedVisitor)
14276 }
14277 }
14278 struct GeneratedVisitor;
14279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14280 type Value = RefreshRequest;
14281
14282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14283 formatter.write_str("struct meta.RefreshRequest")
14284 }
14285
14286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
14287 where
14288 V: serde::de::MapAccess<'de>,
14289 {
14290 let mut table_id__ = None;
14291 let mut associated_source_id__ = None;
14292 while let Some(k) = map_.next_key()? {
14293 match k {
14294 GeneratedField::TableId => {
14295 if table_id__.is_some() {
14296 return Err(serde::de::Error::duplicate_field("tableId"));
14297 }
14298 table_id__ =
14299 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14300 ;
14301 }
14302 GeneratedField::AssociatedSourceId => {
14303 if associated_source_id__.is_some() {
14304 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
14305 }
14306 associated_source_id__ =
14307 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14308 ;
14309 }
14310 }
14311 }
14312 Ok(RefreshRequest {
14313 table_id: table_id__.unwrap_or_default(),
14314 associated_source_id: associated_source_id__.unwrap_or_default(),
14315 })
14316 }
14317 }
14318 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
14319 }
14320}
14321impl serde::Serialize for RefreshResponse {
14322 #[allow(deprecated)]
14323 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14324 where
14325 S: serde::Serializer,
14326 {
14327 use serde::ser::SerializeStruct;
14328 let mut len = 0;
14329 if self.status.is_some() {
14330 len += 1;
14331 }
14332 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
14333 if let Some(v) = self.status.as_ref() {
14334 struct_ser.serialize_field("status", v)?;
14335 }
14336 struct_ser.end()
14337 }
14338}
14339impl<'de> serde::Deserialize<'de> for RefreshResponse {
14340 #[allow(deprecated)]
14341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14342 where
14343 D: serde::Deserializer<'de>,
14344 {
14345 const FIELDS: &[&str] = &[
14346 "status",
14347 ];
14348
14349 #[allow(clippy::enum_variant_names)]
14350 enum GeneratedField {
14351 Status,
14352 }
14353 impl<'de> serde::Deserialize<'de> for GeneratedField {
14354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14355 where
14356 D: serde::Deserializer<'de>,
14357 {
14358 struct GeneratedVisitor;
14359
14360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14361 type Value = GeneratedField;
14362
14363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14364 write!(formatter, "expected one of: {:?}", &FIELDS)
14365 }
14366
14367 #[allow(unused_variables)]
14368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14369 where
14370 E: serde::de::Error,
14371 {
14372 match value {
14373 "status" => Ok(GeneratedField::Status),
14374 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14375 }
14376 }
14377 }
14378 deserializer.deserialize_identifier(GeneratedVisitor)
14379 }
14380 }
14381 struct GeneratedVisitor;
14382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14383 type Value = RefreshResponse;
14384
14385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14386 formatter.write_str("struct meta.RefreshResponse")
14387 }
14388
14389 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
14390 where
14391 V: serde::de::MapAccess<'de>,
14392 {
14393 let mut status__ = None;
14394 while let Some(k) = map_.next_key()? {
14395 match k {
14396 GeneratedField::Status => {
14397 if status__.is_some() {
14398 return Err(serde::de::Error::duplicate_field("status"));
14399 }
14400 status__ = map_.next_value()?;
14401 }
14402 }
14403 }
14404 Ok(RefreshResponse {
14405 status: status__,
14406 })
14407 }
14408 }
14409 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
14410 }
14411}
14412impl serde::Serialize for RelationIdInfos {
14413 #[allow(deprecated)]
14414 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14415 where
14416 S: serde::Serializer,
14417 {
14418 use serde::ser::SerializeStruct;
14419 let mut len = 0;
14420 if !self.map.is_empty() {
14421 len += 1;
14422 }
14423 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
14424 if !self.map.is_empty() {
14425 struct_ser.serialize_field("map", &self.map)?;
14426 }
14427 struct_ser.end()
14428 }
14429}
14430impl<'de> serde::Deserialize<'de> for RelationIdInfos {
14431 #[allow(deprecated)]
14432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14433 where
14434 D: serde::Deserializer<'de>,
14435 {
14436 const FIELDS: &[&str] = &[
14437 "map",
14438 ];
14439
14440 #[allow(clippy::enum_variant_names)]
14441 enum GeneratedField {
14442 Map,
14443 }
14444 impl<'de> serde::Deserialize<'de> for GeneratedField {
14445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14446 where
14447 D: serde::Deserializer<'de>,
14448 {
14449 struct GeneratedVisitor;
14450
14451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14452 type Value = GeneratedField;
14453
14454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14455 write!(formatter, "expected one of: {:?}", &FIELDS)
14456 }
14457
14458 #[allow(unused_variables)]
14459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14460 where
14461 E: serde::de::Error,
14462 {
14463 match value {
14464 "map" => Ok(GeneratedField::Map),
14465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14466 }
14467 }
14468 }
14469 deserializer.deserialize_identifier(GeneratedVisitor)
14470 }
14471 }
14472 struct GeneratedVisitor;
14473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14474 type Value = RelationIdInfos;
14475
14476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14477 formatter.write_str("struct meta.RelationIdInfos")
14478 }
14479
14480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
14481 where
14482 V: serde::de::MapAccess<'de>,
14483 {
14484 let mut map__ = None;
14485 while let Some(k) = map_.next_key()? {
14486 match k {
14487 GeneratedField::Map => {
14488 if map__.is_some() {
14489 return Err(serde::de::Error::duplicate_field("map"));
14490 }
14491 map__ = Some(
14492 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14493 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14494 );
14495 }
14496 }
14497 }
14498 Ok(RelationIdInfos {
14499 map: map__.unwrap_or_default(),
14500 })
14501 }
14502 }
14503 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
14504 }
14505}
14506impl serde::Serialize for RescheduleRequest {
14507 #[allow(deprecated)]
14508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14509 where
14510 S: serde::Serializer,
14511 {
14512 use serde::ser::SerializeStruct;
14513 let mut len = 0;
14514 if self.revision != 0 {
14515 len += 1;
14516 }
14517 if self.resolve_no_shuffle_upstream {
14518 len += 1;
14519 }
14520 if !self.worker_reschedules.is_empty() {
14521 len += 1;
14522 }
14523 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
14524 if self.revision != 0 {
14525 #[allow(clippy::needless_borrow)]
14526 #[allow(clippy::needless_borrows_for_generic_args)]
14527 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
14528 }
14529 if self.resolve_no_shuffle_upstream {
14530 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
14531 }
14532 if !self.worker_reschedules.is_empty() {
14533 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
14534 }
14535 struct_ser.end()
14536 }
14537}
14538impl<'de> serde::Deserialize<'de> for RescheduleRequest {
14539 #[allow(deprecated)]
14540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14541 where
14542 D: serde::Deserializer<'de>,
14543 {
14544 const FIELDS: &[&str] = &[
14545 "revision",
14546 "resolve_no_shuffle_upstream",
14547 "resolveNoShuffleUpstream",
14548 "worker_reschedules",
14549 "workerReschedules",
14550 ];
14551
14552 #[allow(clippy::enum_variant_names)]
14553 enum GeneratedField {
14554 Revision,
14555 ResolveNoShuffleUpstream,
14556 WorkerReschedules,
14557 }
14558 impl<'de> serde::Deserialize<'de> for GeneratedField {
14559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14560 where
14561 D: serde::Deserializer<'de>,
14562 {
14563 struct GeneratedVisitor;
14564
14565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14566 type Value = GeneratedField;
14567
14568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14569 write!(formatter, "expected one of: {:?}", &FIELDS)
14570 }
14571
14572 #[allow(unused_variables)]
14573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14574 where
14575 E: serde::de::Error,
14576 {
14577 match value {
14578 "revision" => Ok(GeneratedField::Revision),
14579 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
14580 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
14581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14582 }
14583 }
14584 }
14585 deserializer.deserialize_identifier(GeneratedVisitor)
14586 }
14587 }
14588 struct GeneratedVisitor;
14589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14590 type Value = RescheduleRequest;
14591
14592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14593 formatter.write_str("struct meta.RescheduleRequest")
14594 }
14595
14596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
14597 where
14598 V: serde::de::MapAccess<'de>,
14599 {
14600 let mut revision__ = None;
14601 let mut resolve_no_shuffle_upstream__ = None;
14602 let mut worker_reschedules__ = None;
14603 while let Some(k) = map_.next_key()? {
14604 match k {
14605 GeneratedField::Revision => {
14606 if revision__.is_some() {
14607 return Err(serde::de::Error::duplicate_field("revision"));
14608 }
14609 revision__ =
14610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14611 ;
14612 }
14613 GeneratedField::ResolveNoShuffleUpstream => {
14614 if resolve_no_shuffle_upstream__.is_some() {
14615 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
14616 }
14617 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
14618 }
14619 GeneratedField::WorkerReschedules => {
14620 if worker_reschedules__.is_some() {
14621 return Err(serde::de::Error::duplicate_field("workerReschedules"));
14622 }
14623 worker_reschedules__ = Some(
14624 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14625 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14626 );
14627 }
14628 }
14629 }
14630 Ok(RescheduleRequest {
14631 revision: revision__.unwrap_or_default(),
14632 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
14633 worker_reschedules: worker_reschedules__.unwrap_or_default(),
14634 })
14635 }
14636 }
14637 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
14638 }
14639}
14640impl serde::Serialize for RescheduleResponse {
14641 #[allow(deprecated)]
14642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14643 where
14644 S: serde::Serializer,
14645 {
14646 use serde::ser::SerializeStruct;
14647 let mut len = 0;
14648 if self.success {
14649 len += 1;
14650 }
14651 if self.revision != 0 {
14652 len += 1;
14653 }
14654 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
14655 if self.success {
14656 struct_ser.serialize_field("success", &self.success)?;
14657 }
14658 if self.revision != 0 {
14659 #[allow(clippy::needless_borrow)]
14660 #[allow(clippy::needless_borrows_for_generic_args)]
14661 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
14662 }
14663 struct_ser.end()
14664 }
14665}
14666impl<'de> serde::Deserialize<'de> for RescheduleResponse {
14667 #[allow(deprecated)]
14668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14669 where
14670 D: serde::Deserializer<'de>,
14671 {
14672 const FIELDS: &[&str] = &[
14673 "success",
14674 "revision",
14675 ];
14676
14677 #[allow(clippy::enum_variant_names)]
14678 enum GeneratedField {
14679 Success,
14680 Revision,
14681 }
14682 impl<'de> serde::Deserialize<'de> for GeneratedField {
14683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14684 where
14685 D: serde::Deserializer<'de>,
14686 {
14687 struct GeneratedVisitor;
14688
14689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14690 type Value = GeneratedField;
14691
14692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14693 write!(formatter, "expected one of: {:?}", &FIELDS)
14694 }
14695
14696 #[allow(unused_variables)]
14697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14698 where
14699 E: serde::de::Error,
14700 {
14701 match value {
14702 "success" => Ok(GeneratedField::Success),
14703 "revision" => Ok(GeneratedField::Revision),
14704 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14705 }
14706 }
14707 }
14708 deserializer.deserialize_identifier(GeneratedVisitor)
14709 }
14710 }
14711 struct GeneratedVisitor;
14712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14713 type Value = RescheduleResponse;
14714
14715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14716 formatter.write_str("struct meta.RescheduleResponse")
14717 }
14718
14719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
14720 where
14721 V: serde::de::MapAccess<'de>,
14722 {
14723 let mut success__ = None;
14724 let mut revision__ = None;
14725 while let Some(k) = map_.next_key()? {
14726 match k {
14727 GeneratedField::Success => {
14728 if success__.is_some() {
14729 return Err(serde::de::Error::duplicate_field("success"));
14730 }
14731 success__ = Some(map_.next_value()?);
14732 }
14733 GeneratedField::Revision => {
14734 if revision__.is_some() {
14735 return Err(serde::de::Error::duplicate_field("revision"));
14736 }
14737 revision__ =
14738 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14739 ;
14740 }
14741 }
14742 }
14743 Ok(RescheduleResponse {
14744 success: success__.unwrap_or_default(),
14745 revision: revision__.unwrap_or_default(),
14746 })
14747 }
14748 }
14749 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
14750 }
14751}
14752impl serde::Serialize for ResumeRequest {
14753 #[allow(deprecated)]
14754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14755 where
14756 S: serde::Serializer,
14757 {
14758 use serde::ser::SerializeStruct;
14759 let len = 0;
14760 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
14761 struct_ser.end()
14762 }
14763}
14764impl<'de> serde::Deserialize<'de> for ResumeRequest {
14765 #[allow(deprecated)]
14766 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14767 where
14768 D: serde::Deserializer<'de>,
14769 {
14770 const FIELDS: &[&str] = &[
14771 ];
14772
14773 #[allow(clippy::enum_variant_names)]
14774 enum GeneratedField {
14775 }
14776 impl<'de> serde::Deserialize<'de> for GeneratedField {
14777 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14778 where
14779 D: serde::Deserializer<'de>,
14780 {
14781 struct GeneratedVisitor;
14782
14783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14784 type Value = GeneratedField;
14785
14786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14787 write!(formatter, "expected one of: {:?}", &FIELDS)
14788 }
14789
14790 #[allow(unused_variables)]
14791 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14792 where
14793 E: serde::de::Error,
14794 {
14795 Err(serde::de::Error::unknown_field(value, FIELDS))
14796 }
14797 }
14798 deserializer.deserialize_identifier(GeneratedVisitor)
14799 }
14800 }
14801 struct GeneratedVisitor;
14802 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14803 type Value = ResumeRequest;
14804
14805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14806 formatter.write_str("struct meta.ResumeRequest")
14807 }
14808
14809 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
14810 where
14811 V: serde::de::MapAccess<'de>,
14812 {
14813 while map_.next_key::<GeneratedField>()?.is_some() {
14814 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14815 }
14816 Ok(ResumeRequest {
14817 })
14818 }
14819 }
14820 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
14821 }
14822}
14823impl serde::Serialize for ResumeResponse {
14824 #[allow(deprecated)]
14825 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14826 where
14827 S: serde::Serializer,
14828 {
14829 use serde::ser::SerializeStruct;
14830 let len = 0;
14831 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
14832 struct_ser.end()
14833 }
14834}
14835impl<'de> serde::Deserialize<'de> for ResumeResponse {
14836 #[allow(deprecated)]
14837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14838 where
14839 D: serde::Deserializer<'de>,
14840 {
14841 const FIELDS: &[&str] = &[
14842 ];
14843
14844 #[allow(clippy::enum_variant_names)]
14845 enum GeneratedField {
14846 }
14847 impl<'de> serde::Deserialize<'de> for GeneratedField {
14848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14849 where
14850 D: serde::Deserializer<'de>,
14851 {
14852 struct GeneratedVisitor;
14853
14854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14855 type Value = GeneratedField;
14856
14857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14858 write!(formatter, "expected one of: {:?}", &FIELDS)
14859 }
14860
14861 #[allow(unused_variables)]
14862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14863 where
14864 E: serde::de::Error,
14865 {
14866 Err(serde::de::Error::unknown_field(value, FIELDS))
14867 }
14868 }
14869 deserializer.deserialize_identifier(GeneratedVisitor)
14870 }
14871 }
14872 struct GeneratedVisitor;
14873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14874 type Value = ResumeResponse;
14875
14876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14877 formatter.write_str("struct meta.ResumeResponse")
14878 }
14879
14880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
14881 where
14882 V: serde::de::MapAccess<'de>,
14883 {
14884 while map_.next_key::<GeneratedField>()?.is_some() {
14885 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14886 }
14887 Ok(ResumeResponse {
14888 })
14889 }
14890 }
14891 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
14892 }
14893}
14894impl serde::Serialize for SetSessionParamRequest {
14895 #[allow(deprecated)]
14896 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14897 where
14898 S: serde::Serializer,
14899 {
14900 use serde::ser::SerializeStruct;
14901 let mut len = 0;
14902 if !self.param.is_empty() {
14903 len += 1;
14904 }
14905 if self.value.is_some() {
14906 len += 1;
14907 }
14908 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
14909 if !self.param.is_empty() {
14910 struct_ser.serialize_field("param", &self.param)?;
14911 }
14912 if let Some(v) = self.value.as_ref() {
14913 struct_ser.serialize_field("value", v)?;
14914 }
14915 struct_ser.end()
14916 }
14917}
14918impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
14919 #[allow(deprecated)]
14920 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14921 where
14922 D: serde::Deserializer<'de>,
14923 {
14924 const FIELDS: &[&str] = &[
14925 "param",
14926 "value",
14927 ];
14928
14929 #[allow(clippy::enum_variant_names)]
14930 enum GeneratedField {
14931 Param,
14932 Value,
14933 }
14934 impl<'de> serde::Deserialize<'de> for GeneratedField {
14935 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14936 where
14937 D: serde::Deserializer<'de>,
14938 {
14939 struct GeneratedVisitor;
14940
14941 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14942 type Value = GeneratedField;
14943
14944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14945 write!(formatter, "expected one of: {:?}", &FIELDS)
14946 }
14947
14948 #[allow(unused_variables)]
14949 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14950 where
14951 E: serde::de::Error,
14952 {
14953 match value {
14954 "param" => Ok(GeneratedField::Param),
14955 "value" => Ok(GeneratedField::Value),
14956 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14957 }
14958 }
14959 }
14960 deserializer.deserialize_identifier(GeneratedVisitor)
14961 }
14962 }
14963 struct GeneratedVisitor;
14964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14965 type Value = SetSessionParamRequest;
14966
14967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14968 formatter.write_str("struct meta.SetSessionParamRequest")
14969 }
14970
14971 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
14972 where
14973 V: serde::de::MapAccess<'de>,
14974 {
14975 let mut param__ = None;
14976 let mut value__ = None;
14977 while let Some(k) = map_.next_key()? {
14978 match k {
14979 GeneratedField::Param => {
14980 if param__.is_some() {
14981 return Err(serde::de::Error::duplicate_field("param"));
14982 }
14983 param__ = Some(map_.next_value()?);
14984 }
14985 GeneratedField::Value => {
14986 if value__.is_some() {
14987 return Err(serde::de::Error::duplicate_field("value"));
14988 }
14989 value__ = map_.next_value()?;
14990 }
14991 }
14992 }
14993 Ok(SetSessionParamRequest {
14994 param: param__.unwrap_or_default(),
14995 value: value__,
14996 })
14997 }
14998 }
14999 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
15000 }
15001}
15002impl serde::Serialize for SetSessionParamResponse {
15003 #[allow(deprecated)]
15004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15005 where
15006 S: serde::Serializer,
15007 {
15008 use serde::ser::SerializeStruct;
15009 let mut len = 0;
15010 if !self.param.is_empty() {
15011 len += 1;
15012 }
15013 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
15014 if !self.param.is_empty() {
15015 struct_ser.serialize_field("param", &self.param)?;
15016 }
15017 struct_ser.end()
15018 }
15019}
15020impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
15021 #[allow(deprecated)]
15022 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15023 where
15024 D: serde::Deserializer<'de>,
15025 {
15026 const FIELDS: &[&str] = &[
15027 "param",
15028 ];
15029
15030 #[allow(clippy::enum_variant_names)]
15031 enum GeneratedField {
15032 Param,
15033 }
15034 impl<'de> serde::Deserialize<'de> for GeneratedField {
15035 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15036 where
15037 D: serde::Deserializer<'de>,
15038 {
15039 struct GeneratedVisitor;
15040
15041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15042 type Value = GeneratedField;
15043
15044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15045 write!(formatter, "expected one of: {:?}", &FIELDS)
15046 }
15047
15048 #[allow(unused_variables)]
15049 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15050 where
15051 E: serde::de::Error,
15052 {
15053 match value {
15054 "param" => Ok(GeneratedField::Param),
15055 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15056 }
15057 }
15058 }
15059 deserializer.deserialize_identifier(GeneratedVisitor)
15060 }
15061 }
15062 struct GeneratedVisitor;
15063 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15064 type Value = SetSessionParamResponse;
15065
15066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15067 formatter.write_str("struct meta.SetSessionParamResponse")
15068 }
15069
15070 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
15071 where
15072 V: serde::de::MapAccess<'de>,
15073 {
15074 let mut param__ = None;
15075 while let Some(k) = map_.next_key()? {
15076 match k {
15077 GeneratedField::Param => {
15078 if param__.is_some() {
15079 return Err(serde::de::Error::duplicate_field("param"));
15080 }
15081 param__ = Some(map_.next_value()?);
15082 }
15083 }
15084 }
15085 Ok(SetSessionParamResponse {
15086 param: param__.unwrap_or_default(),
15087 })
15088 }
15089 }
15090 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
15091 }
15092}
15093impl serde::Serialize for SetSyncLogStoreAlignedRequest {
15094 #[allow(deprecated)]
15095 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15096 where
15097 S: serde::Serializer,
15098 {
15099 use serde::ser::SerializeStruct;
15100 let mut len = 0;
15101 if self.job_id != 0 {
15102 len += 1;
15103 }
15104 if self.aligned {
15105 len += 1;
15106 }
15107 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
15108 if self.job_id != 0 {
15109 struct_ser.serialize_field("jobId", &self.job_id)?;
15110 }
15111 if self.aligned {
15112 struct_ser.serialize_field("aligned", &self.aligned)?;
15113 }
15114 struct_ser.end()
15115 }
15116}
15117impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
15118 #[allow(deprecated)]
15119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15120 where
15121 D: serde::Deserializer<'de>,
15122 {
15123 const FIELDS: &[&str] = &[
15124 "job_id",
15125 "jobId",
15126 "aligned",
15127 ];
15128
15129 #[allow(clippy::enum_variant_names)]
15130 enum GeneratedField {
15131 JobId,
15132 Aligned,
15133 }
15134 impl<'de> serde::Deserialize<'de> for GeneratedField {
15135 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15136 where
15137 D: serde::Deserializer<'de>,
15138 {
15139 struct GeneratedVisitor;
15140
15141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15142 type Value = GeneratedField;
15143
15144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15145 write!(formatter, "expected one of: {:?}", &FIELDS)
15146 }
15147
15148 #[allow(unused_variables)]
15149 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15150 where
15151 E: serde::de::Error,
15152 {
15153 match value {
15154 "jobId" | "job_id" => Ok(GeneratedField::JobId),
15155 "aligned" => Ok(GeneratedField::Aligned),
15156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15157 }
15158 }
15159 }
15160 deserializer.deserialize_identifier(GeneratedVisitor)
15161 }
15162 }
15163 struct GeneratedVisitor;
15164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15165 type Value = SetSyncLogStoreAlignedRequest;
15166
15167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15168 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
15169 }
15170
15171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
15172 where
15173 V: serde::de::MapAccess<'de>,
15174 {
15175 let mut job_id__ = None;
15176 let mut aligned__ = None;
15177 while let Some(k) = map_.next_key()? {
15178 match k {
15179 GeneratedField::JobId => {
15180 if job_id__.is_some() {
15181 return Err(serde::de::Error::duplicate_field("jobId"));
15182 }
15183 job_id__ =
15184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15185 ;
15186 }
15187 GeneratedField::Aligned => {
15188 if aligned__.is_some() {
15189 return Err(serde::de::Error::duplicate_field("aligned"));
15190 }
15191 aligned__ = Some(map_.next_value()?);
15192 }
15193 }
15194 }
15195 Ok(SetSyncLogStoreAlignedRequest {
15196 job_id: job_id__.unwrap_or_default(),
15197 aligned: aligned__.unwrap_or_default(),
15198 })
15199 }
15200 }
15201 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
15202 }
15203}
15204impl serde::Serialize for SetSyncLogStoreAlignedResponse {
15205 #[allow(deprecated)]
15206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15207 where
15208 S: serde::Serializer,
15209 {
15210 use serde::ser::SerializeStruct;
15211 let len = 0;
15212 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
15213 struct_ser.end()
15214 }
15215}
15216impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
15217 #[allow(deprecated)]
15218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15219 where
15220 D: serde::Deserializer<'de>,
15221 {
15222 const FIELDS: &[&str] = &[
15223 ];
15224
15225 #[allow(clippy::enum_variant_names)]
15226 enum GeneratedField {
15227 }
15228 impl<'de> serde::Deserialize<'de> for GeneratedField {
15229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15230 where
15231 D: serde::Deserializer<'de>,
15232 {
15233 struct GeneratedVisitor;
15234
15235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15236 type Value = GeneratedField;
15237
15238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15239 write!(formatter, "expected one of: {:?}", &FIELDS)
15240 }
15241
15242 #[allow(unused_variables)]
15243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15244 where
15245 E: serde::de::Error,
15246 {
15247 Err(serde::de::Error::unknown_field(value, FIELDS))
15248 }
15249 }
15250 deserializer.deserialize_identifier(GeneratedVisitor)
15251 }
15252 }
15253 struct GeneratedVisitor;
15254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15255 type Value = SetSyncLogStoreAlignedResponse;
15256
15257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15258 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
15259 }
15260
15261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
15262 where
15263 V: serde::de::MapAccess<'de>,
15264 {
15265 while map_.next_key::<GeneratedField>()?.is_some() {
15266 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15267 }
15268 Ok(SetSyncLogStoreAlignedResponse {
15269 })
15270 }
15271 }
15272 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
15273 }
15274}
15275impl serde::Serialize for SetSystemParamRequest {
15276 #[allow(deprecated)]
15277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15278 where
15279 S: serde::Serializer,
15280 {
15281 use serde::ser::SerializeStruct;
15282 let mut len = 0;
15283 if !self.param.is_empty() {
15284 len += 1;
15285 }
15286 if self.value.is_some() {
15287 len += 1;
15288 }
15289 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
15290 if !self.param.is_empty() {
15291 struct_ser.serialize_field("param", &self.param)?;
15292 }
15293 if let Some(v) = self.value.as_ref() {
15294 struct_ser.serialize_field("value", v)?;
15295 }
15296 struct_ser.end()
15297 }
15298}
15299impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
15300 #[allow(deprecated)]
15301 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15302 where
15303 D: serde::Deserializer<'de>,
15304 {
15305 const FIELDS: &[&str] = &[
15306 "param",
15307 "value",
15308 ];
15309
15310 #[allow(clippy::enum_variant_names)]
15311 enum GeneratedField {
15312 Param,
15313 Value,
15314 }
15315 impl<'de> serde::Deserialize<'de> for GeneratedField {
15316 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15317 where
15318 D: serde::Deserializer<'de>,
15319 {
15320 struct GeneratedVisitor;
15321
15322 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15323 type Value = GeneratedField;
15324
15325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15326 write!(formatter, "expected one of: {:?}", &FIELDS)
15327 }
15328
15329 #[allow(unused_variables)]
15330 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15331 where
15332 E: serde::de::Error,
15333 {
15334 match value {
15335 "param" => Ok(GeneratedField::Param),
15336 "value" => Ok(GeneratedField::Value),
15337 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15338 }
15339 }
15340 }
15341 deserializer.deserialize_identifier(GeneratedVisitor)
15342 }
15343 }
15344 struct GeneratedVisitor;
15345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15346 type Value = SetSystemParamRequest;
15347
15348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15349 formatter.write_str("struct meta.SetSystemParamRequest")
15350 }
15351
15352 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
15353 where
15354 V: serde::de::MapAccess<'de>,
15355 {
15356 let mut param__ = None;
15357 let mut value__ = None;
15358 while let Some(k) = map_.next_key()? {
15359 match k {
15360 GeneratedField::Param => {
15361 if param__.is_some() {
15362 return Err(serde::de::Error::duplicate_field("param"));
15363 }
15364 param__ = Some(map_.next_value()?);
15365 }
15366 GeneratedField::Value => {
15367 if value__.is_some() {
15368 return Err(serde::de::Error::duplicate_field("value"));
15369 }
15370 value__ = map_.next_value()?;
15371 }
15372 }
15373 }
15374 Ok(SetSystemParamRequest {
15375 param: param__.unwrap_or_default(),
15376 value: value__,
15377 })
15378 }
15379 }
15380 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
15381 }
15382}
15383impl serde::Serialize for SetSystemParamResponse {
15384 #[allow(deprecated)]
15385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15386 where
15387 S: serde::Serializer,
15388 {
15389 use serde::ser::SerializeStruct;
15390 let mut len = 0;
15391 if self.params.is_some() {
15392 len += 1;
15393 }
15394 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
15395 if let Some(v) = self.params.as_ref() {
15396 struct_ser.serialize_field("params", v)?;
15397 }
15398 struct_ser.end()
15399 }
15400}
15401impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
15402 #[allow(deprecated)]
15403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15404 where
15405 D: serde::Deserializer<'de>,
15406 {
15407 const FIELDS: &[&str] = &[
15408 "params",
15409 ];
15410
15411 #[allow(clippy::enum_variant_names)]
15412 enum GeneratedField {
15413 Params,
15414 }
15415 impl<'de> serde::Deserialize<'de> for GeneratedField {
15416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15417 where
15418 D: serde::Deserializer<'de>,
15419 {
15420 struct GeneratedVisitor;
15421
15422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15423 type Value = GeneratedField;
15424
15425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15426 write!(formatter, "expected one of: {:?}", &FIELDS)
15427 }
15428
15429 #[allow(unused_variables)]
15430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15431 where
15432 E: serde::de::Error,
15433 {
15434 match value {
15435 "params" => Ok(GeneratedField::Params),
15436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15437 }
15438 }
15439 }
15440 deserializer.deserialize_identifier(GeneratedVisitor)
15441 }
15442 }
15443 struct GeneratedVisitor;
15444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15445 type Value = SetSystemParamResponse;
15446
15447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15448 formatter.write_str("struct meta.SetSystemParamResponse")
15449 }
15450
15451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
15452 where
15453 V: serde::de::MapAccess<'de>,
15454 {
15455 let mut params__ = None;
15456 while let Some(k) = map_.next_key()? {
15457 match k {
15458 GeneratedField::Params => {
15459 if params__.is_some() {
15460 return Err(serde::de::Error::duplicate_field("params"));
15461 }
15462 params__ = map_.next_value()?;
15463 }
15464 }
15465 }
15466 Ok(SetSystemParamResponse {
15467 params: params__,
15468 })
15469 }
15470 }
15471 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
15472 }
15473}
15474impl serde::Serialize for SubscribeRequest {
15475 #[allow(deprecated)]
15476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15477 where
15478 S: serde::Serializer,
15479 {
15480 use serde::ser::SerializeStruct;
15481 let mut len = 0;
15482 if self.subscribe_type != 0 {
15483 len += 1;
15484 }
15485 if self.host.is_some() {
15486 len += 1;
15487 }
15488 if self.worker_id != 0 {
15489 len += 1;
15490 }
15491 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
15492 if self.subscribe_type != 0 {
15493 let v = SubscribeType::try_from(self.subscribe_type)
15494 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
15495 struct_ser.serialize_field("subscribeType", &v)?;
15496 }
15497 if let Some(v) = self.host.as_ref() {
15498 struct_ser.serialize_field("host", v)?;
15499 }
15500 if self.worker_id != 0 {
15501 struct_ser.serialize_field("workerId", &self.worker_id)?;
15502 }
15503 struct_ser.end()
15504 }
15505}
15506impl<'de> serde::Deserialize<'de> for SubscribeRequest {
15507 #[allow(deprecated)]
15508 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15509 where
15510 D: serde::Deserializer<'de>,
15511 {
15512 const FIELDS: &[&str] = &[
15513 "subscribe_type",
15514 "subscribeType",
15515 "host",
15516 "worker_id",
15517 "workerId",
15518 ];
15519
15520 #[allow(clippy::enum_variant_names)]
15521 enum GeneratedField {
15522 SubscribeType,
15523 Host,
15524 WorkerId,
15525 }
15526 impl<'de> serde::Deserialize<'de> for GeneratedField {
15527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15528 where
15529 D: serde::Deserializer<'de>,
15530 {
15531 struct GeneratedVisitor;
15532
15533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15534 type Value = GeneratedField;
15535
15536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15537 write!(formatter, "expected one of: {:?}", &FIELDS)
15538 }
15539
15540 #[allow(unused_variables)]
15541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15542 where
15543 E: serde::de::Error,
15544 {
15545 match value {
15546 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
15547 "host" => Ok(GeneratedField::Host),
15548 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
15549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15550 }
15551 }
15552 }
15553 deserializer.deserialize_identifier(GeneratedVisitor)
15554 }
15555 }
15556 struct GeneratedVisitor;
15557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15558 type Value = SubscribeRequest;
15559
15560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15561 formatter.write_str("struct meta.SubscribeRequest")
15562 }
15563
15564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
15565 where
15566 V: serde::de::MapAccess<'de>,
15567 {
15568 let mut subscribe_type__ = None;
15569 let mut host__ = None;
15570 let mut worker_id__ = None;
15571 while let Some(k) = map_.next_key()? {
15572 match k {
15573 GeneratedField::SubscribeType => {
15574 if subscribe_type__.is_some() {
15575 return Err(serde::de::Error::duplicate_field("subscribeType"));
15576 }
15577 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
15578 }
15579 GeneratedField::Host => {
15580 if host__.is_some() {
15581 return Err(serde::de::Error::duplicate_field("host"));
15582 }
15583 host__ = map_.next_value()?;
15584 }
15585 GeneratedField::WorkerId => {
15586 if worker_id__.is_some() {
15587 return Err(serde::de::Error::duplicate_field("workerId"));
15588 }
15589 worker_id__ =
15590 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15591 ;
15592 }
15593 }
15594 }
15595 Ok(SubscribeRequest {
15596 subscribe_type: subscribe_type__.unwrap_or_default(),
15597 host: host__,
15598 worker_id: worker_id__.unwrap_or_default(),
15599 })
15600 }
15601 }
15602 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
15603 }
15604}
15605impl serde::Serialize for SubscribeResponse {
15606 #[allow(deprecated)]
15607 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15608 where
15609 S: serde::Serializer,
15610 {
15611 use serde::ser::SerializeStruct;
15612 let mut len = 0;
15613 if self.status.is_some() {
15614 len += 1;
15615 }
15616 if self.operation != 0 {
15617 len += 1;
15618 }
15619 if self.version != 0 {
15620 len += 1;
15621 }
15622 if self.info.is_some() {
15623 len += 1;
15624 }
15625 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
15626 if let Some(v) = self.status.as_ref() {
15627 struct_ser.serialize_field("status", v)?;
15628 }
15629 if self.operation != 0 {
15630 let v = subscribe_response::Operation::try_from(self.operation)
15631 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
15632 struct_ser.serialize_field("operation", &v)?;
15633 }
15634 if self.version != 0 {
15635 #[allow(clippy::needless_borrow)]
15636 #[allow(clippy::needless_borrows_for_generic_args)]
15637 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
15638 }
15639 if let Some(v) = self.info.as_ref() {
15640 match v {
15641 subscribe_response::Info::Database(v) => {
15642 struct_ser.serialize_field("database", v)?;
15643 }
15644 subscribe_response::Info::Schema(v) => {
15645 struct_ser.serialize_field("schema", v)?;
15646 }
15647 subscribe_response::Info::Function(v) => {
15648 struct_ser.serialize_field("function", v)?;
15649 }
15650 subscribe_response::Info::User(v) => {
15651 struct_ser.serialize_field("user", v)?;
15652 }
15653 subscribe_response::Info::SessionParam(v) => {
15654 struct_ser.serialize_field("sessionParam", v)?;
15655 }
15656 subscribe_response::Info::Node(v) => {
15657 struct_ser.serialize_field("node", v)?;
15658 }
15659 subscribe_response::Info::HummockVersionDeltas(v) => {
15660 struct_ser.serialize_field("hummockVersionDeltas", v)?;
15661 }
15662 subscribe_response::Info::Snapshot(v) => {
15663 struct_ser.serialize_field("snapshot", v)?;
15664 }
15665 subscribe_response::Info::MetaBackupManifestId(v) => {
15666 struct_ser.serialize_field("metaBackupManifestId", v)?;
15667 }
15668 subscribe_response::Info::SystemParams(v) => {
15669 struct_ser.serialize_field("systemParams", v)?;
15670 }
15671 subscribe_response::Info::HummockWriteLimits(v) => {
15672 struct_ser.serialize_field("hummockWriteLimits", v)?;
15673 }
15674 subscribe_response::Info::ObjectGroup(v) => {
15675 struct_ser.serialize_field("objectGroup", v)?;
15676 }
15677 subscribe_response::Info::Connection(v) => {
15678 struct_ser.serialize_field("connection", v)?;
15679 }
15680 subscribe_response::Info::HummockStats(v) => {
15681 struct_ser.serialize_field("hummockStats", v)?;
15682 }
15683 subscribe_response::Info::Recovery(v) => {
15684 struct_ser.serialize_field("recovery", v)?;
15685 }
15686 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
15687 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
15688 }
15689 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
15690 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
15691 }
15692 subscribe_response::Info::Secret(v) => {
15693 struct_ser.serialize_field("secret", v)?;
15694 }
15695 subscribe_response::Info::ClusterResource(v) => {
15696 struct_ser.serialize_field("clusterResource", v)?;
15697 }
15698 }
15699 }
15700 struct_ser.end()
15701 }
15702}
15703impl<'de> serde::Deserialize<'de> for SubscribeResponse {
15704 #[allow(deprecated)]
15705 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15706 where
15707 D: serde::Deserializer<'de>,
15708 {
15709 const FIELDS: &[&str] = &[
15710 "status",
15711 "operation",
15712 "version",
15713 "database",
15714 "schema",
15715 "function",
15716 "user",
15717 "session_param",
15718 "sessionParam",
15719 "node",
15720 "hummock_version_deltas",
15721 "hummockVersionDeltas",
15722 "snapshot",
15723 "meta_backup_manifest_id",
15724 "metaBackupManifestId",
15725 "system_params",
15726 "systemParams",
15727 "hummock_write_limits",
15728 "hummockWriteLimits",
15729 "object_group",
15730 "objectGroup",
15731 "connection",
15732 "hummock_stats",
15733 "hummockStats",
15734 "recovery",
15735 "streaming_worker_slot_mapping",
15736 "streamingWorkerSlotMapping",
15737 "serving_worker_slot_mappings",
15738 "servingWorkerSlotMappings",
15739 "secret",
15740 "cluster_resource",
15741 "clusterResource",
15742 ];
15743
15744 #[allow(clippy::enum_variant_names)]
15745 enum GeneratedField {
15746 Status,
15747 Operation,
15748 Version,
15749 Database,
15750 Schema,
15751 Function,
15752 User,
15753 SessionParam,
15754 Node,
15755 HummockVersionDeltas,
15756 Snapshot,
15757 MetaBackupManifestId,
15758 SystemParams,
15759 HummockWriteLimits,
15760 ObjectGroup,
15761 Connection,
15762 HummockStats,
15763 Recovery,
15764 StreamingWorkerSlotMapping,
15765 ServingWorkerSlotMappings,
15766 Secret,
15767 ClusterResource,
15768 }
15769 impl<'de> serde::Deserialize<'de> for GeneratedField {
15770 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15771 where
15772 D: serde::Deserializer<'de>,
15773 {
15774 struct GeneratedVisitor;
15775
15776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15777 type Value = GeneratedField;
15778
15779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15780 write!(formatter, "expected one of: {:?}", &FIELDS)
15781 }
15782
15783 #[allow(unused_variables)]
15784 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15785 where
15786 E: serde::de::Error,
15787 {
15788 match value {
15789 "status" => Ok(GeneratedField::Status),
15790 "operation" => Ok(GeneratedField::Operation),
15791 "version" => Ok(GeneratedField::Version),
15792 "database" => Ok(GeneratedField::Database),
15793 "schema" => Ok(GeneratedField::Schema),
15794 "function" => Ok(GeneratedField::Function),
15795 "user" => Ok(GeneratedField::User),
15796 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
15797 "node" => Ok(GeneratedField::Node),
15798 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
15799 "snapshot" => Ok(GeneratedField::Snapshot),
15800 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
15801 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
15802 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
15803 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
15804 "connection" => Ok(GeneratedField::Connection),
15805 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
15806 "recovery" => Ok(GeneratedField::Recovery),
15807 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
15808 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
15809 "secret" => Ok(GeneratedField::Secret),
15810 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
15811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15812 }
15813 }
15814 }
15815 deserializer.deserialize_identifier(GeneratedVisitor)
15816 }
15817 }
15818 struct GeneratedVisitor;
15819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15820 type Value = SubscribeResponse;
15821
15822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15823 formatter.write_str("struct meta.SubscribeResponse")
15824 }
15825
15826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
15827 where
15828 V: serde::de::MapAccess<'de>,
15829 {
15830 let mut status__ = None;
15831 let mut operation__ = None;
15832 let mut version__ = None;
15833 let mut info__ = None;
15834 while let Some(k) = map_.next_key()? {
15835 match k {
15836 GeneratedField::Status => {
15837 if status__.is_some() {
15838 return Err(serde::de::Error::duplicate_field("status"));
15839 }
15840 status__ = map_.next_value()?;
15841 }
15842 GeneratedField::Operation => {
15843 if operation__.is_some() {
15844 return Err(serde::de::Error::duplicate_field("operation"));
15845 }
15846 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
15847 }
15848 GeneratedField::Version => {
15849 if version__.is_some() {
15850 return Err(serde::de::Error::duplicate_field("version"));
15851 }
15852 version__ =
15853 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15854 ;
15855 }
15856 GeneratedField::Database => {
15857 if info__.is_some() {
15858 return Err(serde::de::Error::duplicate_field("database"));
15859 }
15860 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
15861;
15862 }
15863 GeneratedField::Schema => {
15864 if info__.is_some() {
15865 return Err(serde::de::Error::duplicate_field("schema"));
15866 }
15867 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
15868;
15869 }
15870 GeneratedField::Function => {
15871 if info__.is_some() {
15872 return Err(serde::de::Error::duplicate_field("function"));
15873 }
15874 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
15875;
15876 }
15877 GeneratedField::User => {
15878 if info__.is_some() {
15879 return Err(serde::de::Error::duplicate_field("user"));
15880 }
15881 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
15882;
15883 }
15884 GeneratedField::SessionParam => {
15885 if info__.is_some() {
15886 return Err(serde::de::Error::duplicate_field("sessionParam"));
15887 }
15888 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
15889;
15890 }
15891 GeneratedField::Node => {
15892 if info__.is_some() {
15893 return Err(serde::de::Error::duplicate_field("node"));
15894 }
15895 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
15896;
15897 }
15898 GeneratedField::HummockVersionDeltas => {
15899 if info__.is_some() {
15900 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
15901 }
15902 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
15903;
15904 }
15905 GeneratedField::Snapshot => {
15906 if info__.is_some() {
15907 return Err(serde::de::Error::duplicate_field("snapshot"));
15908 }
15909 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
15910;
15911 }
15912 GeneratedField::MetaBackupManifestId => {
15913 if info__.is_some() {
15914 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
15915 }
15916 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
15917;
15918 }
15919 GeneratedField::SystemParams => {
15920 if info__.is_some() {
15921 return Err(serde::de::Error::duplicate_field("systemParams"));
15922 }
15923 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
15924;
15925 }
15926 GeneratedField::HummockWriteLimits => {
15927 if info__.is_some() {
15928 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
15929 }
15930 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
15931;
15932 }
15933 GeneratedField::ObjectGroup => {
15934 if info__.is_some() {
15935 return Err(serde::de::Error::duplicate_field("objectGroup"));
15936 }
15937 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
15938;
15939 }
15940 GeneratedField::Connection => {
15941 if info__.is_some() {
15942 return Err(serde::de::Error::duplicate_field("connection"));
15943 }
15944 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
15945;
15946 }
15947 GeneratedField::HummockStats => {
15948 if info__.is_some() {
15949 return Err(serde::de::Error::duplicate_field("hummockStats"));
15950 }
15951 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
15952;
15953 }
15954 GeneratedField::Recovery => {
15955 if info__.is_some() {
15956 return Err(serde::de::Error::duplicate_field("recovery"));
15957 }
15958 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
15959;
15960 }
15961 GeneratedField::StreamingWorkerSlotMapping => {
15962 if info__.is_some() {
15963 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
15964 }
15965 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
15966;
15967 }
15968 GeneratedField::ServingWorkerSlotMappings => {
15969 if info__.is_some() {
15970 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
15971 }
15972 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
15973;
15974 }
15975 GeneratedField::Secret => {
15976 if info__.is_some() {
15977 return Err(serde::de::Error::duplicate_field("secret"));
15978 }
15979 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
15980;
15981 }
15982 GeneratedField::ClusterResource => {
15983 if info__.is_some() {
15984 return Err(serde::de::Error::duplicate_field("clusterResource"));
15985 }
15986 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
15987;
15988 }
15989 }
15990 }
15991 Ok(SubscribeResponse {
15992 status: status__,
15993 operation: operation__.unwrap_or_default(),
15994 version: version__.unwrap_or_default(),
15995 info: info__,
15996 })
15997 }
15998 }
15999 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
16000 }
16001}
16002impl serde::Serialize for subscribe_response::Operation {
16003 #[allow(deprecated)]
16004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16005 where
16006 S: serde::Serializer,
16007 {
16008 let variant = match self {
16009 Self::Unspecified => "UNSPECIFIED",
16010 Self::Add => "ADD",
16011 Self::Delete => "DELETE",
16012 Self::Update => "UPDATE",
16013 Self::Snapshot => "SNAPSHOT",
16014 };
16015 serializer.serialize_str(variant)
16016 }
16017}
16018impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
16019 #[allow(deprecated)]
16020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16021 where
16022 D: serde::Deserializer<'de>,
16023 {
16024 const FIELDS: &[&str] = &[
16025 "UNSPECIFIED",
16026 "ADD",
16027 "DELETE",
16028 "UPDATE",
16029 "SNAPSHOT",
16030 ];
16031
16032 struct GeneratedVisitor;
16033
16034 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16035 type Value = subscribe_response::Operation;
16036
16037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16038 write!(formatter, "expected one of: {:?}", &FIELDS)
16039 }
16040
16041 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16042 where
16043 E: serde::de::Error,
16044 {
16045 i32::try_from(v)
16046 .ok()
16047 .and_then(|x| x.try_into().ok())
16048 .ok_or_else(|| {
16049 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16050 })
16051 }
16052
16053 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16054 where
16055 E: serde::de::Error,
16056 {
16057 i32::try_from(v)
16058 .ok()
16059 .and_then(|x| x.try_into().ok())
16060 .ok_or_else(|| {
16061 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16062 })
16063 }
16064
16065 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16066 where
16067 E: serde::de::Error,
16068 {
16069 match value {
16070 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
16071 "ADD" => Ok(subscribe_response::Operation::Add),
16072 "DELETE" => Ok(subscribe_response::Operation::Delete),
16073 "UPDATE" => Ok(subscribe_response::Operation::Update),
16074 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
16075 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16076 }
16077 }
16078 }
16079 deserializer.deserialize_any(GeneratedVisitor)
16080 }
16081}
16082impl serde::Serialize for SubscribeType {
16083 #[allow(deprecated)]
16084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16085 where
16086 S: serde::Serializer,
16087 {
16088 let variant = match self {
16089 Self::Unspecified => "UNSPECIFIED",
16090 Self::Frontend => "FRONTEND",
16091 Self::Hummock => "HUMMOCK",
16092 Self::Compactor => "COMPACTOR",
16093 Self::Compute => "COMPUTE",
16094 };
16095 serializer.serialize_str(variant)
16096 }
16097}
16098impl<'de> serde::Deserialize<'de> for SubscribeType {
16099 #[allow(deprecated)]
16100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16101 where
16102 D: serde::Deserializer<'de>,
16103 {
16104 const FIELDS: &[&str] = &[
16105 "UNSPECIFIED",
16106 "FRONTEND",
16107 "HUMMOCK",
16108 "COMPACTOR",
16109 "COMPUTE",
16110 ];
16111
16112 struct GeneratedVisitor;
16113
16114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16115 type Value = SubscribeType;
16116
16117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16118 write!(formatter, "expected one of: {:?}", &FIELDS)
16119 }
16120
16121 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16122 where
16123 E: serde::de::Error,
16124 {
16125 i32::try_from(v)
16126 .ok()
16127 .and_then(|x| x.try_into().ok())
16128 .ok_or_else(|| {
16129 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16130 })
16131 }
16132
16133 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16134 where
16135 E: serde::de::Error,
16136 {
16137 i32::try_from(v)
16138 .ok()
16139 .and_then(|x| x.try_into().ok())
16140 .ok_or_else(|| {
16141 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16142 })
16143 }
16144
16145 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16146 where
16147 E: serde::de::Error,
16148 {
16149 match value {
16150 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
16151 "FRONTEND" => Ok(SubscribeType::Frontend),
16152 "HUMMOCK" => Ok(SubscribeType::Hummock),
16153 "COMPACTOR" => Ok(SubscribeType::Compactor),
16154 "COMPUTE" => Ok(SubscribeType::Compute),
16155 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16156 }
16157 }
16158 }
16159 deserializer.deserialize_any(GeneratedVisitor)
16160 }
16161}
16162impl serde::Serialize for SystemParams {
16163 #[allow(deprecated)]
16164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16165 where
16166 S: serde::Serializer,
16167 {
16168 use serde::ser::SerializeStruct;
16169 let mut len = 0;
16170 if self.barrier_interval_ms.is_some() {
16171 len += 1;
16172 }
16173 if self.checkpoint_frequency.is_some() {
16174 len += 1;
16175 }
16176 if self.sstable_size_mb.is_some() {
16177 len += 1;
16178 }
16179 if self.block_size_kb.is_some() {
16180 len += 1;
16181 }
16182 if self.bloom_false_positive.is_some() {
16183 len += 1;
16184 }
16185 if self.state_store.is_some() {
16186 len += 1;
16187 }
16188 if self.data_directory.is_some() {
16189 len += 1;
16190 }
16191 if self.backup_storage_url.is_some() {
16192 len += 1;
16193 }
16194 if self.backup_storage_directory.is_some() {
16195 len += 1;
16196 }
16197 if self.telemetry_enabled.is_some() {
16198 len += 1;
16199 }
16200 if self.parallel_compact_size_mb.is_some() {
16201 len += 1;
16202 }
16203 if self.max_concurrent_creating_streaming_jobs.is_some() {
16204 len += 1;
16205 }
16206 if self.pause_on_next_bootstrap.is_some() {
16207 len += 1;
16208 }
16209 if self.wasm_storage_url.is_some() {
16210 len += 1;
16211 }
16212 if self.enable_tracing.is_some() {
16213 len += 1;
16214 }
16215 if self.use_new_object_prefix_strategy.is_some() {
16216 len += 1;
16217 }
16218 if self.license_key.is_some() {
16219 len += 1;
16220 }
16221 if self.time_travel_retention_ms.is_some() {
16222 len += 1;
16223 }
16224 if self.adaptive_parallelism_strategy.is_some() {
16225 len += 1;
16226 }
16227 if self.per_database_isolation.is_some() {
16228 len += 1;
16229 }
16230 if self.enforce_secret.is_some() {
16231 len += 1;
16232 }
16233 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
16234 if let Some(v) = self.barrier_interval_ms.as_ref() {
16235 struct_ser.serialize_field("barrierIntervalMs", v)?;
16236 }
16237 if let Some(v) = self.checkpoint_frequency.as_ref() {
16238 #[allow(clippy::needless_borrow)]
16239 #[allow(clippy::needless_borrows_for_generic_args)]
16240 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
16241 }
16242 if let Some(v) = self.sstable_size_mb.as_ref() {
16243 struct_ser.serialize_field("sstableSizeMb", v)?;
16244 }
16245 if let Some(v) = self.block_size_kb.as_ref() {
16246 struct_ser.serialize_field("blockSizeKb", v)?;
16247 }
16248 if let Some(v) = self.bloom_false_positive.as_ref() {
16249 struct_ser.serialize_field("bloomFalsePositive", v)?;
16250 }
16251 if let Some(v) = self.state_store.as_ref() {
16252 struct_ser.serialize_field("stateStore", v)?;
16253 }
16254 if let Some(v) = self.data_directory.as_ref() {
16255 struct_ser.serialize_field("dataDirectory", v)?;
16256 }
16257 if let Some(v) = self.backup_storage_url.as_ref() {
16258 struct_ser.serialize_field("backupStorageUrl", v)?;
16259 }
16260 if let Some(v) = self.backup_storage_directory.as_ref() {
16261 struct_ser.serialize_field("backupStorageDirectory", v)?;
16262 }
16263 if let Some(v) = self.telemetry_enabled.as_ref() {
16264 struct_ser.serialize_field("telemetryEnabled", v)?;
16265 }
16266 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
16267 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
16268 }
16269 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
16270 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
16271 }
16272 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
16273 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
16274 }
16275 if let Some(v) = self.wasm_storage_url.as_ref() {
16276 struct_ser.serialize_field("wasmStorageUrl", v)?;
16277 }
16278 if let Some(v) = self.enable_tracing.as_ref() {
16279 struct_ser.serialize_field("enableTracing", v)?;
16280 }
16281 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
16282 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
16283 }
16284 if let Some(v) = self.license_key.as_ref() {
16285 struct_ser.serialize_field("licenseKey", v)?;
16286 }
16287 if let Some(v) = self.time_travel_retention_ms.as_ref() {
16288 #[allow(clippy::needless_borrow)]
16289 #[allow(clippy::needless_borrows_for_generic_args)]
16290 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
16291 }
16292 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
16293 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
16294 }
16295 if let Some(v) = self.per_database_isolation.as_ref() {
16296 struct_ser.serialize_field("perDatabaseIsolation", v)?;
16297 }
16298 if let Some(v) = self.enforce_secret.as_ref() {
16299 struct_ser.serialize_field("enforceSecret", v)?;
16300 }
16301 struct_ser.end()
16302 }
16303}
16304impl<'de> serde::Deserialize<'de> for SystemParams {
16305 #[allow(deprecated)]
16306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16307 where
16308 D: serde::Deserializer<'de>,
16309 {
16310 const FIELDS: &[&str] = &[
16311 "barrier_interval_ms",
16312 "barrierIntervalMs",
16313 "checkpoint_frequency",
16314 "checkpointFrequency",
16315 "sstable_size_mb",
16316 "sstableSizeMb",
16317 "block_size_kb",
16318 "blockSizeKb",
16319 "bloom_false_positive",
16320 "bloomFalsePositive",
16321 "state_store",
16322 "stateStore",
16323 "data_directory",
16324 "dataDirectory",
16325 "backup_storage_url",
16326 "backupStorageUrl",
16327 "backup_storage_directory",
16328 "backupStorageDirectory",
16329 "telemetry_enabled",
16330 "telemetryEnabled",
16331 "parallel_compact_size_mb",
16332 "parallelCompactSizeMb",
16333 "max_concurrent_creating_streaming_jobs",
16334 "maxConcurrentCreatingStreamingJobs",
16335 "pause_on_next_bootstrap",
16336 "pauseOnNextBootstrap",
16337 "wasm_storage_url",
16338 "wasmStorageUrl",
16339 "enable_tracing",
16340 "enableTracing",
16341 "use_new_object_prefix_strategy",
16342 "useNewObjectPrefixStrategy",
16343 "license_key",
16344 "licenseKey",
16345 "time_travel_retention_ms",
16346 "timeTravelRetentionMs",
16347 "adaptive_parallelism_strategy",
16348 "adaptiveParallelismStrategy",
16349 "per_database_isolation",
16350 "perDatabaseIsolation",
16351 "enforce_secret",
16352 "enforceSecret",
16353 ];
16354
16355 #[allow(clippy::enum_variant_names)]
16356 enum GeneratedField {
16357 BarrierIntervalMs,
16358 CheckpointFrequency,
16359 SstableSizeMb,
16360 BlockSizeKb,
16361 BloomFalsePositive,
16362 StateStore,
16363 DataDirectory,
16364 BackupStorageUrl,
16365 BackupStorageDirectory,
16366 TelemetryEnabled,
16367 ParallelCompactSizeMb,
16368 MaxConcurrentCreatingStreamingJobs,
16369 PauseOnNextBootstrap,
16370 WasmStorageUrl,
16371 EnableTracing,
16372 UseNewObjectPrefixStrategy,
16373 LicenseKey,
16374 TimeTravelRetentionMs,
16375 AdaptiveParallelismStrategy,
16376 PerDatabaseIsolation,
16377 EnforceSecret,
16378 }
16379 impl<'de> serde::Deserialize<'de> for GeneratedField {
16380 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16381 where
16382 D: serde::Deserializer<'de>,
16383 {
16384 struct GeneratedVisitor;
16385
16386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16387 type Value = GeneratedField;
16388
16389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16390 write!(formatter, "expected one of: {:?}", &FIELDS)
16391 }
16392
16393 #[allow(unused_variables)]
16394 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16395 where
16396 E: serde::de::Error,
16397 {
16398 match value {
16399 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
16400 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
16401 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
16402 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
16403 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
16404 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
16405 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
16406 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
16407 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
16408 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
16409 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
16410 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
16411 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
16412 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
16413 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
16414 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
16415 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
16416 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
16417 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
16418 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
16419 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
16420 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16421 }
16422 }
16423 }
16424 deserializer.deserialize_identifier(GeneratedVisitor)
16425 }
16426 }
16427 struct GeneratedVisitor;
16428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16429 type Value = SystemParams;
16430
16431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16432 formatter.write_str("struct meta.SystemParams")
16433 }
16434
16435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
16436 where
16437 V: serde::de::MapAccess<'de>,
16438 {
16439 let mut barrier_interval_ms__ = None;
16440 let mut checkpoint_frequency__ = None;
16441 let mut sstable_size_mb__ = None;
16442 let mut block_size_kb__ = None;
16443 let mut bloom_false_positive__ = None;
16444 let mut state_store__ = None;
16445 let mut data_directory__ = None;
16446 let mut backup_storage_url__ = None;
16447 let mut backup_storage_directory__ = None;
16448 let mut telemetry_enabled__ = None;
16449 let mut parallel_compact_size_mb__ = None;
16450 let mut max_concurrent_creating_streaming_jobs__ = None;
16451 let mut pause_on_next_bootstrap__ = None;
16452 let mut wasm_storage_url__ = None;
16453 let mut enable_tracing__ = None;
16454 let mut use_new_object_prefix_strategy__ = None;
16455 let mut license_key__ = None;
16456 let mut time_travel_retention_ms__ = None;
16457 let mut adaptive_parallelism_strategy__ = None;
16458 let mut per_database_isolation__ = None;
16459 let mut enforce_secret__ = None;
16460 while let Some(k) = map_.next_key()? {
16461 match k {
16462 GeneratedField::BarrierIntervalMs => {
16463 if barrier_interval_ms__.is_some() {
16464 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
16465 }
16466 barrier_interval_ms__ =
16467 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16468 ;
16469 }
16470 GeneratedField::CheckpointFrequency => {
16471 if checkpoint_frequency__.is_some() {
16472 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
16473 }
16474 checkpoint_frequency__ =
16475 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16476 ;
16477 }
16478 GeneratedField::SstableSizeMb => {
16479 if sstable_size_mb__.is_some() {
16480 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
16481 }
16482 sstable_size_mb__ =
16483 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16484 ;
16485 }
16486 GeneratedField::BlockSizeKb => {
16487 if block_size_kb__.is_some() {
16488 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
16489 }
16490 block_size_kb__ =
16491 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16492 ;
16493 }
16494 GeneratedField::BloomFalsePositive => {
16495 if bloom_false_positive__.is_some() {
16496 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
16497 }
16498 bloom_false_positive__ =
16499 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16500 ;
16501 }
16502 GeneratedField::StateStore => {
16503 if state_store__.is_some() {
16504 return Err(serde::de::Error::duplicate_field("stateStore"));
16505 }
16506 state_store__ = map_.next_value()?;
16507 }
16508 GeneratedField::DataDirectory => {
16509 if data_directory__.is_some() {
16510 return Err(serde::de::Error::duplicate_field("dataDirectory"));
16511 }
16512 data_directory__ = map_.next_value()?;
16513 }
16514 GeneratedField::BackupStorageUrl => {
16515 if backup_storage_url__.is_some() {
16516 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
16517 }
16518 backup_storage_url__ = map_.next_value()?;
16519 }
16520 GeneratedField::BackupStorageDirectory => {
16521 if backup_storage_directory__.is_some() {
16522 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
16523 }
16524 backup_storage_directory__ = map_.next_value()?;
16525 }
16526 GeneratedField::TelemetryEnabled => {
16527 if telemetry_enabled__.is_some() {
16528 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
16529 }
16530 telemetry_enabled__ = map_.next_value()?;
16531 }
16532 GeneratedField::ParallelCompactSizeMb => {
16533 if parallel_compact_size_mb__.is_some() {
16534 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
16535 }
16536 parallel_compact_size_mb__ =
16537 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16538 ;
16539 }
16540 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
16541 if max_concurrent_creating_streaming_jobs__.is_some() {
16542 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
16543 }
16544 max_concurrent_creating_streaming_jobs__ =
16545 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16546 ;
16547 }
16548 GeneratedField::PauseOnNextBootstrap => {
16549 if pause_on_next_bootstrap__.is_some() {
16550 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
16551 }
16552 pause_on_next_bootstrap__ = map_.next_value()?;
16553 }
16554 GeneratedField::WasmStorageUrl => {
16555 if wasm_storage_url__.is_some() {
16556 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
16557 }
16558 wasm_storage_url__ = map_.next_value()?;
16559 }
16560 GeneratedField::EnableTracing => {
16561 if enable_tracing__.is_some() {
16562 return Err(serde::de::Error::duplicate_field("enableTracing"));
16563 }
16564 enable_tracing__ = map_.next_value()?;
16565 }
16566 GeneratedField::UseNewObjectPrefixStrategy => {
16567 if use_new_object_prefix_strategy__.is_some() {
16568 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
16569 }
16570 use_new_object_prefix_strategy__ = map_.next_value()?;
16571 }
16572 GeneratedField::LicenseKey => {
16573 if license_key__.is_some() {
16574 return Err(serde::de::Error::duplicate_field("licenseKey"));
16575 }
16576 license_key__ = map_.next_value()?;
16577 }
16578 GeneratedField::TimeTravelRetentionMs => {
16579 if time_travel_retention_ms__.is_some() {
16580 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
16581 }
16582 time_travel_retention_ms__ =
16583 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16584 ;
16585 }
16586 GeneratedField::AdaptiveParallelismStrategy => {
16587 if adaptive_parallelism_strategy__.is_some() {
16588 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
16589 }
16590 adaptive_parallelism_strategy__ = map_.next_value()?;
16591 }
16592 GeneratedField::PerDatabaseIsolation => {
16593 if per_database_isolation__.is_some() {
16594 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
16595 }
16596 per_database_isolation__ = map_.next_value()?;
16597 }
16598 GeneratedField::EnforceSecret => {
16599 if enforce_secret__.is_some() {
16600 return Err(serde::de::Error::duplicate_field("enforceSecret"));
16601 }
16602 enforce_secret__ = map_.next_value()?;
16603 }
16604 }
16605 }
16606 Ok(SystemParams {
16607 barrier_interval_ms: barrier_interval_ms__,
16608 checkpoint_frequency: checkpoint_frequency__,
16609 sstable_size_mb: sstable_size_mb__,
16610 block_size_kb: block_size_kb__,
16611 bloom_false_positive: bloom_false_positive__,
16612 state_store: state_store__,
16613 data_directory: data_directory__,
16614 backup_storage_url: backup_storage_url__,
16615 backup_storage_directory: backup_storage_directory__,
16616 telemetry_enabled: telemetry_enabled__,
16617 parallel_compact_size_mb: parallel_compact_size_mb__,
16618 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
16619 pause_on_next_bootstrap: pause_on_next_bootstrap__,
16620 wasm_storage_url: wasm_storage_url__,
16621 enable_tracing: enable_tracing__,
16622 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
16623 license_key: license_key__,
16624 time_travel_retention_ms: time_travel_retention_ms__,
16625 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
16626 per_database_isolation: per_database_isolation__,
16627 enforce_secret: enforce_secret__,
16628 })
16629 }
16630 }
16631 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
16632 }
16633}
16634impl serde::Serialize for TableFragments {
16635 #[allow(deprecated)]
16636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16637 where
16638 S: serde::Serializer,
16639 {
16640 use serde::ser::SerializeStruct;
16641 let mut len = 0;
16642 if self.table_id != 0 {
16643 len += 1;
16644 }
16645 if self.state != 0 {
16646 len += 1;
16647 }
16648 if !self.fragments.is_empty() {
16649 len += 1;
16650 }
16651 if !self.actor_status.is_empty() {
16652 len += 1;
16653 }
16654 if self.ctx.is_some() {
16655 len += 1;
16656 }
16657 if self.parallelism.is_some() {
16658 len += 1;
16659 }
16660 if self.max_parallelism.is_some() {
16661 len += 1;
16662 }
16663 if !self.node_label.is_empty() {
16664 len += 1;
16665 }
16666 if self.backfill_done {
16667 len += 1;
16668 }
16669 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
16670 if self.table_id != 0 {
16671 struct_ser.serialize_field("tableId", &self.table_id)?;
16672 }
16673 if self.state != 0 {
16674 let v = table_fragments::State::try_from(self.state)
16675 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
16676 struct_ser.serialize_field("state", &v)?;
16677 }
16678 if !self.fragments.is_empty() {
16679 struct_ser.serialize_field("fragments", &self.fragments)?;
16680 }
16681 if !self.actor_status.is_empty() {
16682 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
16683 }
16684 if let Some(v) = self.ctx.as_ref() {
16685 struct_ser.serialize_field("ctx", v)?;
16686 }
16687 if let Some(v) = self.parallelism.as_ref() {
16688 struct_ser.serialize_field("parallelism", v)?;
16689 }
16690 if let Some(v) = self.max_parallelism.as_ref() {
16691 struct_ser.serialize_field("maxParallelism", v)?;
16692 }
16693 if !self.node_label.is_empty() {
16694 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16695 }
16696 if self.backfill_done {
16697 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
16698 }
16699 struct_ser.end()
16700 }
16701}
16702impl<'de> serde::Deserialize<'de> for TableFragments {
16703 #[allow(deprecated)]
16704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16705 where
16706 D: serde::Deserializer<'de>,
16707 {
16708 const FIELDS: &[&str] = &[
16709 "table_id",
16710 "tableId",
16711 "state",
16712 "fragments",
16713 "actor_status",
16714 "actorStatus",
16715 "ctx",
16716 "parallelism",
16717 "max_parallelism",
16718 "maxParallelism",
16719 "node_label",
16720 "nodeLabel",
16721 "backfill_done",
16722 "backfillDone",
16723 ];
16724
16725 #[allow(clippy::enum_variant_names)]
16726 enum GeneratedField {
16727 TableId,
16728 State,
16729 Fragments,
16730 ActorStatus,
16731 Ctx,
16732 Parallelism,
16733 MaxParallelism,
16734 NodeLabel,
16735 BackfillDone,
16736 }
16737 impl<'de> serde::Deserialize<'de> for GeneratedField {
16738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16739 where
16740 D: serde::Deserializer<'de>,
16741 {
16742 struct GeneratedVisitor;
16743
16744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16745 type Value = GeneratedField;
16746
16747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16748 write!(formatter, "expected one of: {:?}", &FIELDS)
16749 }
16750
16751 #[allow(unused_variables)]
16752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16753 where
16754 E: serde::de::Error,
16755 {
16756 match value {
16757 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16758 "state" => Ok(GeneratedField::State),
16759 "fragments" => Ok(GeneratedField::Fragments),
16760 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
16761 "ctx" => Ok(GeneratedField::Ctx),
16762 "parallelism" => Ok(GeneratedField::Parallelism),
16763 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
16764 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16765 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
16766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16767 }
16768 }
16769 }
16770 deserializer.deserialize_identifier(GeneratedVisitor)
16771 }
16772 }
16773 struct GeneratedVisitor;
16774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16775 type Value = TableFragments;
16776
16777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16778 formatter.write_str("struct meta.TableFragments")
16779 }
16780
16781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
16782 where
16783 V: serde::de::MapAccess<'de>,
16784 {
16785 let mut table_id__ = None;
16786 let mut state__ = None;
16787 let mut fragments__ = None;
16788 let mut actor_status__ = None;
16789 let mut ctx__ = None;
16790 let mut parallelism__ = None;
16791 let mut max_parallelism__ = None;
16792 let mut node_label__ = None;
16793 let mut backfill_done__ = None;
16794 while let Some(k) = map_.next_key()? {
16795 match k {
16796 GeneratedField::TableId => {
16797 if table_id__.is_some() {
16798 return Err(serde::de::Error::duplicate_field("tableId"));
16799 }
16800 table_id__ =
16801 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16802 ;
16803 }
16804 GeneratedField::State => {
16805 if state__.is_some() {
16806 return Err(serde::de::Error::duplicate_field("state"));
16807 }
16808 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
16809 }
16810 GeneratedField::Fragments => {
16811 if fragments__.is_some() {
16812 return Err(serde::de::Error::duplicate_field("fragments"));
16813 }
16814 fragments__ = Some(
16815 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16816 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16817 );
16818 }
16819 GeneratedField::ActorStatus => {
16820 if actor_status__.is_some() {
16821 return Err(serde::de::Error::duplicate_field("actorStatus"));
16822 }
16823 actor_status__ = Some(
16824 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16825 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16826 );
16827 }
16828 GeneratedField::Ctx => {
16829 if ctx__.is_some() {
16830 return Err(serde::de::Error::duplicate_field("ctx"));
16831 }
16832 ctx__ = map_.next_value()?;
16833 }
16834 GeneratedField::Parallelism => {
16835 if parallelism__.is_some() {
16836 return Err(serde::de::Error::duplicate_field("parallelism"));
16837 }
16838 parallelism__ = map_.next_value()?;
16839 }
16840 GeneratedField::MaxParallelism => {
16841 if max_parallelism__.is_some() {
16842 return Err(serde::de::Error::duplicate_field("maxParallelism"));
16843 }
16844 max_parallelism__ =
16845 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16846 ;
16847 }
16848 GeneratedField::NodeLabel => {
16849 if node_label__.is_some() {
16850 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16851 }
16852 node_label__ = Some(map_.next_value()?);
16853 }
16854 GeneratedField::BackfillDone => {
16855 if backfill_done__.is_some() {
16856 return Err(serde::de::Error::duplicate_field("backfillDone"));
16857 }
16858 backfill_done__ = Some(map_.next_value()?);
16859 }
16860 }
16861 }
16862 Ok(TableFragments {
16863 table_id: table_id__.unwrap_or_default(),
16864 state: state__.unwrap_or_default(),
16865 fragments: fragments__.unwrap_or_default(),
16866 actor_status: actor_status__.unwrap_or_default(),
16867 ctx: ctx__,
16868 parallelism: parallelism__,
16869 max_parallelism: max_parallelism__,
16870 node_label: node_label__.unwrap_or_default(),
16871 backfill_done: backfill_done__.unwrap_or_default(),
16872 })
16873 }
16874 }
16875 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
16876 }
16877}
16878impl serde::Serialize for table_fragments::ActorStatus {
16879 #[allow(deprecated)]
16880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16881 where
16882 S: serde::Serializer,
16883 {
16884 use serde::ser::SerializeStruct;
16885 let mut len = 0;
16886 if self.location.is_some() {
16887 len += 1;
16888 }
16889 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
16890 if let Some(v) = self.location.as_ref() {
16891 struct_ser.serialize_field("location", v)?;
16892 }
16893 struct_ser.end()
16894 }
16895}
16896impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
16897 #[allow(deprecated)]
16898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16899 where
16900 D: serde::Deserializer<'de>,
16901 {
16902 const FIELDS: &[&str] = &[
16903 "location",
16904 ];
16905
16906 #[allow(clippy::enum_variant_names)]
16907 enum GeneratedField {
16908 Location,
16909 }
16910 impl<'de> serde::Deserialize<'de> for GeneratedField {
16911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16912 where
16913 D: serde::Deserializer<'de>,
16914 {
16915 struct GeneratedVisitor;
16916
16917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16918 type Value = GeneratedField;
16919
16920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16921 write!(formatter, "expected one of: {:?}", &FIELDS)
16922 }
16923
16924 #[allow(unused_variables)]
16925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16926 where
16927 E: serde::de::Error,
16928 {
16929 match value {
16930 "location" => Ok(GeneratedField::Location),
16931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16932 }
16933 }
16934 }
16935 deserializer.deserialize_identifier(GeneratedVisitor)
16936 }
16937 }
16938 struct GeneratedVisitor;
16939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16940 type Value = table_fragments::ActorStatus;
16941
16942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16943 formatter.write_str("struct meta.TableFragments.ActorStatus")
16944 }
16945
16946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
16947 where
16948 V: serde::de::MapAccess<'de>,
16949 {
16950 let mut location__ = None;
16951 while let Some(k) = map_.next_key()? {
16952 match k {
16953 GeneratedField::Location => {
16954 if location__.is_some() {
16955 return Err(serde::de::Error::duplicate_field("location"));
16956 }
16957 location__ = map_.next_value()?;
16958 }
16959 }
16960 }
16961 Ok(table_fragments::ActorStatus {
16962 location: location__,
16963 })
16964 }
16965 }
16966 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
16967 }
16968}
16969impl serde::Serialize for table_fragments::Fragment {
16970 #[allow(deprecated)]
16971 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16972 where
16973 S: serde::Serializer,
16974 {
16975 use serde::ser::SerializeStruct;
16976 let mut len = 0;
16977 if self.fragment_id != 0 {
16978 len += 1;
16979 }
16980 if self.fragment_type_mask != 0 {
16981 len += 1;
16982 }
16983 if self.distribution_type != 0 {
16984 len += 1;
16985 }
16986 if !self.actors.is_empty() {
16987 len += 1;
16988 }
16989 if !self.state_table_ids.is_empty() {
16990 len += 1;
16991 }
16992 if !self.upstream_fragment_ids.is_empty() {
16993 len += 1;
16994 }
16995 if self.maybe_vnode_count.is_some() {
16996 len += 1;
16997 }
16998 if self.nodes.is_some() {
16999 len += 1;
17000 }
17001 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
17002 if self.fragment_id != 0 {
17003 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
17004 }
17005 if self.fragment_type_mask != 0 {
17006 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
17007 }
17008 if self.distribution_type != 0 {
17009 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
17010 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
17011 struct_ser.serialize_field("distributionType", &v)?;
17012 }
17013 if !self.actors.is_empty() {
17014 struct_ser.serialize_field("actors", &self.actors)?;
17015 }
17016 if !self.state_table_ids.is_empty() {
17017 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
17018 }
17019 if !self.upstream_fragment_ids.is_empty() {
17020 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
17021 }
17022 if let Some(v) = self.maybe_vnode_count.as_ref() {
17023 struct_ser.serialize_field("maybeVnodeCount", v)?;
17024 }
17025 if let Some(v) = self.nodes.as_ref() {
17026 struct_ser.serialize_field("nodes", v)?;
17027 }
17028 struct_ser.end()
17029 }
17030}
17031impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
17032 #[allow(deprecated)]
17033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17034 where
17035 D: serde::Deserializer<'de>,
17036 {
17037 const FIELDS: &[&str] = &[
17038 "fragment_id",
17039 "fragmentId",
17040 "fragment_type_mask",
17041 "fragmentTypeMask",
17042 "distribution_type",
17043 "distributionType",
17044 "actors",
17045 "state_table_ids",
17046 "stateTableIds",
17047 "upstream_fragment_ids",
17048 "upstreamFragmentIds",
17049 "maybe_vnode_count",
17050 "maybeVnodeCount",
17051 "nodes",
17052 ];
17053
17054 #[allow(clippy::enum_variant_names)]
17055 enum GeneratedField {
17056 FragmentId,
17057 FragmentTypeMask,
17058 DistributionType,
17059 Actors,
17060 StateTableIds,
17061 UpstreamFragmentIds,
17062 MaybeVnodeCount,
17063 Nodes,
17064 }
17065 impl<'de> serde::Deserialize<'de> for GeneratedField {
17066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17067 where
17068 D: serde::Deserializer<'de>,
17069 {
17070 struct GeneratedVisitor;
17071
17072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17073 type Value = GeneratedField;
17074
17075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17076 write!(formatter, "expected one of: {:?}", &FIELDS)
17077 }
17078
17079 #[allow(unused_variables)]
17080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17081 where
17082 E: serde::de::Error,
17083 {
17084 match value {
17085 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
17086 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
17087 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
17088 "actors" => Ok(GeneratedField::Actors),
17089 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
17090 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
17091 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
17092 "nodes" => Ok(GeneratedField::Nodes),
17093 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17094 }
17095 }
17096 }
17097 deserializer.deserialize_identifier(GeneratedVisitor)
17098 }
17099 }
17100 struct GeneratedVisitor;
17101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17102 type Value = table_fragments::Fragment;
17103
17104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17105 formatter.write_str("struct meta.TableFragments.Fragment")
17106 }
17107
17108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
17109 where
17110 V: serde::de::MapAccess<'de>,
17111 {
17112 let mut fragment_id__ = None;
17113 let mut fragment_type_mask__ = None;
17114 let mut distribution_type__ = None;
17115 let mut actors__ = None;
17116 let mut state_table_ids__ = None;
17117 let mut upstream_fragment_ids__ = None;
17118 let mut maybe_vnode_count__ = None;
17119 let mut nodes__ = None;
17120 while let Some(k) = map_.next_key()? {
17121 match k {
17122 GeneratedField::FragmentId => {
17123 if fragment_id__.is_some() {
17124 return Err(serde::de::Error::duplicate_field("fragmentId"));
17125 }
17126 fragment_id__ =
17127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17128 ;
17129 }
17130 GeneratedField::FragmentTypeMask => {
17131 if fragment_type_mask__.is_some() {
17132 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
17133 }
17134 fragment_type_mask__ =
17135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17136 ;
17137 }
17138 GeneratedField::DistributionType => {
17139 if distribution_type__.is_some() {
17140 return Err(serde::de::Error::duplicate_field("distributionType"));
17141 }
17142 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
17143 }
17144 GeneratedField::Actors => {
17145 if actors__.is_some() {
17146 return Err(serde::de::Error::duplicate_field("actors"));
17147 }
17148 actors__ = Some(map_.next_value()?);
17149 }
17150 GeneratedField::StateTableIds => {
17151 if state_table_ids__.is_some() {
17152 return Err(serde::de::Error::duplicate_field("stateTableIds"));
17153 }
17154 state_table_ids__ =
17155 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17156 .into_iter().map(|x| x.0).collect())
17157 ;
17158 }
17159 GeneratedField::UpstreamFragmentIds => {
17160 if upstream_fragment_ids__.is_some() {
17161 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
17162 }
17163 upstream_fragment_ids__ =
17164 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17165 .into_iter().map(|x| x.0).collect())
17166 ;
17167 }
17168 GeneratedField::MaybeVnodeCount => {
17169 if maybe_vnode_count__.is_some() {
17170 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
17171 }
17172 maybe_vnode_count__ =
17173 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17174 ;
17175 }
17176 GeneratedField::Nodes => {
17177 if nodes__.is_some() {
17178 return Err(serde::de::Error::duplicate_field("nodes"));
17179 }
17180 nodes__ = map_.next_value()?;
17181 }
17182 }
17183 }
17184 Ok(table_fragments::Fragment {
17185 fragment_id: fragment_id__.unwrap_or_default(),
17186 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
17187 distribution_type: distribution_type__.unwrap_or_default(),
17188 actors: actors__.unwrap_or_default(),
17189 state_table_ids: state_table_ids__.unwrap_or_default(),
17190 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
17191 maybe_vnode_count: maybe_vnode_count__,
17192 nodes: nodes__,
17193 })
17194 }
17195 }
17196 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
17197 }
17198}
17199impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
17200 #[allow(deprecated)]
17201 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17202 where
17203 S: serde::Serializer,
17204 {
17205 let variant = match self {
17206 Self::Unspecified => "UNSPECIFIED",
17207 Self::Single => "SINGLE",
17208 Self::Hash => "HASH",
17209 };
17210 serializer.serialize_str(variant)
17211 }
17212}
17213impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
17214 #[allow(deprecated)]
17215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17216 where
17217 D: serde::Deserializer<'de>,
17218 {
17219 const FIELDS: &[&str] = &[
17220 "UNSPECIFIED",
17221 "SINGLE",
17222 "HASH",
17223 ];
17224
17225 struct GeneratedVisitor;
17226
17227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17228 type Value = table_fragments::fragment::FragmentDistributionType;
17229
17230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17231 write!(formatter, "expected one of: {:?}", &FIELDS)
17232 }
17233
17234 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17235 where
17236 E: serde::de::Error,
17237 {
17238 i32::try_from(v)
17239 .ok()
17240 .and_then(|x| x.try_into().ok())
17241 .ok_or_else(|| {
17242 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17243 })
17244 }
17245
17246 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17247 where
17248 E: serde::de::Error,
17249 {
17250 i32::try_from(v)
17251 .ok()
17252 .and_then(|x| x.try_into().ok())
17253 .ok_or_else(|| {
17254 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17255 })
17256 }
17257
17258 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17259 where
17260 E: serde::de::Error,
17261 {
17262 match value {
17263 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
17264 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
17265 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
17266 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17267 }
17268 }
17269 }
17270 deserializer.deserialize_any(GeneratedVisitor)
17271 }
17272}
17273impl serde::Serialize for table_fragments::State {
17274 #[allow(deprecated)]
17275 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17276 where
17277 S: serde::Serializer,
17278 {
17279 let variant = match self {
17280 Self::Unspecified => "UNSPECIFIED",
17281 Self::Initial => "INITIAL",
17282 Self::Creating => "CREATING",
17283 Self::Created => "CREATED",
17284 };
17285 serializer.serialize_str(variant)
17286 }
17287}
17288impl<'de> serde::Deserialize<'de> for table_fragments::State {
17289 #[allow(deprecated)]
17290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17291 where
17292 D: serde::Deserializer<'de>,
17293 {
17294 const FIELDS: &[&str] = &[
17295 "UNSPECIFIED",
17296 "INITIAL",
17297 "CREATING",
17298 "CREATED",
17299 ];
17300
17301 struct GeneratedVisitor;
17302
17303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17304 type Value = table_fragments::State;
17305
17306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17307 write!(formatter, "expected one of: {:?}", &FIELDS)
17308 }
17309
17310 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17311 where
17312 E: serde::de::Error,
17313 {
17314 i32::try_from(v)
17315 .ok()
17316 .and_then(|x| x.try_into().ok())
17317 .ok_or_else(|| {
17318 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17319 })
17320 }
17321
17322 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17323 where
17324 E: serde::de::Error,
17325 {
17326 i32::try_from(v)
17327 .ok()
17328 .and_then(|x| x.try_into().ok())
17329 .ok_or_else(|| {
17330 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17331 })
17332 }
17333
17334 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17335 where
17336 E: serde::de::Error,
17337 {
17338 match value {
17339 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
17340 "INITIAL" => Ok(table_fragments::State::Initial),
17341 "CREATING" => Ok(table_fragments::State::Creating),
17342 "CREATED" => Ok(table_fragments::State::Created),
17343 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17344 }
17345 }
17346 }
17347 deserializer.deserialize_any(GeneratedVisitor)
17348 }
17349}
17350impl serde::Serialize for TableParallelism {
17351 #[allow(deprecated)]
17352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17353 where
17354 S: serde::Serializer,
17355 {
17356 use serde::ser::SerializeStruct;
17357 let mut len = 0;
17358 if self.parallelism.is_some() {
17359 len += 1;
17360 }
17361 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
17362 if let Some(v) = self.parallelism.as_ref() {
17363 match v {
17364 table_parallelism::Parallelism::Fixed(v) => {
17365 struct_ser.serialize_field("fixed", v)?;
17366 }
17367 table_parallelism::Parallelism::Auto(v) => {
17368 struct_ser.serialize_field("auto", v)?;
17369 }
17370 table_parallelism::Parallelism::Custom(v) => {
17371 struct_ser.serialize_field("custom", v)?;
17372 }
17373 table_parallelism::Parallelism::Adaptive(v) => {
17374 struct_ser.serialize_field("adaptive", v)?;
17375 }
17376 }
17377 }
17378 struct_ser.end()
17379 }
17380}
17381impl<'de> serde::Deserialize<'de> for TableParallelism {
17382 #[allow(deprecated)]
17383 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17384 where
17385 D: serde::Deserializer<'de>,
17386 {
17387 const FIELDS: &[&str] = &[
17388 "fixed",
17389 "auto",
17390 "custom",
17391 "adaptive",
17392 ];
17393
17394 #[allow(clippy::enum_variant_names)]
17395 enum GeneratedField {
17396 Fixed,
17397 Auto,
17398 Custom,
17399 Adaptive,
17400 }
17401 impl<'de> serde::Deserialize<'de> for GeneratedField {
17402 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17403 where
17404 D: serde::Deserializer<'de>,
17405 {
17406 struct GeneratedVisitor;
17407
17408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17409 type Value = GeneratedField;
17410
17411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17412 write!(formatter, "expected one of: {:?}", &FIELDS)
17413 }
17414
17415 #[allow(unused_variables)]
17416 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17417 where
17418 E: serde::de::Error,
17419 {
17420 match value {
17421 "fixed" => Ok(GeneratedField::Fixed),
17422 "auto" => Ok(GeneratedField::Auto),
17423 "custom" => Ok(GeneratedField::Custom),
17424 "adaptive" => Ok(GeneratedField::Adaptive),
17425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17426 }
17427 }
17428 }
17429 deserializer.deserialize_identifier(GeneratedVisitor)
17430 }
17431 }
17432 struct GeneratedVisitor;
17433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17434 type Value = TableParallelism;
17435
17436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17437 formatter.write_str("struct meta.TableParallelism")
17438 }
17439
17440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
17441 where
17442 V: serde::de::MapAccess<'de>,
17443 {
17444 let mut parallelism__ = None;
17445 while let Some(k) = map_.next_key()? {
17446 match k {
17447 GeneratedField::Fixed => {
17448 if parallelism__.is_some() {
17449 return Err(serde::de::Error::duplicate_field("fixed"));
17450 }
17451 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
17452;
17453 }
17454 GeneratedField::Auto => {
17455 if parallelism__.is_some() {
17456 return Err(serde::de::Error::duplicate_field("auto"));
17457 }
17458 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
17459;
17460 }
17461 GeneratedField::Custom => {
17462 if parallelism__.is_some() {
17463 return Err(serde::de::Error::duplicate_field("custom"));
17464 }
17465 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
17466;
17467 }
17468 GeneratedField::Adaptive => {
17469 if parallelism__.is_some() {
17470 return Err(serde::de::Error::duplicate_field("adaptive"));
17471 }
17472 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
17473;
17474 }
17475 }
17476 }
17477 Ok(TableParallelism {
17478 parallelism: parallelism__,
17479 })
17480 }
17481 }
17482 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
17483 }
17484}
17485impl serde::Serialize for table_parallelism::AdaptiveParallelism {
17486 #[allow(deprecated)]
17487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17488 where
17489 S: serde::Serializer,
17490 {
17491 use serde::ser::SerializeStruct;
17492 let len = 0;
17493 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
17494 struct_ser.end()
17495 }
17496}
17497impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
17498 #[allow(deprecated)]
17499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17500 where
17501 D: serde::Deserializer<'de>,
17502 {
17503 const FIELDS: &[&str] = &[
17504 ];
17505
17506 #[allow(clippy::enum_variant_names)]
17507 enum GeneratedField {
17508 }
17509 impl<'de> serde::Deserialize<'de> for GeneratedField {
17510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17511 where
17512 D: serde::Deserializer<'de>,
17513 {
17514 struct GeneratedVisitor;
17515
17516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17517 type Value = GeneratedField;
17518
17519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17520 write!(formatter, "expected one of: {:?}", &FIELDS)
17521 }
17522
17523 #[allow(unused_variables)]
17524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17525 where
17526 E: serde::de::Error,
17527 {
17528 Err(serde::de::Error::unknown_field(value, FIELDS))
17529 }
17530 }
17531 deserializer.deserialize_identifier(GeneratedVisitor)
17532 }
17533 }
17534 struct GeneratedVisitor;
17535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17536 type Value = table_parallelism::AdaptiveParallelism;
17537
17538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17539 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
17540 }
17541
17542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
17543 where
17544 V: serde::de::MapAccess<'de>,
17545 {
17546 while map_.next_key::<GeneratedField>()?.is_some() {
17547 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17548 }
17549 Ok(table_parallelism::AdaptiveParallelism {
17550 })
17551 }
17552 }
17553 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
17554 }
17555}
17556impl serde::Serialize for table_parallelism::AutoParallelism {
17557 #[allow(deprecated)]
17558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17559 where
17560 S: serde::Serializer,
17561 {
17562 use serde::ser::SerializeStruct;
17563 let len = 0;
17564 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
17565 struct_ser.end()
17566 }
17567}
17568impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
17569 #[allow(deprecated)]
17570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17571 where
17572 D: serde::Deserializer<'de>,
17573 {
17574 const FIELDS: &[&str] = &[
17575 ];
17576
17577 #[allow(clippy::enum_variant_names)]
17578 enum GeneratedField {
17579 }
17580 impl<'de> serde::Deserialize<'de> for GeneratedField {
17581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17582 where
17583 D: serde::Deserializer<'de>,
17584 {
17585 struct GeneratedVisitor;
17586
17587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17588 type Value = GeneratedField;
17589
17590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17591 write!(formatter, "expected one of: {:?}", &FIELDS)
17592 }
17593
17594 #[allow(unused_variables)]
17595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17596 where
17597 E: serde::de::Error,
17598 {
17599 Err(serde::de::Error::unknown_field(value, FIELDS))
17600 }
17601 }
17602 deserializer.deserialize_identifier(GeneratedVisitor)
17603 }
17604 }
17605 struct GeneratedVisitor;
17606 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17607 type Value = table_parallelism::AutoParallelism;
17608
17609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17610 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
17611 }
17612
17613 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
17614 where
17615 V: serde::de::MapAccess<'de>,
17616 {
17617 while map_.next_key::<GeneratedField>()?.is_some() {
17618 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17619 }
17620 Ok(table_parallelism::AutoParallelism {
17621 })
17622 }
17623 }
17624 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
17625 }
17626}
17627impl serde::Serialize for table_parallelism::CustomParallelism {
17628 #[allow(deprecated)]
17629 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17630 where
17631 S: serde::Serializer,
17632 {
17633 use serde::ser::SerializeStruct;
17634 let len = 0;
17635 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
17636 struct_ser.end()
17637 }
17638}
17639impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
17640 #[allow(deprecated)]
17641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17642 where
17643 D: serde::Deserializer<'de>,
17644 {
17645 const FIELDS: &[&str] = &[
17646 ];
17647
17648 #[allow(clippy::enum_variant_names)]
17649 enum GeneratedField {
17650 }
17651 impl<'de> serde::Deserialize<'de> for GeneratedField {
17652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17653 where
17654 D: serde::Deserializer<'de>,
17655 {
17656 struct GeneratedVisitor;
17657
17658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17659 type Value = GeneratedField;
17660
17661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17662 write!(formatter, "expected one of: {:?}", &FIELDS)
17663 }
17664
17665 #[allow(unused_variables)]
17666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17667 where
17668 E: serde::de::Error,
17669 {
17670 Err(serde::de::Error::unknown_field(value, FIELDS))
17671 }
17672 }
17673 deserializer.deserialize_identifier(GeneratedVisitor)
17674 }
17675 }
17676 struct GeneratedVisitor;
17677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17678 type Value = table_parallelism::CustomParallelism;
17679
17680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17681 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
17682 }
17683
17684 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
17685 where
17686 V: serde::de::MapAccess<'de>,
17687 {
17688 while map_.next_key::<GeneratedField>()?.is_some() {
17689 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17690 }
17691 Ok(table_parallelism::CustomParallelism {
17692 })
17693 }
17694 }
17695 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
17696 }
17697}
17698impl serde::Serialize for table_parallelism::FixedParallelism {
17699 #[allow(deprecated)]
17700 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17701 where
17702 S: serde::Serializer,
17703 {
17704 use serde::ser::SerializeStruct;
17705 let mut len = 0;
17706 if self.parallelism != 0 {
17707 len += 1;
17708 }
17709 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
17710 if self.parallelism != 0 {
17711 struct_ser.serialize_field("parallelism", &self.parallelism)?;
17712 }
17713 struct_ser.end()
17714 }
17715}
17716impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
17717 #[allow(deprecated)]
17718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17719 where
17720 D: serde::Deserializer<'de>,
17721 {
17722 const FIELDS: &[&str] = &[
17723 "parallelism",
17724 ];
17725
17726 #[allow(clippy::enum_variant_names)]
17727 enum GeneratedField {
17728 Parallelism,
17729 }
17730 impl<'de> serde::Deserialize<'de> for GeneratedField {
17731 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17732 where
17733 D: serde::Deserializer<'de>,
17734 {
17735 struct GeneratedVisitor;
17736
17737 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17738 type Value = GeneratedField;
17739
17740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17741 write!(formatter, "expected one of: {:?}", &FIELDS)
17742 }
17743
17744 #[allow(unused_variables)]
17745 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17746 where
17747 E: serde::de::Error,
17748 {
17749 match value {
17750 "parallelism" => Ok(GeneratedField::Parallelism),
17751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17752 }
17753 }
17754 }
17755 deserializer.deserialize_identifier(GeneratedVisitor)
17756 }
17757 }
17758 struct GeneratedVisitor;
17759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17760 type Value = table_parallelism::FixedParallelism;
17761
17762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17763 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
17764 }
17765
17766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
17767 where
17768 V: serde::de::MapAccess<'de>,
17769 {
17770 let mut parallelism__ = None;
17771 while let Some(k) = map_.next_key()? {
17772 match k {
17773 GeneratedField::Parallelism => {
17774 if parallelism__.is_some() {
17775 return Err(serde::de::Error::duplicate_field("parallelism"));
17776 }
17777 parallelism__ =
17778 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17779 ;
17780 }
17781 }
17782 }
17783 Ok(table_parallelism::FixedParallelism {
17784 parallelism: parallelism__.unwrap_or_default(),
17785 })
17786 }
17787 }
17788 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
17789 }
17790}
17791impl serde::Serialize for TelemetryInfoResponse {
17792 #[allow(deprecated)]
17793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17794 where
17795 S: serde::Serializer,
17796 {
17797 use serde::ser::SerializeStruct;
17798 let mut len = 0;
17799 if self.tracking_id.is_some() {
17800 len += 1;
17801 }
17802 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
17803 if let Some(v) = self.tracking_id.as_ref() {
17804 struct_ser.serialize_field("trackingId", v)?;
17805 }
17806 struct_ser.end()
17807 }
17808}
17809impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
17810 #[allow(deprecated)]
17811 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17812 where
17813 D: serde::Deserializer<'de>,
17814 {
17815 const FIELDS: &[&str] = &[
17816 "tracking_id",
17817 "trackingId",
17818 ];
17819
17820 #[allow(clippy::enum_variant_names)]
17821 enum GeneratedField {
17822 TrackingId,
17823 }
17824 impl<'de> serde::Deserialize<'de> for GeneratedField {
17825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17826 where
17827 D: serde::Deserializer<'de>,
17828 {
17829 struct GeneratedVisitor;
17830
17831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17832 type Value = GeneratedField;
17833
17834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17835 write!(formatter, "expected one of: {:?}", &FIELDS)
17836 }
17837
17838 #[allow(unused_variables)]
17839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17840 where
17841 E: serde::de::Error,
17842 {
17843 match value {
17844 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
17845 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17846 }
17847 }
17848 }
17849 deserializer.deserialize_identifier(GeneratedVisitor)
17850 }
17851 }
17852 struct GeneratedVisitor;
17853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17854 type Value = TelemetryInfoResponse;
17855
17856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17857 formatter.write_str("struct meta.TelemetryInfoResponse")
17858 }
17859
17860 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
17861 where
17862 V: serde::de::MapAccess<'de>,
17863 {
17864 let mut tracking_id__ = None;
17865 while let Some(k) = map_.next_key()? {
17866 match k {
17867 GeneratedField::TrackingId => {
17868 if tracking_id__.is_some() {
17869 return Err(serde::de::Error::duplicate_field("trackingId"));
17870 }
17871 tracking_id__ = map_.next_value()?;
17872 }
17873 }
17874 }
17875 Ok(TelemetryInfoResponse {
17876 tracking_id: tracking_id__,
17877 })
17878 }
17879 }
17880 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
17881 }
17882}
17883impl serde::Serialize for ThrottleTarget {
17884 #[allow(deprecated)]
17885 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17886 where
17887 S: serde::Serializer,
17888 {
17889 let variant = match self {
17890 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
17891 Self::Source => "SOURCE",
17892 Self::Mv => "MV",
17893 Self::TableWithSource => "TABLE_WITH_SOURCE",
17894 Self::CdcTable => "CDC_TABLE",
17895 Self::TableDml => "TABLE_DML",
17896 Self::Sink => "SINK",
17897 Self::Fragment => "FRAGMENT",
17898 };
17899 serializer.serialize_str(variant)
17900 }
17901}
17902impl<'de> serde::Deserialize<'de> for ThrottleTarget {
17903 #[allow(deprecated)]
17904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17905 where
17906 D: serde::Deserializer<'de>,
17907 {
17908 const FIELDS: &[&str] = &[
17909 "THROTTLE_TARGET_UNSPECIFIED",
17910 "SOURCE",
17911 "MV",
17912 "TABLE_WITH_SOURCE",
17913 "CDC_TABLE",
17914 "TABLE_DML",
17915 "SINK",
17916 "FRAGMENT",
17917 ];
17918
17919 struct GeneratedVisitor;
17920
17921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17922 type Value = ThrottleTarget;
17923
17924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17925 write!(formatter, "expected one of: {:?}", &FIELDS)
17926 }
17927
17928 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17929 where
17930 E: serde::de::Error,
17931 {
17932 i32::try_from(v)
17933 .ok()
17934 .and_then(|x| x.try_into().ok())
17935 .ok_or_else(|| {
17936 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17937 })
17938 }
17939
17940 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17941 where
17942 E: serde::de::Error,
17943 {
17944 i32::try_from(v)
17945 .ok()
17946 .and_then(|x| x.try_into().ok())
17947 .ok_or_else(|| {
17948 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17949 })
17950 }
17951
17952 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17953 where
17954 E: serde::de::Error,
17955 {
17956 match value {
17957 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
17958 "SOURCE" => Ok(ThrottleTarget::Source),
17959 "MV" => Ok(ThrottleTarget::Mv),
17960 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
17961 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
17962 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
17963 "SINK" => Ok(ThrottleTarget::Sink),
17964 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
17965 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17966 }
17967 }
17968 }
17969 deserializer.deserialize_any(GeneratedVisitor)
17970 }
17971}
17972impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
17973 #[allow(deprecated)]
17974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17975 where
17976 S: serde::Serializer,
17977 {
17978 use serde::ser::SerializeStruct;
17979 let mut len = 0;
17980 if self.id != 0 {
17981 len += 1;
17982 }
17983 if !self.node_label.is_empty() {
17984 len += 1;
17985 }
17986 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
17987 if self.id != 0 {
17988 struct_ser.serialize_field("id", &self.id)?;
17989 }
17990 if !self.node_label.is_empty() {
17991 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
17992 }
17993 struct_ser.end()
17994 }
17995}
17996impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
17997 #[allow(deprecated)]
17998 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17999 where
18000 D: serde::Deserializer<'de>,
18001 {
18002 const FIELDS: &[&str] = &[
18003 "id",
18004 "node_label",
18005 "nodeLabel",
18006 ];
18007
18008 #[allow(clippy::enum_variant_names)]
18009 enum GeneratedField {
18010 Id,
18011 NodeLabel,
18012 }
18013 impl<'de> serde::Deserialize<'de> for GeneratedField {
18014 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18015 where
18016 D: serde::Deserializer<'de>,
18017 {
18018 struct GeneratedVisitor;
18019
18020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18021 type Value = GeneratedField;
18022
18023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18024 write!(formatter, "expected one of: {:?}", &FIELDS)
18025 }
18026
18027 #[allow(unused_variables)]
18028 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18029 where
18030 E: serde::de::Error,
18031 {
18032 match value {
18033 "id" => Ok(GeneratedField::Id),
18034 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
18035 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18036 }
18037 }
18038 }
18039 deserializer.deserialize_identifier(GeneratedVisitor)
18040 }
18041 }
18042 struct GeneratedVisitor;
18043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18044 type Value = UpdateStreamingJobNodeLabelsRequest;
18045
18046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18047 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
18048 }
18049
18050 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
18051 where
18052 V: serde::de::MapAccess<'de>,
18053 {
18054 let mut id__ = None;
18055 let mut node_label__ = None;
18056 while let Some(k) = map_.next_key()? {
18057 match k {
18058 GeneratedField::Id => {
18059 if id__.is_some() {
18060 return Err(serde::de::Error::duplicate_field("id"));
18061 }
18062 id__ =
18063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18064 ;
18065 }
18066 GeneratedField::NodeLabel => {
18067 if node_label__.is_some() {
18068 return Err(serde::de::Error::duplicate_field("nodeLabel"));
18069 }
18070 node_label__ = Some(map_.next_value()?);
18071 }
18072 }
18073 }
18074 Ok(UpdateStreamingJobNodeLabelsRequest {
18075 id: id__.unwrap_or_default(),
18076 node_label: node_label__.unwrap_or_default(),
18077 })
18078 }
18079 }
18080 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
18081 }
18082}
18083impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
18084 #[allow(deprecated)]
18085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18086 where
18087 S: serde::Serializer,
18088 {
18089 use serde::ser::SerializeStruct;
18090 let len = 0;
18091 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
18092 struct_ser.end()
18093 }
18094}
18095impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
18096 #[allow(deprecated)]
18097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18098 where
18099 D: serde::Deserializer<'de>,
18100 {
18101 const FIELDS: &[&str] = &[
18102 ];
18103
18104 #[allow(clippy::enum_variant_names)]
18105 enum GeneratedField {
18106 }
18107 impl<'de> serde::Deserialize<'de> for GeneratedField {
18108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18109 where
18110 D: serde::Deserializer<'de>,
18111 {
18112 struct GeneratedVisitor;
18113
18114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18115 type Value = GeneratedField;
18116
18117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18118 write!(formatter, "expected one of: {:?}", &FIELDS)
18119 }
18120
18121 #[allow(unused_variables)]
18122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18123 where
18124 E: serde::de::Error,
18125 {
18126 Err(serde::de::Error::unknown_field(value, FIELDS))
18127 }
18128 }
18129 deserializer.deserialize_identifier(GeneratedVisitor)
18130 }
18131 }
18132 struct GeneratedVisitor;
18133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18134 type Value = UpdateStreamingJobNodeLabelsResponse;
18135
18136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18137 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
18138 }
18139
18140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
18141 where
18142 V: serde::de::MapAccess<'de>,
18143 {
18144 while map_.next_key::<GeneratedField>()?.is_some() {
18145 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
18146 }
18147 Ok(UpdateStreamingJobNodeLabelsResponse {
18148 })
18149 }
18150 }
18151 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
18152 }
18153}
18154impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
18155 #[allow(deprecated)]
18156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18157 where
18158 S: serde::Serializer,
18159 {
18160 use serde::ser::SerializeStruct;
18161 let mut len = 0;
18162 if !self.worker_ids.is_empty() {
18163 len += 1;
18164 }
18165 if self.schedulability != 0 {
18166 len += 1;
18167 }
18168 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
18169 if !self.worker_ids.is_empty() {
18170 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
18171 }
18172 if self.schedulability != 0 {
18173 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
18174 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
18175 struct_ser.serialize_field("schedulability", &v)?;
18176 }
18177 struct_ser.end()
18178 }
18179}
18180impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
18181 #[allow(deprecated)]
18182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18183 where
18184 D: serde::Deserializer<'de>,
18185 {
18186 const FIELDS: &[&str] = &[
18187 "worker_ids",
18188 "workerIds",
18189 "schedulability",
18190 ];
18191
18192 #[allow(clippy::enum_variant_names)]
18193 enum GeneratedField {
18194 WorkerIds,
18195 Schedulability,
18196 }
18197 impl<'de> serde::Deserialize<'de> for GeneratedField {
18198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18199 where
18200 D: serde::Deserializer<'de>,
18201 {
18202 struct GeneratedVisitor;
18203
18204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18205 type Value = GeneratedField;
18206
18207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18208 write!(formatter, "expected one of: {:?}", &FIELDS)
18209 }
18210
18211 #[allow(unused_variables)]
18212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18213 where
18214 E: serde::de::Error,
18215 {
18216 match value {
18217 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
18218 "schedulability" => Ok(GeneratedField::Schedulability),
18219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18220 }
18221 }
18222 }
18223 deserializer.deserialize_identifier(GeneratedVisitor)
18224 }
18225 }
18226 struct GeneratedVisitor;
18227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18228 type Value = UpdateWorkerNodeSchedulabilityRequest;
18229
18230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18231 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
18232 }
18233
18234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
18235 where
18236 V: serde::de::MapAccess<'de>,
18237 {
18238 let mut worker_ids__ = None;
18239 let mut schedulability__ = None;
18240 while let Some(k) = map_.next_key()? {
18241 match k {
18242 GeneratedField::WorkerIds => {
18243 if worker_ids__.is_some() {
18244 return Err(serde::de::Error::duplicate_field("workerIds"));
18245 }
18246 worker_ids__ =
18247 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18248 .into_iter().map(|x| x.0).collect())
18249 ;
18250 }
18251 GeneratedField::Schedulability => {
18252 if schedulability__.is_some() {
18253 return Err(serde::de::Error::duplicate_field("schedulability"));
18254 }
18255 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
18256 }
18257 }
18258 }
18259 Ok(UpdateWorkerNodeSchedulabilityRequest {
18260 worker_ids: worker_ids__.unwrap_or_default(),
18261 schedulability: schedulability__.unwrap_or_default(),
18262 })
18263 }
18264 }
18265 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
18266 }
18267}
18268impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
18269 #[allow(deprecated)]
18270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18271 where
18272 S: serde::Serializer,
18273 {
18274 let variant = match self {
18275 Self::Unspecified => "UNSPECIFIED",
18276 Self::Schedulable => "SCHEDULABLE",
18277 Self::Unschedulable => "UNSCHEDULABLE",
18278 };
18279 serializer.serialize_str(variant)
18280 }
18281}
18282impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
18283 #[allow(deprecated)]
18284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18285 where
18286 D: serde::Deserializer<'de>,
18287 {
18288 const FIELDS: &[&str] = &[
18289 "UNSPECIFIED",
18290 "SCHEDULABLE",
18291 "UNSCHEDULABLE",
18292 ];
18293
18294 struct GeneratedVisitor;
18295
18296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18297 type Value = update_worker_node_schedulability_request::Schedulability;
18298
18299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18300 write!(formatter, "expected one of: {:?}", &FIELDS)
18301 }
18302
18303 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18304 where
18305 E: serde::de::Error,
18306 {
18307 i32::try_from(v)
18308 .ok()
18309 .and_then(|x| x.try_into().ok())
18310 .ok_or_else(|| {
18311 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18312 })
18313 }
18314
18315 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18316 where
18317 E: serde::de::Error,
18318 {
18319 i32::try_from(v)
18320 .ok()
18321 .and_then(|x| x.try_into().ok())
18322 .ok_or_else(|| {
18323 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18324 })
18325 }
18326
18327 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18328 where
18329 E: serde::de::Error,
18330 {
18331 match value {
18332 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
18333 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
18334 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
18335 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18336 }
18337 }
18338 }
18339 deserializer.deserialize_any(GeneratedVisitor)
18340 }
18341}
18342impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
18343 #[allow(deprecated)]
18344 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18345 where
18346 S: serde::Serializer,
18347 {
18348 use serde::ser::SerializeStruct;
18349 let mut len = 0;
18350 if self.status.is_some() {
18351 len += 1;
18352 }
18353 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
18354 if let Some(v) = self.status.as_ref() {
18355 struct_ser.serialize_field("status", v)?;
18356 }
18357 struct_ser.end()
18358 }
18359}
18360impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
18361 #[allow(deprecated)]
18362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18363 where
18364 D: serde::Deserializer<'de>,
18365 {
18366 const FIELDS: &[&str] = &[
18367 "status",
18368 ];
18369
18370 #[allow(clippy::enum_variant_names)]
18371 enum GeneratedField {
18372 Status,
18373 }
18374 impl<'de> serde::Deserialize<'de> for GeneratedField {
18375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18376 where
18377 D: serde::Deserializer<'de>,
18378 {
18379 struct GeneratedVisitor;
18380
18381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18382 type Value = GeneratedField;
18383
18384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18385 write!(formatter, "expected one of: {:?}", &FIELDS)
18386 }
18387
18388 #[allow(unused_variables)]
18389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18390 where
18391 E: serde::de::Error,
18392 {
18393 match value {
18394 "status" => Ok(GeneratedField::Status),
18395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18396 }
18397 }
18398 }
18399 deserializer.deserialize_identifier(GeneratedVisitor)
18400 }
18401 }
18402 struct GeneratedVisitor;
18403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18404 type Value = UpdateWorkerNodeSchedulabilityResponse;
18405
18406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18407 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
18408 }
18409
18410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
18411 where
18412 V: serde::de::MapAccess<'de>,
18413 {
18414 let mut status__ = None;
18415 while let Some(k) = map_.next_key()? {
18416 match k {
18417 GeneratedField::Status => {
18418 if status__.is_some() {
18419 return Err(serde::de::Error::duplicate_field("status"));
18420 }
18421 status__ = map_.next_value()?;
18422 }
18423 }
18424 }
18425 Ok(UpdateWorkerNodeSchedulabilityResponse {
18426 status: status__,
18427 })
18428 }
18429 }
18430 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
18431 }
18432}
18433impl serde::Serialize for WorkerReschedule {
18434 #[allow(deprecated)]
18435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18436 where
18437 S: serde::Serializer,
18438 {
18439 use serde::ser::SerializeStruct;
18440 let mut len = 0;
18441 if !self.worker_actor_diff.is_empty() {
18442 len += 1;
18443 }
18444 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
18445 if !self.worker_actor_diff.is_empty() {
18446 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
18447 }
18448 struct_ser.end()
18449 }
18450}
18451impl<'de> serde::Deserialize<'de> for WorkerReschedule {
18452 #[allow(deprecated)]
18453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18454 where
18455 D: serde::Deserializer<'de>,
18456 {
18457 const FIELDS: &[&str] = &[
18458 "worker_actor_diff",
18459 "workerActorDiff",
18460 ];
18461
18462 #[allow(clippy::enum_variant_names)]
18463 enum GeneratedField {
18464 WorkerActorDiff,
18465 }
18466 impl<'de> serde::Deserialize<'de> for GeneratedField {
18467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18468 where
18469 D: serde::Deserializer<'de>,
18470 {
18471 struct GeneratedVisitor;
18472
18473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18474 type Value = GeneratedField;
18475
18476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18477 write!(formatter, "expected one of: {:?}", &FIELDS)
18478 }
18479
18480 #[allow(unused_variables)]
18481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18482 where
18483 E: serde::de::Error,
18484 {
18485 match value {
18486 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
18487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18488 }
18489 }
18490 }
18491 deserializer.deserialize_identifier(GeneratedVisitor)
18492 }
18493 }
18494 struct GeneratedVisitor;
18495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18496 type Value = WorkerReschedule;
18497
18498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18499 formatter.write_str("struct meta.WorkerReschedule")
18500 }
18501
18502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
18503 where
18504 V: serde::de::MapAccess<'de>,
18505 {
18506 let mut worker_actor_diff__ = None;
18507 while let Some(k) = map_.next_key()? {
18508 match k {
18509 GeneratedField::WorkerActorDiff => {
18510 if worker_actor_diff__.is_some() {
18511 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
18512 }
18513 worker_actor_diff__ = Some(
18514 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
18515 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
18516 );
18517 }
18518 }
18519 }
18520 Ok(WorkerReschedule {
18521 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
18522 })
18523 }
18524 }
18525 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
18526 }
18527}