1use crate::meta::*;
2impl serde::Serialize for ActivateWorkerNodeRequest {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if self.host.is_some() {
11 len += 1;
12 }
13 if self.node_id != 0 {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
17 if let Some(v) = self.host.as_ref() {
18 struct_ser.serialize_field("host", v)?;
19 }
20 if self.node_id != 0 {
21 struct_ser.serialize_field("nodeId", &self.node_id)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "host",
34 "node_id",
35 "nodeId",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 Host,
41 NodeId,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "host" => Ok(GeneratedField::Host),
64 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = ActivateWorkerNodeRequest;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct meta.ActivateWorkerNodeRequest")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut host__ = None;
85 let mut node_id__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::Host => {
89 if host__.is_some() {
90 return Err(serde::de::Error::duplicate_field("host"));
91 }
92 host__ = map_.next_value()?;
93 }
94 GeneratedField::NodeId => {
95 if node_id__.is_some() {
96 return Err(serde::de::Error::duplicate_field("nodeId"));
97 }
98 node_id__ =
99 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
100 ;
101 }
102 }
103 }
104 Ok(ActivateWorkerNodeRequest {
105 host: host__,
106 node_id: node_id__.unwrap_or_default(),
107 })
108 }
109 }
110 deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
111 }
112}
113impl serde::Serialize for ActivateWorkerNodeResponse {
114 #[allow(deprecated)]
115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
116 where
117 S: serde::Serializer,
118 {
119 use serde::ser::SerializeStruct;
120 let mut len = 0;
121 if self.status.is_some() {
122 len += 1;
123 }
124 let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
125 if let Some(v) = self.status.as_ref() {
126 struct_ser.serialize_field("status", v)?;
127 }
128 struct_ser.end()
129 }
130}
131impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
132 #[allow(deprecated)]
133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
134 where
135 D: serde::Deserializer<'de>,
136 {
137 const FIELDS: &[&str] = &[
138 "status",
139 ];
140
141 #[allow(clippy::enum_variant_names)]
142 enum GeneratedField {
143 Status,
144 }
145 impl<'de> serde::Deserialize<'de> for GeneratedField {
146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
147 where
148 D: serde::Deserializer<'de>,
149 {
150 struct GeneratedVisitor;
151
152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
153 type Value = GeneratedField;
154
155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
156 write!(formatter, "expected one of: {:?}", &FIELDS)
157 }
158
159 #[allow(unused_variables)]
160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
161 where
162 E: serde::de::Error,
163 {
164 match value {
165 "status" => Ok(GeneratedField::Status),
166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
167 }
168 }
169 }
170 deserializer.deserialize_identifier(GeneratedVisitor)
171 }
172 }
173 struct GeneratedVisitor;
174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
175 type Value = ActivateWorkerNodeResponse;
176
177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
178 formatter.write_str("struct meta.ActivateWorkerNodeResponse")
179 }
180
181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
182 where
183 V: serde::de::MapAccess<'de>,
184 {
185 let mut status__ = None;
186 while let Some(k) = map_.next_key()? {
187 match k {
188 GeneratedField::Status => {
189 if status__.is_some() {
190 return Err(serde::de::Error::duplicate_field("status"));
191 }
192 status__ = map_.next_value()?;
193 }
194 }
195 }
196 Ok(ActivateWorkerNodeResponse {
197 status: status__,
198 })
199 }
200 }
201 deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
202 }
203}
204impl serde::Serialize for ActorCountPerParallelism {
205 #[allow(deprecated)]
206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
207 where
208 S: serde::Serializer,
209 {
210 use serde::ser::SerializeStruct;
211 let mut len = 0;
212 if !self.worker_id_to_actor_count.is_empty() {
213 len += 1;
214 }
215 if self.hard_limit != 0 {
216 len += 1;
217 }
218 if self.soft_limit != 0 {
219 len += 1;
220 }
221 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
222 if !self.worker_id_to_actor_count.is_empty() {
223 struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
224 }
225 if self.hard_limit != 0 {
226 #[allow(clippy::needless_borrow)]
227 #[allow(clippy::needless_borrows_for_generic_args)]
228 struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
229 }
230 if self.soft_limit != 0 {
231 #[allow(clippy::needless_borrow)]
232 #[allow(clippy::needless_borrows_for_generic_args)]
233 struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
234 }
235 struct_ser.end()
236 }
237}
238impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
239 #[allow(deprecated)]
240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
241 where
242 D: serde::Deserializer<'de>,
243 {
244 const FIELDS: &[&str] = &[
245 "worker_id_to_actor_count",
246 "workerIdToActorCount",
247 "hard_limit",
248 "hardLimit",
249 "soft_limit",
250 "softLimit",
251 ];
252
253 #[allow(clippy::enum_variant_names)]
254 enum GeneratedField {
255 WorkerIdToActorCount,
256 HardLimit,
257 SoftLimit,
258 }
259 impl<'de> serde::Deserialize<'de> for GeneratedField {
260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261 where
262 D: serde::Deserializer<'de>,
263 {
264 struct GeneratedVisitor;
265
266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267 type Value = GeneratedField;
268
269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 write!(formatter, "expected one of: {:?}", &FIELDS)
271 }
272
273 #[allow(unused_variables)]
274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275 where
276 E: serde::de::Error,
277 {
278 match value {
279 "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
280 "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
281 "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
283 }
284 }
285 }
286 deserializer.deserialize_identifier(GeneratedVisitor)
287 }
288 }
289 struct GeneratedVisitor;
290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
291 type Value = ActorCountPerParallelism;
292
293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
294 formatter.write_str("struct meta.ActorCountPerParallelism")
295 }
296
297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
298 where
299 V: serde::de::MapAccess<'de>,
300 {
301 let mut worker_id_to_actor_count__ = None;
302 let mut hard_limit__ = None;
303 let mut soft_limit__ = None;
304 while let Some(k) = map_.next_key()? {
305 match k {
306 GeneratedField::WorkerIdToActorCount => {
307 if worker_id_to_actor_count__.is_some() {
308 return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
309 }
310 worker_id_to_actor_count__ = Some(
311 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
312 .into_iter().map(|(k,v)| (k.0, v)).collect()
313 );
314 }
315 GeneratedField::HardLimit => {
316 if hard_limit__.is_some() {
317 return Err(serde::de::Error::duplicate_field("hardLimit"));
318 }
319 hard_limit__ =
320 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
321 ;
322 }
323 GeneratedField::SoftLimit => {
324 if soft_limit__.is_some() {
325 return Err(serde::de::Error::duplicate_field("softLimit"));
326 }
327 soft_limit__ =
328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
329 ;
330 }
331 }
332 }
333 Ok(ActorCountPerParallelism {
334 worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
335 hard_limit: hard_limit__.unwrap_or_default(),
336 soft_limit: soft_limit__.unwrap_or_default(),
337 })
338 }
339 }
340 deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
341 }
342}
343impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
344 #[allow(deprecated)]
345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
346 where
347 S: serde::Serializer,
348 {
349 use serde::ser::SerializeStruct;
350 let mut len = 0;
351 if self.actor_count != 0 {
352 len += 1;
353 }
354 if self.parallelism != 0 {
355 len += 1;
356 }
357 let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
358 if self.actor_count != 0 {
359 #[allow(clippy::needless_borrow)]
360 #[allow(clippy::needless_borrows_for_generic_args)]
361 struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
362 }
363 if self.parallelism != 0 {
364 #[allow(clippy::needless_borrow)]
365 #[allow(clippy::needless_borrows_for_generic_args)]
366 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
367 }
368 struct_ser.end()
369 }
370}
371impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
372 #[allow(deprecated)]
373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
374 where
375 D: serde::Deserializer<'de>,
376 {
377 const FIELDS: &[&str] = &[
378 "actor_count",
379 "actorCount",
380 "parallelism",
381 ];
382
383 #[allow(clippy::enum_variant_names)]
384 enum GeneratedField {
385 ActorCount,
386 Parallelism,
387 }
388 impl<'de> serde::Deserialize<'de> for GeneratedField {
389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
390 where
391 D: serde::Deserializer<'de>,
392 {
393 struct GeneratedVisitor;
394
395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
396 type Value = GeneratedField;
397
398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
399 write!(formatter, "expected one of: {:?}", &FIELDS)
400 }
401
402 #[allow(unused_variables)]
403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
404 where
405 E: serde::de::Error,
406 {
407 match value {
408 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
409 "parallelism" => Ok(GeneratedField::Parallelism),
410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
411 }
412 }
413 }
414 deserializer.deserialize_identifier(GeneratedVisitor)
415 }
416 }
417 struct GeneratedVisitor;
418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
419 type Value = actor_count_per_parallelism::WorkerActorCount;
420
421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
422 formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
423 }
424
425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
426 where
427 V: serde::de::MapAccess<'de>,
428 {
429 let mut actor_count__ = None;
430 let mut parallelism__ = None;
431 while let Some(k) = map_.next_key()? {
432 match k {
433 GeneratedField::ActorCount => {
434 if actor_count__.is_some() {
435 return Err(serde::de::Error::duplicate_field("actorCount"));
436 }
437 actor_count__ =
438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
439 ;
440 }
441 GeneratedField::Parallelism => {
442 if parallelism__.is_some() {
443 return Err(serde::de::Error::duplicate_field("parallelism"));
444 }
445 parallelism__ =
446 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
447 ;
448 }
449 }
450 }
451 Ok(actor_count_per_parallelism::WorkerActorCount {
452 actor_count: actor_count__.unwrap_or_default(),
453 parallelism: parallelism__.unwrap_or_default(),
454 })
455 }
456 }
457 deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
458 }
459}
460impl serde::Serialize for ActorIds {
461 #[allow(deprecated)]
462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
463 where
464 S: serde::Serializer,
465 {
466 use serde::ser::SerializeStruct;
467 let mut len = 0;
468 if !self.ids.is_empty() {
469 len += 1;
470 }
471 let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
472 if !self.ids.is_empty() {
473 struct_ser.serialize_field("ids", &self.ids)?;
474 }
475 struct_ser.end()
476 }
477}
478impl<'de> serde::Deserialize<'de> for ActorIds {
479 #[allow(deprecated)]
480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
481 where
482 D: serde::Deserializer<'de>,
483 {
484 const FIELDS: &[&str] = &[
485 "ids",
486 ];
487
488 #[allow(clippy::enum_variant_names)]
489 enum GeneratedField {
490 Ids,
491 }
492 impl<'de> serde::Deserialize<'de> for GeneratedField {
493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
494 where
495 D: serde::Deserializer<'de>,
496 {
497 struct GeneratedVisitor;
498
499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
500 type Value = GeneratedField;
501
502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
503 write!(formatter, "expected one of: {:?}", &FIELDS)
504 }
505
506 #[allow(unused_variables)]
507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
508 where
509 E: serde::de::Error,
510 {
511 match value {
512 "ids" => Ok(GeneratedField::Ids),
513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
514 }
515 }
516 }
517 deserializer.deserialize_identifier(GeneratedVisitor)
518 }
519 }
520 struct GeneratedVisitor;
521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
522 type Value = ActorIds;
523
524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
525 formatter.write_str("struct meta.ActorIds")
526 }
527
528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
529 where
530 V: serde::de::MapAccess<'de>,
531 {
532 let mut ids__ = None;
533 while let Some(k) = map_.next_key()? {
534 match k {
535 GeneratedField::Ids => {
536 if ids__.is_some() {
537 return Err(serde::de::Error::duplicate_field("ids"));
538 }
539 ids__ =
540 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
541 .into_iter().map(|x| x.0).collect())
542 ;
543 }
544 }
545 }
546 Ok(ActorIds {
547 ids: ids__.unwrap_or_default(),
548 })
549 }
550 }
551 deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
552 }
553}
554impl serde::Serialize for ActorLocation {
555 #[allow(deprecated)]
556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
557 where
558 S: serde::Serializer,
559 {
560 use serde::ser::SerializeStruct;
561 let mut len = 0;
562 if self.node.is_some() {
563 len += 1;
564 }
565 if !self.actors.is_empty() {
566 len += 1;
567 }
568 let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
569 if let Some(v) = self.node.as_ref() {
570 struct_ser.serialize_field("node", v)?;
571 }
572 if !self.actors.is_empty() {
573 struct_ser.serialize_field("actors", &self.actors)?;
574 }
575 struct_ser.end()
576 }
577}
578impl<'de> serde::Deserialize<'de> for ActorLocation {
579 #[allow(deprecated)]
580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
581 where
582 D: serde::Deserializer<'de>,
583 {
584 const FIELDS: &[&str] = &[
585 "node",
586 "actors",
587 ];
588
589 #[allow(clippy::enum_variant_names)]
590 enum GeneratedField {
591 Node,
592 Actors,
593 }
594 impl<'de> serde::Deserialize<'de> for GeneratedField {
595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
596 where
597 D: serde::Deserializer<'de>,
598 {
599 struct GeneratedVisitor;
600
601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
602 type Value = GeneratedField;
603
604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
605 write!(formatter, "expected one of: {:?}", &FIELDS)
606 }
607
608 #[allow(unused_variables)]
609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
610 where
611 E: serde::de::Error,
612 {
613 match value {
614 "node" => Ok(GeneratedField::Node),
615 "actors" => Ok(GeneratedField::Actors),
616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
617 }
618 }
619 }
620 deserializer.deserialize_identifier(GeneratedVisitor)
621 }
622 }
623 struct GeneratedVisitor;
624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
625 type Value = ActorLocation;
626
627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
628 formatter.write_str("struct meta.ActorLocation")
629 }
630
631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
632 where
633 V: serde::de::MapAccess<'de>,
634 {
635 let mut node__ = None;
636 let mut actors__ = None;
637 while let Some(k) = map_.next_key()? {
638 match k {
639 GeneratedField::Node => {
640 if node__.is_some() {
641 return Err(serde::de::Error::duplicate_field("node"));
642 }
643 node__ = map_.next_value()?;
644 }
645 GeneratedField::Actors => {
646 if actors__.is_some() {
647 return Err(serde::de::Error::duplicate_field("actors"));
648 }
649 actors__ = Some(map_.next_value()?);
650 }
651 }
652 }
653 Ok(ActorLocation {
654 node: node__,
655 actors: actors__.unwrap_or_default(),
656 })
657 }
658 }
659 deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
660 }
661}
662impl serde::Serialize for AddEventLogRequest {
663 #[allow(deprecated)]
664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
665 where
666 S: serde::Serializer,
667 {
668 use serde::ser::SerializeStruct;
669 let mut len = 0;
670 if self.event.is_some() {
671 len += 1;
672 }
673 let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
674 if let Some(v) = self.event.as_ref() {
675 match v {
676 add_event_log_request::Event::WorkerNodePanic(v) => {
677 struct_ser.serialize_field("workerNodePanic", v)?;
678 }
679 add_event_log_request::Event::SinkFail(v) => {
680 struct_ser.serialize_field("sinkFail", v)?;
681 }
682 }
683 }
684 struct_ser.end()
685 }
686}
687impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
688 #[allow(deprecated)]
689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
690 where
691 D: serde::Deserializer<'de>,
692 {
693 const FIELDS: &[&str] = &[
694 "worker_node_panic",
695 "workerNodePanic",
696 "sink_fail",
697 "sinkFail",
698 ];
699
700 #[allow(clippy::enum_variant_names)]
701 enum GeneratedField {
702 WorkerNodePanic,
703 SinkFail,
704 }
705 impl<'de> serde::Deserialize<'de> for GeneratedField {
706 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
707 where
708 D: serde::Deserializer<'de>,
709 {
710 struct GeneratedVisitor;
711
712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
713 type Value = GeneratedField;
714
715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
716 write!(formatter, "expected one of: {:?}", &FIELDS)
717 }
718
719 #[allow(unused_variables)]
720 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
721 where
722 E: serde::de::Error,
723 {
724 match value {
725 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
726 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
728 }
729 }
730 }
731 deserializer.deserialize_identifier(GeneratedVisitor)
732 }
733 }
734 struct GeneratedVisitor;
735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
736 type Value = AddEventLogRequest;
737
738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
739 formatter.write_str("struct meta.AddEventLogRequest")
740 }
741
742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
743 where
744 V: serde::de::MapAccess<'de>,
745 {
746 let mut event__ = None;
747 while let Some(k) = map_.next_key()? {
748 match k {
749 GeneratedField::WorkerNodePanic => {
750 if event__.is_some() {
751 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
752 }
753 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
754;
755 }
756 GeneratedField::SinkFail => {
757 if event__.is_some() {
758 return Err(serde::de::Error::duplicate_field("sinkFail"));
759 }
760 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
761;
762 }
763 }
764 }
765 Ok(AddEventLogRequest {
766 event: event__,
767 })
768 }
769 }
770 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
771 }
772}
773impl serde::Serialize for AddEventLogResponse {
774 #[allow(deprecated)]
775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
776 where
777 S: serde::Serializer,
778 {
779 use serde::ser::SerializeStruct;
780 let len = 0;
781 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
782 struct_ser.end()
783 }
784}
785impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
786 #[allow(deprecated)]
787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
788 where
789 D: serde::Deserializer<'de>,
790 {
791 const FIELDS: &[&str] = &[
792 ];
793
794 #[allow(clippy::enum_variant_names)]
795 enum GeneratedField {
796 }
797 impl<'de> serde::Deserialize<'de> for GeneratedField {
798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
799 where
800 D: serde::Deserializer<'de>,
801 {
802 struct GeneratedVisitor;
803
804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
805 type Value = GeneratedField;
806
807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
808 write!(formatter, "expected one of: {:?}", &FIELDS)
809 }
810
811 #[allow(unused_variables)]
812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
813 where
814 E: serde::de::Error,
815 {
816 Err(serde::de::Error::unknown_field(value, FIELDS))
817 }
818 }
819 deserializer.deserialize_identifier(GeneratedVisitor)
820 }
821 }
822 struct GeneratedVisitor;
823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
824 type Value = AddEventLogResponse;
825
826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
827 formatter.write_str("struct meta.AddEventLogResponse")
828 }
829
830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
831 where
832 V: serde::de::MapAccess<'de>,
833 {
834 while map_.next_key::<GeneratedField>()?.is_some() {
835 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
836 }
837 Ok(AddEventLogResponse {
838 })
839 }
840 }
841 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
842 }
843}
844impl serde::Serialize for AddWorkerNodeRequest {
845 #[allow(deprecated)]
846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
847 where
848 S: serde::Serializer,
849 {
850 use serde::ser::SerializeStruct;
851 let mut len = 0;
852 if self.worker_type != 0 {
853 len += 1;
854 }
855 if self.host.is_some() {
856 len += 1;
857 }
858 if self.resource.is_some() {
859 len += 1;
860 }
861 if self.property.is_some() {
862 len += 1;
863 }
864 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
865 if self.worker_type != 0 {
866 let v = super::common::WorkerType::try_from(self.worker_type)
867 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
868 struct_ser.serialize_field("workerType", &v)?;
869 }
870 if let Some(v) = self.host.as_ref() {
871 struct_ser.serialize_field("host", v)?;
872 }
873 if let Some(v) = self.resource.as_ref() {
874 struct_ser.serialize_field("resource", v)?;
875 }
876 if let Some(v) = self.property.as_ref() {
877 struct_ser.serialize_field("property", v)?;
878 }
879 struct_ser.end()
880 }
881}
882impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
883 #[allow(deprecated)]
884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
885 where
886 D: serde::Deserializer<'de>,
887 {
888 const FIELDS: &[&str] = &[
889 "worker_type",
890 "workerType",
891 "host",
892 "resource",
893 "property",
894 ];
895
896 #[allow(clippy::enum_variant_names)]
897 enum GeneratedField {
898 WorkerType,
899 Host,
900 Resource,
901 Property,
902 }
903 impl<'de> serde::Deserialize<'de> for GeneratedField {
904 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
905 where
906 D: serde::Deserializer<'de>,
907 {
908 struct GeneratedVisitor;
909
910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
911 type Value = GeneratedField;
912
913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
914 write!(formatter, "expected one of: {:?}", &FIELDS)
915 }
916
917 #[allow(unused_variables)]
918 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
919 where
920 E: serde::de::Error,
921 {
922 match value {
923 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
924 "host" => Ok(GeneratedField::Host),
925 "resource" => Ok(GeneratedField::Resource),
926 "property" => Ok(GeneratedField::Property),
927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
928 }
929 }
930 }
931 deserializer.deserialize_identifier(GeneratedVisitor)
932 }
933 }
934 struct GeneratedVisitor;
935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
936 type Value = AddWorkerNodeRequest;
937
938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
939 formatter.write_str("struct meta.AddWorkerNodeRequest")
940 }
941
942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
943 where
944 V: serde::de::MapAccess<'de>,
945 {
946 let mut worker_type__ = None;
947 let mut host__ = None;
948 let mut resource__ = None;
949 let mut property__ = None;
950 while let Some(k) = map_.next_key()? {
951 match k {
952 GeneratedField::WorkerType => {
953 if worker_type__.is_some() {
954 return Err(serde::de::Error::duplicate_field("workerType"));
955 }
956 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
957 }
958 GeneratedField::Host => {
959 if host__.is_some() {
960 return Err(serde::de::Error::duplicate_field("host"));
961 }
962 host__ = map_.next_value()?;
963 }
964 GeneratedField::Resource => {
965 if resource__.is_some() {
966 return Err(serde::de::Error::duplicate_field("resource"));
967 }
968 resource__ = map_.next_value()?;
969 }
970 GeneratedField::Property => {
971 if property__.is_some() {
972 return Err(serde::de::Error::duplicate_field("property"));
973 }
974 property__ = map_.next_value()?;
975 }
976 }
977 }
978 Ok(AddWorkerNodeRequest {
979 worker_type: worker_type__.unwrap_or_default(),
980 host: host__,
981 resource: resource__,
982 property: property__,
983 })
984 }
985 }
986 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
987 }
988}
989impl serde::Serialize for AddWorkerNodeResponse {
990 #[allow(deprecated)]
991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
992 where
993 S: serde::Serializer,
994 {
995 use serde::ser::SerializeStruct;
996 let mut len = 0;
997 if self.node_id.is_some() {
998 len += 1;
999 }
1000 if !self.cluster_id.is_empty() {
1001 len += 1;
1002 }
1003 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1004 if let Some(v) = self.node_id.as_ref() {
1005 struct_ser.serialize_field("nodeId", v)?;
1006 }
1007 if !self.cluster_id.is_empty() {
1008 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1009 }
1010 struct_ser.end()
1011 }
1012}
1013impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1014 #[allow(deprecated)]
1015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1016 where
1017 D: serde::Deserializer<'de>,
1018 {
1019 const FIELDS: &[&str] = &[
1020 "node_id",
1021 "nodeId",
1022 "cluster_id",
1023 "clusterId",
1024 ];
1025
1026 #[allow(clippy::enum_variant_names)]
1027 enum GeneratedField {
1028 NodeId,
1029 ClusterId,
1030 }
1031 impl<'de> serde::Deserialize<'de> for GeneratedField {
1032 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1033 where
1034 D: serde::Deserializer<'de>,
1035 {
1036 struct GeneratedVisitor;
1037
1038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1039 type Value = GeneratedField;
1040
1041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1042 write!(formatter, "expected one of: {:?}", &FIELDS)
1043 }
1044
1045 #[allow(unused_variables)]
1046 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1047 where
1048 E: serde::de::Error,
1049 {
1050 match value {
1051 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1052 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1054 }
1055 }
1056 }
1057 deserializer.deserialize_identifier(GeneratedVisitor)
1058 }
1059 }
1060 struct GeneratedVisitor;
1061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1062 type Value = AddWorkerNodeResponse;
1063
1064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1065 formatter.write_str("struct meta.AddWorkerNodeResponse")
1066 }
1067
1068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1069 where
1070 V: serde::de::MapAccess<'de>,
1071 {
1072 let mut node_id__ = None;
1073 let mut cluster_id__ = None;
1074 while let Some(k) = map_.next_key()? {
1075 match k {
1076 GeneratedField::NodeId => {
1077 if node_id__.is_some() {
1078 return Err(serde::de::Error::duplicate_field("nodeId"));
1079 }
1080 node_id__ =
1081 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1082 ;
1083 }
1084 GeneratedField::ClusterId => {
1085 if cluster_id__.is_some() {
1086 return Err(serde::de::Error::duplicate_field("clusterId"));
1087 }
1088 cluster_id__ = Some(map_.next_value()?);
1089 }
1090 }
1091 }
1092 Ok(AddWorkerNodeResponse {
1093 node_id: node_id__,
1094 cluster_id: cluster_id__.unwrap_or_default(),
1095 })
1096 }
1097 }
1098 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1099 }
1100}
1101impl serde::Serialize for AlterConnectorPropsRequest {
1102 #[allow(deprecated)]
1103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1104 where
1105 S: serde::Serializer,
1106 {
1107 use serde::ser::SerializeStruct;
1108 let mut len = 0;
1109 if self.object_id != 0 {
1110 len += 1;
1111 }
1112 if !self.changed_props.is_empty() {
1113 len += 1;
1114 }
1115 if !self.changed_secret_refs.is_empty() {
1116 len += 1;
1117 }
1118 if self.connector_conn_ref.is_some() {
1119 len += 1;
1120 }
1121 if self.object_type != 0 {
1122 len += 1;
1123 }
1124 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1125 if self.object_id != 0 {
1126 struct_ser.serialize_field("objectId", &self.object_id)?;
1127 }
1128 if !self.changed_props.is_empty() {
1129 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1130 }
1131 if !self.changed_secret_refs.is_empty() {
1132 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1133 }
1134 if let Some(v) = self.connector_conn_ref.as_ref() {
1135 struct_ser.serialize_field("connectorConnRef", v)?;
1136 }
1137 if self.object_type != 0 {
1138 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1139 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1140 struct_ser.serialize_field("objectType", &v)?;
1141 }
1142 struct_ser.end()
1143 }
1144}
1145impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1146 #[allow(deprecated)]
1147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1148 where
1149 D: serde::Deserializer<'de>,
1150 {
1151 const FIELDS: &[&str] = &[
1152 "object_id",
1153 "objectId",
1154 "changed_props",
1155 "changedProps",
1156 "changed_secret_refs",
1157 "changedSecretRefs",
1158 "connector_conn_ref",
1159 "connectorConnRef",
1160 "object_type",
1161 "objectType",
1162 ];
1163
1164 #[allow(clippy::enum_variant_names)]
1165 enum GeneratedField {
1166 ObjectId,
1167 ChangedProps,
1168 ChangedSecretRefs,
1169 ConnectorConnRef,
1170 ObjectType,
1171 }
1172 impl<'de> serde::Deserialize<'de> for GeneratedField {
1173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1174 where
1175 D: serde::Deserializer<'de>,
1176 {
1177 struct GeneratedVisitor;
1178
1179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1180 type Value = GeneratedField;
1181
1182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1183 write!(formatter, "expected one of: {:?}", &FIELDS)
1184 }
1185
1186 #[allow(unused_variables)]
1187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1188 where
1189 E: serde::de::Error,
1190 {
1191 match value {
1192 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1193 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1194 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1195 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1196 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1197 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1198 }
1199 }
1200 }
1201 deserializer.deserialize_identifier(GeneratedVisitor)
1202 }
1203 }
1204 struct GeneratedVisitor;
1205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1206 type Value = AlterConnectorPropsRequest;
1207
1208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1209 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1210 }
1211
1212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1213 where
1214 V: serde::de::MapAccess<'de>,
1215 {
1216 let mut object_id__ = None;
1217 let mut changed_props__ = None;
1218 let mut changed_secret_refs__ = None;
1219 let mut connector_conn_ref__ = None;
1220 let mut object_type__ = None;
1221 while let Some(k) = map_.next_key()? {
1222 match k {
1223 GeneratedField::ObjectId => {
1224 if object_id__.is_some() {
1225 return Err(serde::de::Error::duplicate_field("objectId"));
1226 }
1227 object_id__ =
1228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1229 ;
1230 }
1231 GeneratedField::ChangedProps => {
1232 if changed_props__.is_some() {
1233 return Err(serde::de::Error::duplicate_field("changedProps"));
1234 }
1235 changed_props__ = Some(
1236 map_.next_value::<std::collections::HashMap<_, _>>()?
1237 );
1238 }
1239 GeneratedField::ChangedSecretRefs => {
1240 if changed_secret_refs__.is_some() {
1241 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1242 }
1243 changed_secret_refs__ = Some(
1244 map_.next_value::<std::collections::HashMap<_, _>>()?
1245 );
1246 }
1247 GeneratedField::ConnectorConnRef => {
1248 if connector_conn_ref__.is_some() {
1249 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1250 }
1251 connector_conn_ref__ =
1252 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1253 ;
1254 }
1255 GeneratedField::ObjectType => {
1256 if object_type__.is_some() {
1257 return Err(serde::de::Error::duplicate_field("objectType"));
1258 }
1259 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1260 }
1261 }
1262 }
1263 Ok(AlterConnectorPropsRequest {
1264 object_id: object_id__.unwrap_or_default(),
1265 changed_props: changed_props__.unwrap_or_default(),
1266 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1267 connector_conn_ref: connector_conn_ref__,
1268 object_type: object_type__.unwrap_or_default(),
1269 })
1270 }
1271 }
1272 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1273 }
1274}
1275impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1276 #[allow(deprecated)]
1277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1278 where
1279 S: serde::Serializer,
1280 {
1281 let variant = match self {
1282 Self::Unspecified => "UNSPECIFIED",
1283 Self::Source => "SOURCE",
1284 Self::Sink => "SINK",
1285 Self::Connection => "CONNECTION",
1286 };
1287 serializer.serialize_str(variant)
1288 }
1289}
1290impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1291 #[allow(deprecated)]
1292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1293 where
1294 D: serde::Deserializer<'de>,
1295 {
1296 const FIELDS: &[&str] = &[
1297 "UNSPECIFIED",
1298 "SOURCE",
1299 "SINK",
1300 "CONNECTION",
1301 ];
1302
1303 struct GeneratedVisitor;
1304
1305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1306 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1307
1308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1309 write!(formatter, "expected one of: {:?}", &FIELDS)
1310 }
1311
1312 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1313 where
1314 E: serde::de::Error,
1315 {
1316 i32::try_from(v)
1317 .ok()
1318 .and_then(|x| x.try_into().ok())
1319 .ok_or_else(|| {
1320 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1321 })
1322 }
1323
1324 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1325 where
1326 E: serde::de::Error,
1327 {
1328 i32::try_from(v)
1329 .ok()
1330 .and_then(|x| x.try_into().ok())
1331 .ok_or_else(|| {
1332 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1333 })
1334 }
1335
1336 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1337 where
1338 E: serde::de::Error,
1339 {
1340 match value {
1341 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1342 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1343 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1344 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1345 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1346 }
1347 }
1348 }
1349 deserializer.deserialize_any(GeneratedVisitor)
1350 }
1351}
1352impl serde::Serialize for AlterConnectorPropsResponse {
1353 #[allow(deprecated)]
1354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1355 where
1356 S: serde::Serializer,
1357 {
1358 use serde::ser::SerializeStruct;
1359 let len = 0;
1360 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1361 struct_ser.end()
1362 }
1363}
1364impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1365 #[allow(deprecated)]
1366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1367 where
1368 D: serde::Deserializer<'de>,
1369 {
1370 const FIELDS: &[&str] = &[
1371 ];
1372
1373 #[allow(clippy::enum_variant_names)]
1374 enum GeneratedField {
1375 }
1376 impl<'de> serde::Deserialize<'de> for GeneratedField {
1377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1378 where
1379 D: serde::Deserializer<'de>,
1380 {
1381 struct GeneratedVisitor;
1382
1383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1384 type Value = GeneratedField;
1385
1386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1387 write!(formatter, "expected one of: {:?}", &FIELDS)
1388 }
1389
1390 #[allow(unused_variables)]
1391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1392 where
1393 E: serde::de::Error,
1394 {
1395 Err(serde::de::Error::unknown_field(value, FIELDS))
1396 }
1397 }
1398 deserializer.deserialize_identifier(GeneratedVisitor)
1399 }
1400 }
1401 struct GeneratedVisitor;
1402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1403 type Value = AlterConnectorPropsResponse;
1404
1405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1406 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1407 }
1408
1409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1410 where
1411 V: serde::de::MapAccess<'de>,
1412 {
1413 while map_.next_key::<GeneratedField>()?.is_some() {
1414 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1415 }
1416 Ok(AlterConnectorPropsResponse {
1417 })
1418 }
1419 }
1420 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1421 }
1422}
1423impl serde::Serialize for ApplyThrottleRequest {
1424 #[allow(deprecated)]
1425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426 where
1427 S: serde::Serializer,
1428 {
1429 use serde::ser::SerializeStruct;
1430 let mut len = 0;
1431 if self.kind != 0 {
1432 len += 1;
1433 }
1434 if self.id != 0 {
1435 len += 1;
1436 }
1437 if self.rate.is_some() {
1438 len += 1;
1439 }
1440 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1441 if self.kind != 0 {
1442 let v = ThrottleTarget::try_from(self.kind)
1443 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1444 struct_ser.serialize_field("kind", &v)?;
1445 }
1446 if self.id != 0 {
1447 struct_ser.serialize_field("id", &self.id)?;
1448 }
1449 if let Some(v) = self.rate.as_ref() {
1450 struct_ser.serialize_field("rate", v)?;
1451 }
1452 struct_ser.end()
1453 }
1454}
1455impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1456 #[allow(deprecated)]
1457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1458 where
1459 D: serde::Deserializer<'de>,
1460 {
1461 const FIELDS: &[&str] = &[
1462 "kind",
1463 "id",
1464 "rate",
1465 ];
1466
1467 #[allow(clippy::enum_variant_names)]
1468 enum GeneratedField {
1469 Kind,
1470 Id,
1471 Rate,
1472 }
1473 impl<'de> serde::Deserialize<'de> for GeneratedField {
1474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1475 where
1476 D: serde::Deserializer<'de>,
1477 {
1478 struct GeneratedVisitor;
1479
1480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1481 type Value = GeneratedField;
1482
1483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1484 write!(formatter, "expected one of: {:?}", &FIELDS)
1485 }
1486
1487 #[allow(unused_variables)]
1488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1489 where
1490 E: serde::de::Error,
1491 {
1492 match value {
1493 "kind" => Ok(GeneratedField::Kind),
1494 "id" => Ok(GeneratedField::Id),
1495 "rate" => Ok(GeneratedField::Rate),
1496 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1497 }
1498 }
1499 }
1500 deserializer.deserialize_identifier(GeneratedVisitor)
1501 }
1502 }
1503 struct GeneratedVisitor;
1504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1505 type Value = ApplyThrottleRequest;
1506
1507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1508 formatter.write_str("struct meta.ApplyThrottleRequest")
1509 }
1510
1511 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1512 where
1513 V: serde::de::MapAccess<'de>,
1514 {
1515 let mut kind__ = None;
1516 let mut id__ = None;
1517 let mut rate__ = None;
1518 while let Some(k) = map_.next_key()? {
1519 match k {
1520 GeneratedField::Kind => {
1521 if kind__.is_some() {
1522 return Err(serde::de::Error::duplicate_field("kind"));
1523 }
1524 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1525 }
1526 GeneratedField::Id => {
1527 if id__.is_some() {
1528 return Err(serde::de::Error::duplicate_field("id"));
1529 }
1530 id__ =
1531 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1532 ;
1533 }
1534 GeneratedField::Rate => {
1535 if rate__.is_some() {
1536 return Err(serde::de::Error::duplicate_field("rate"));
1537 }
1538 rate__ =
1539 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1540 ;
1541 }
1542 }
1543 }
1544 Ok(ApplyThrottleRequest {
1545 kind: kind__.unwrap_or_default(),
1546 id: id__.unwrap_or_default(),
1547 rate: rate__,
1548 })
1549 }
1550 }
1551 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1552 }
1553}
1554impl serde::Serialize for ApplyThrottleResponse {
1555 #[allow(deprecated)]
1556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1557 where
1558 S: serde::Serializer,
1559 {
1560 use serde::ser::SerializeStruct;
1561 let mut len = 0;
1562 if self.status.is_some() {
1563 len += 1;
1564 }
1565 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1566 if let Some(v) = self.status.as_ref() {
1567 struct_ser.serialize_field("status", v)?;
1568 }
1569 struct_ser.end()
1570 }
1571}
1572impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1573 #[allow(deprecated)]
1574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1575 where
1576 D: serde::Deserializer<'de>,
1577 {
1578 const FIELDS: &[&str] = &[
1579 "status",
1580 ];
1581
1582 #[allow(clippy::enum_variant_names)]
1583 enum GeneratedField {
1584 Status,
1585 }
1586 impl<'de> serde::Deserialize<'de> for GeneratedField {
1587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1588 where
1589 D: serde::Deserializer<'de>,
1590 {
1591 struct GeneratedVisitor;
1592
1593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1594 type Value = GeneratedField;
1595
1596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1597 write!(formatter, "expected one of: {:?}", &FIELDS)
1598 }
1599
1600 #[allow(unused_variables)]
1601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1602 where
1603 E: serde::de::Error,
1604 {
1605 match value {
1606 "status" => Ok(GeneratedField::Status),
1607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1608 }
1609 }
1610 }
1611 deserializer.deserialize_identifier(GeneratedVisitor)
1612 }
1613 }
1614 struct GeneratedVisitor;
1615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1616 type Value = ApplyThrottleResponse;
1617
1618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1619 formatter.write_str("struct meta.ApplyThrottleResponse")
1620 }
1621
1622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1623 where
1624 V: serde::de::MapAccess<'de>,
1625 {
1626 let mut status__ = None;
1627 while let Some(k) = map_.next_key()? {
1628 match k {
1629 GeneratedField::Status => {
1630 if status__.is_some() {
1631 return Err(serde::de::Error::duplicate_field("status"));
1632 }
1633 status__ = map_.next_value()?;
1634 }
1635 }
1636 }
1637 Ok(ApplyThrottleResponse {
1638 status: status__,
1639 })
1640 }
1641 }
1642 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1643 }
1644}
1645impl serde::Serialize for CancelCreatingJobsRequest {
1646 #[allow(deprecated)]
1647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1648 where
1649 S: serde::Serializer,
1650 {
1651 use serde::ser::SerializeStruct;
1652 let mut len = 0;
1653 if self.jobs.is_some() {
1654 len += 1;
1655 }
1656 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1657 if let Some(v) = self.jobs.as_ref() {
1658 match v {
1659 cancel_creating_jobs_request::Jobs::Infos(v) => {
1660 struct_ser.serialize_field("infos", v)?;
1661 }
1662 cancel_creating_jobs_request::Jobs::Ids(v) => {
1663 struct_ser.serialize_field("ids", v)?;
1664 }
1665 }
1666 }
1667 struct_ser.end()
1668 }
1669}
1670impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1671 #[allow(deprecated)]
1672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1673 where
1674 D: serde::Deserializer<'de>,
1675 {
1676 const FIELDS: &[&str] = &[
1677 "infos",
1678 "ids",
1679 ];
1680
1681 #[allow(clippy::enum_variant_names)]
1682 enum GeneratedField {
1683 Infos,
1684 Ids,
1685 }
1686 impl<'de> serde::Deserialize<'de> for GeneratedField {
1687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1688 where
1689 D: serde::Deserializer<'de>,
1690 {
1691 struct GeneratedVisitor;
1692
1693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1694 type Value = GeneratedField;
1695
1696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1697 write!(formatter, "expected one of: {:?}", &FIELDS)
1698 }
1699
1700 #[allow(unused_variables)]
1701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1702 where
1703 E: serde::de::Error,
1704 {
1705 match value {
1706 "infos" => Ok(GeneratedField::Infos),
1707 "ids" => Ok(GeneratedField::Ids),
1708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1709 }
1710 }
1711 }
1712 deserializer.deserialize_identifier(GeneratedVisitor)
1713 }
1714 }
1715 struct GeneratedVisitor;
1716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1717 type Value = CancelCreatingJobsRequest;
1718
1719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1720 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1721 }
1722
1723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1724 where
1725 V: serde::de::MapAccess<'de>,
1726 {
1727 let mut jobs__ = None;
1728 while let Some(k) = map_.next_key()? {
1729 match k {
1730 GeneratedField::Infos => {
1731 if jobs__.is_some() {
1732 return Err(serde::de::Error::duplicate_field("infos"));
1733 }
1734 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1735;
1736 }
1737 GeneratedField::Ids => {
1738 if jobs__.is_some() {
1739 return Err(serde::de::Error::duplicate_field("ids"));
1740 }
1741 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1742;
1743 }
1744 }
1745 }
1746 Ok(CancelCreatingJobsRequest {
1747 jobs: jobs__,
1748 })
1749 }
1750 }
1751 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1752 }
1753}
1754impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1755 #[allow(deprecated)]
1756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1757 where
1758 S: serde::Serializer,
1759 {
1760 use serde::ser::SerializeStruct;
1761 let mut len = 0;
1762 if !self.job_ids.is_empty() {
1763 len += 1;
1764 }
1765 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1766 if !self.job_ids.is_empty() {
1767 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1768 }
1769 struct_ser.end()
1770 }
1771}
1772impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1773 #[allow(deprecated)]
1774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1775 where
1776 D: serde::Deserializer<'de>,
1777 {
1778 const FIELDS: &[&str] = &[
1779 "job_ids",
1780 "jobIds",
1781 ];
1782
1783 #[allow(clippy::enum_variant_names)]
1784 enum GeneratedField {
1785 JobIds,
1786 }
1787 impl<'de> serde::Deserialize<'de> for GeneratedField {
1788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1789 where
1790 D: serde::Deserializer<'de>,
1791 {
1792 struct GeneratedVisitor;
1793
1794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1795 type Value = GeneratedField;
1796
1797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1798 write!(formatter, "expected one of: {:?}", &FIELDS)
1799 }
1800
1801 #[allow(unused_variables)]
1802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1803 where
1804 E: serde::de::Error,
1805 {
1806 match value {
1807 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1809 }
1810 }
1811 }
1812 deserializer.deserialize_identifier(GeneratedVisitor)
1813 }
1814 }
1815 struct GeneratedVisitor;
1816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1817 type Value = cancel_creating_jobs_request::CreatingJobIds;
1818
1819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1820 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1821 }
1822
1823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1824 where
1825 V: serde::de::MapAccess<'de>,
1826 {
1827 let mut job_ids__ = None;
1828 while let Some(k) = map_.next_key()? {
1829 match k {
1830 GeneratedField::JobIds => {
1831 if job_ids__.is_some() {
1832 return Err(serde::de::Error::duplicate_field("jobIds"));
1833 }
1834 job_ids__ =
1835 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1836 .into_iter().map(|x| x.0).collect())
1837 ;
1838 }
1839 }
1840 }
1841 Ok(cancel_creating_jobs_request::CreatingJobIds {
1842 job_ids: job_ids__.unwrap_or_default(),
1843 })
1844 }
1845 }
1846 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
1847 }
1848}
1849impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
1850 #[allow(deprecated)]
1851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1852 where
1853 S: serde::Serializer,
1854 {
1855 use serde::ser::SerializeStruct;
1856 let mut len = 0;
1857 if self.database_id != 0 {
1858 len += 1;
1859 }
1860 if self.schema_id != 0 {
1861 len += 1;
1862 }
1863 if !self.name.is_empty() {
1864 len += 1;
1865 }
1866 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
1867 if self.database_id != 0 {
1868 struct_ser.serialize_field("databaseId", &self.database_id)?;
1869 }
1870 if self.schema_id != 0 {
1871 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1872 }
1873 if !self.name.is_empty() {
1874 struct_ser.serialize_field("name", &self.name)?;
1875 }
1876 struct_ser.end()
1877 }
1878}
1879impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
1880 #[allow(deprecated)]
1881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1882 where
1883 D: serde::Deserializer<'de>,
1884 {
1885 const FIELDS: &[&str] = &[
1886 "database_id",
1887 "databaseId",
1888 "schema_id",
1889 "schemaId",
1890 "name",
1891 ];
1892
1893 #[allow(clippy::enum_variant_names)]
1894 enum GeneratedField {
1895 DatabaseId,
1896 SchemaId,
1897 Name,
1898 }
1899 impl<'de> serde::Deserialize<'de> for GeneratedField {
1900 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1901 where
1902 D: serde::Deserializer<'de>,
1903 {
1904 struct GeneratedVisitor;
1905
1906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1907 type Value = GeneratedField;
1908
1909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1910 write!(formatter, "expected one of: {:?}", &FIELDS)
1911 }
1912
1913 #[allow(unused_variables)]
1914 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1915 where
1916 E: serde::de::Error,
1917 {
1918 match value {
1919 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1920 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1921 "name" => Ok(GeneratedField::Name),
1922 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1923 }
1924 }
1925 }
1926 deserializer.deserialize_identifier(GeneratedVisitor)
1927 }
1928 }
1929 struct GeneratedVisitor;
1930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1931 type Value = cancel_creating_jobs_request::CreatingJobInfo;
1932
1933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1934 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
1935 }
1936
1937 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
1938 where
1939 V: serde::de::MapAccess<'de>,
1940 {
1941 let mut database_id__ = None;
1942 let mut schema_id__ = None;
1943 let mut name__ = None;
1944 while let Some(k) = map_.next_key()? {
1945 match k {
1946 GeneratedField::DatabaseId => {
1947 if database_id__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("databaseId"));
1949 }
1950 database_id__ =
1951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1952 ;
1953 }
1954 GeneratedField::SchemaId => {
1955 if schema_id__.is_some() {
1956 return Err(serde::de::Error::duplicate_field("schemaId"));
1957 }
1958 schema_id__ =
1959 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1960 ;
1961 }
1962 GeneratedField::Name => {
1963 if name__.is_some() {
1964 return Err(serde::de::Error::duplicate_field("name"));
1965 }
1966 name__ = Some(map_.next_value()?);
1967 }
1968 }
1969 }
1970 Ok(cancel_creating_jobs_request::CreatingJobInfo {
1971 database_id: database_id__.unwrap_or_default(),
1972 schema_id: schema_id__.unwrap_or_default(),
1973 name: name__.unwrap_or_default(),
1974 })
1975 }
1976 }
1977 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
1978 }
1979}
1980impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
1981 #[allow(deprecated)]
1982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1983 where
1984 S: serde::Serializer,
1985 {
1986 use serde::ser::SerializeStruct;
1987 let mut len = 0;
1988 if !self.infos.is_empty() {
1989 len += 1;
1990 }
1991 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
1992 if !self.infos.is_empty() {
1993 struct_ser.serialize_field("infos", &self.infos)?;
1994 }
1995 struct_ser.end()
1996 }
1997}
1998impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
1999 #[allow(deprecated)]
2000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2001 where
2002 D: serde::Deserializer<'de>,
2003 {
2004 const FIELDS: &[&str] = &[
2005 "infos",
2006 ];
2007
2008 #[allow(clippy::enum_variant_names)]
2009 enum GeneratedField {
2010 Infos,
2011 }
2012 impl<'de> serde::Deserialize<'de> for GeneratedField {
2013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2014 where
2015 D: serde::Deserializer<'de>,
2016 {
2017 struct GeneratedVisitor;
2018
2019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2020 type Value = GeneratedField;
2021
2022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2023 write!(formatter, "expected one of: {:?}", &FIELDS)
2024 }
2025
2026 #[allow(unused_variables)]
2027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2028 where
2029 E: serde::de::Error,
2030 {
2031 match value {
2032 "infos" => Ok(GeneratedField::Infos),
2033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2034 }
2035 }
2036 }
2037 deserializer.deserialize_identifier(GeneratedVisitor)
2038 }
2039 }
2040 struct GeneratedVisitor;
2041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2042 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2043
2044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2045 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2046 }
2047
2048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2049 where
2050 V: serde::de::MapAccess<'de>,
2051 {
2052 let mut infos__ = None;
2053 while let Some(k) = map_.next_key()? {
2054 match k {
2055 GeneratedField::Infos => {
2056 if infos__.is_some() {
2057 return Err(serde::de::Error::duplicate_field("infos"));
2058 }
2059 infos__ = Some(map_.next_value()?);
2060 }
2061 }
2062 }
2063 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2064 infos: infos__.unwrap_or_default(),
2065 })
2066 }
2067 }
2068 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2069 }
2070}
2071impl serde::Serialize for CancelCreatingJobsResponse {
2072 #[allow(deprecated)]
2073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2074 where
2075 S: serde::Serializer,
2076 {
2077 use serde::ser::SerializeStruct;
2078 let mut len = 0;
2079 if self.status.is_some() {
2080 len += 1;
2081 }
2082 if !self.canceled_jobs.is_empty() {
2083 len += 1;
2084 }
2085 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2086 if let Some(v) = self.status.as_ref() {
2087 struct_ser.serialize_field("status", v)?;
2088 }
2089 if !self.canceled_jobs.is_empty() {
2090 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2091 }
2092 struct_ser.end()
2093 }
2094}
2095impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2096 #[allow(deprecated)]
2097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2098 where
2099 D: serde::Deserializer<'de>,
2100 {
2101 const FIELDS: &[&str] = &[
2102 "status",
2103 "canceled_jobs",
2104 "canceledJobs",
2105 ];
2106
2107 #[allow(clippy::enum_variant_names)]
2108 enum GeneratedField {
2109 Status,
2110 CanceledJobs,
2111 }
2112 impl<'de> serde::Deserialize<'de> for GeneratedField {
2113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2114 where
2115 D: serde::Deserializer<'de>,
2116 {
2117 struct GeneratedVisitor;
2118
2119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2120 type Value = GeneratedField;
2121
2122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2123 write!(formatter, "expected one of: {:?}", &FIELDS)
2124 }
2125
2126 #[allow(unused_variables)]
2127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2128 where
2129 E: serde::de::Error,
2130 {
2131 match value {
2132 "status" => Ok(GeneratedField::Status),
2133 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2135 }
2136 }
2137 }
2138 deserializer.deserialize_identifier(GeneratedVisitor)
2139 }
2140 }
2141 struct GeneratedVisitor;
2142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2143 type Value = CancelCreatingJobsResponse;
2144
2145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2146 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2147 }
2148
2149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2150 where
2151 V: serde::de::MapAccess<'de>,
2152 {
2153 let mut status__ = None;
2154 let mut canceled_jobs__ = None;
2155 while let Some(k) = map_.next_key()? {
2156 match k {
2157 GeneratedField::Status => {
2158 if status__.is_some() {
2159 return Err(serde::de::Error::duplicate_field("status"));
2160 }
2161 status__ = map_.next_value()?;
2162 }
2163 GeneratedField::CanceledJobs => {
2164 if canceled_jobs__.is_some() {
2165 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2166 }
2167 canceled_jobs__ =
2168 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2169 .into_iter().map(|x| x.0).collect())
2170 ;
2171 }
2172 }
2173 }
2174 Ok(CancelCreatingJobsResponse {
2175 status: status__,
2176 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2177 })
2178 }
2179 }
2180 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2181 }
2182}
2183impl serde::Serialize for ClusterLimit {
2184 #[allow(deprecated)]
2185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2186 where
2187 S: serde::Serializer,
2188 {
2189 use serde::ser::SerializeStruct;
2190 let mut len = 0;
2191 if self.limit.is_some() {
2192 len += 1;
2193 }
2194 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2195 if let Some(v) = self.limit.as_ref() {
2196 match v {
2197 cluster_limit::Limit::ActorCount(v) => {
2198 struct_ser.serialize_field("actorCount", v)?;
2199 }
2200 }
2201 }
2202 struct_ser.end()
2203 }
2204}
2205impl<'de> serde::Deserialize<'de> for ClusterLimit {
2206 #[allow(deprecated)]
2207 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2208 where
2209 D: serde::Deserializer<'de>,
2210 {
2211 const FIELDS: &[&str] = &[
2212 "actor_count",
2213 "actorCount",
2214 ];
2215
2216 #[allow(clippy::enum_variant_names)]
2217 enum GeneratedField {
2218 ActorCount,
2219 }
2220 impl<'de> serde::Deserialize<'de> for GeneratedField {
2221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2222 where
2223 D: serde::Deserializer<'de>,
2224 {
2225 struct GeneratedVisitor;
2226
2227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2228 type Value = GeneratedField;
2229
2230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2231 write!(formatter, "expected one of: {:?}", &FIELDS)
2232 }
2233
2234 #[allow(unused_variables)]
2235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2236 where
2237 E: serde::de::Error,
2238 {
2239 match value {
2240 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2242 }
2243 }
2244 }
2245 deserializer.deserialize_identifier(GeneratedVisitor)
2246 }
2247 }
2248 struct GeneratedVisitor;
2249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2250 type Value = ClusterLimit;
2251
2252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2253 formatter.write_str("struct meta.ClusterLimit")
2254 }
2255
2256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2257 where
2258 V: serde::de::MapAccess<'de>,
2259 {
2260 let mut limit__ = None;
2261 while let Some(k) = map_.next_key()? {
2262 match k {
2263 GeneratedField::ActorCount => {
2264 if limit__.is_some() {
2265 return Err(serde::de::Error::duplicate_field("actorCount"));
2266 }
2267 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2268;
2269 }
2270 }
2271 }
2272 Ok(ClusterLimit {
2273 limit: limit__,
2274 })
2275 }
2276 }
2277 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2278 }
2279}
2280impl serde::Serialize for DeleteWorkerNodeRequest {
2281 #[allow(deprecated)]
2282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2283 where
2284 S: serde::Serializer,
2285 {
2286 use serde::ser::SerializeStruct;
2287 let mut len = 0;
2288 if self.host.is_some() {
2289 len += 1;
2290 }
2291 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2292 if let Some(v) = self.host.as_ref() {
2293 struct_ser.serialize_field("host", v)?;
2294 }
2295 struct_ser.end()
2296 }
2297}
2298impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2299 #[allow(deprecated)]
2300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2301 where
2302 D: serde::Deserializer<'de>,
2303 {
2304 const FIELDS: &[&str] = &[
2305 "host",
2306 ];
2307
2308 #[allow(clippy::enum_variant_names)]
2309 enum GeneratedField {
2310 Host,
2311 }
2312 impl<'de> serde::Deserialize<'de> for GeneratedField {
2313 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2314 where
2315 D: serde::Deserializer<'de>,
2316 {
2317 struct GeneratedVisitor;
2318
2319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2320 type Value = GeneratedField;
2321
2322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2323 write!(formatter, "expected one of: {:?}", &FIELDS)
2324 }
2325
2326 #[allow(unused_variables)]
2327 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2328 where
2329 E: serde::de::Error,
2330 {
2331 match value {
2332 "host" => Ok(GeneratedField::Host),
2333 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2334 }
2335 }
2336 }
2337 deserializer.deserialize_identifier(GeneratedVisitor)
2338 }
2339 }
2340 struct GeneratedVisitor;
2341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2342 type Value = DeleteWorkerNodeRequest;
2343
2344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2345 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2346 }
2347
2348 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2349 where
2350 V: serde::de::MapAccess<'de>,
2351 {
2352 let mut host__ = None;
2353 while let Some(k) = map_.next_key()? {
2354 match k {
2355 GeneratedField::Host => {
2356 if host__.is_some() {
2357 return Err(serde::de::Error::duplicate_field("host"));
2358 }
2359 host__ = map_.next_value()?;
2360 }
2361 }
2362 }
2363 Ok(DeleteWorkerNodeRequest {
2364 host: host__,
2365 })
2366 }
2367 }
2368 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2369 }
2370}
2371impl serde::Serialize for DeleteWorkerNodeResponse {
2372 #[allow(deprecated)]
2373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2374 where
2375 S: serde::Serializer,
2376 {
2377 use serde::ser::SerializeStruct;
2378 let mut len = 0;
2379 if self.status.is_some() {
2380 len += 1;
2381 }
2382 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2383 if let Some(v) = self.status.as_ref() {
2384 struct_ser.serialize_field("status", v)?;
2385 }
2386 struct_ser.end()
2387 }
2388}
2389impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2390 #[allow(deprecated)]
2391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2392 where
2393 D: serde::Deserializer<'de>,
2394 {
2395 const FIELDS: &[&str] = &[
2396 "status",
2397 ];
2398
2399 #[allow(clippy::enum_variant_names)]
2400 enum GeneratedField {
2401 Status,
2402 }
2403 impl<'de> serde::Deserialize<'de> for GeneratedField {
2404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2405 where
2406 D: serde::Deserializer<'de>,
2407 {
2408 struct GeneratedVisitor;
2409
2410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2411 type Value = GeneratedField;
2412
2413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2414 write!(formatter, "expected one of: {:?}", &FIELDS)
2415 }
2416
2417 #[allow(unused_variables)]
2418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2419 where
2420 E: serde::de::Error,
2421 {
2422 match value {
2423 "status" => Ok(GeneratedField::Status),
2424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2425 }
2426 }
2427 }
2428 deserializer.deserialize_identifier(GeneratedVisitor)
2429 }
2430 }
2431 struct GeneratedVisitor;
2432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2433 type Value = DeleteWorkerNodeResponse;
2434
2435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2436 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2437 }
2438
2439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2440 where
2441 V: serde::de::MapAccess<'de>,
2442 {
2443 let mut status__ = None;
2444 while let Some(k) = map_.next_key()? {
2445 match k {
2446 GeneratedField::Status => {
2447 if status__.is_some() {
2448 return Err(serde::de::Error::duplicate_field("status"));
2449 }
2450 status__ = map_.next_value()?;
2451 }
2452 }
2453 }
2454 Ok(DeleteWorkerNodeResponse {
2455 status: status__,
2456 })
2457 }
2458 }
2459 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2460 }
2461}
2462impl serde::Serialize for EventLog {
2463 #[allow(deprecated)]
2464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2465 where
2466 S: serde::Serializer,
2467 {
2468 use serde::ser::SerializeStruct;
2469 let mut len = 0;
2470 if self.unique_id.is_some() {
2471 len += 1;
2472 }
2473 if self.timestamp.is_some() {
2474 len += 1;
2475 }
2476 if self.event.is_some() {
2477 len += 1;
2478 }
2479 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2480 if let Some(v) = self.unique_id.as_ref() {
2481 struct_ser.serialize_field("uniqueId", v)?;
2482 }
2483 if let Some(v) = self.timestamp.as_ref() {
2484 #[allow(clippy::needless_borrow)]
2485 #[allow(clippy::needless_borrows_for_generic_args)]
2486 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2487 }
2488 if let Some(v) = self.event.as_ref() {
2489 match v {
2490 event_log::Event::CreateStreamJobFail(v) => {
2491 struct_ser.serialize_field("createStreamJobFail", v)?;
2492 }
2493 event_log::Event::DirtyStreamJobClear(v) => {
2494 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2495 }
2496 event_log::Event::MetaNodeStart(v) => {
2497 struct_ser.serialize_field("metaNodeStart", v)?;
2498 }
2499 event_log::Event::BarrierComplete(v) => {
2500 struct_ser.serialize_field("barrierComplete", v)?;
2501 }
2502 event_log::Event::InjectBarrierFail(v) => {
2503 struct_ser.serialize_field("injectBarrierFail", v)?;
2504 }
2505 event_log::Event::CollectBarrierFail(v) => {
2506 struct_ser.serialize_field("collectBarrierFail", v)?;
2507 }
2508 event_log::Event::WorkerNodePanic(v) => {
2509 struct_ser.serialize_field("workerNodePanic", v)?;
2510 }
2511 event_log::Event::AutoSchemaChangeFail(v) => {
2512 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2513 }
2514 event_log::Event::SinkFail(v) => {
2515 struct_ser.serialize_field("sinkFail", v)?;
2516 }
2517 event_log::Event::Recovery(v) => {
2518 struct_ser.serialize_field("recovery", v)?;
2519 }
2520 }
2521 }
2522 struct_ser.end()
2523 }
2524}
2525impl<'de> serde::Deserialize<'de> for EventLog {
2526 #[allow(deprecated)]
2527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2528 where
2529 D: serde::Deserializer<'de>,
2530 {
2531 const FIELDS: &[&str] = &[
2532 "unique_id",
2533 "uniqueId",
2534 "timestamp",
2535 "create_stream_job_fail",
2536 "createStreamJobFail",
2537 "dirty_stream_job_clear",
2538 "dirtyStreamJobClear",
2539 "meta_node_start",
2540 "metaNodeStart",
2541 "barrier_complete",
2542 "barrierComplete",
2543 "inject_barrier_fail",
2544 "injectBarrierFail",
2545 "collect_barrier_fail",
2546 "collectBarrierFail",
2547 "worker_node_panic",
2548 "workerNodePanic",
2549 "auto_schema_change_fail",
2550 "autoSchemaChangeFail",
2551 "sink_fail",
2552 "sinkFail",
2553 "recovery",
2554 ];
2555
2556 #[allow(clippy::enum_variant_names)]
2557 enum GeneratedField {
2558 UniqueId,
2559 Timestamp,
2560 CreateStreamJobFail,
2561 DirtyStreamJobClear,
2562 MetaNodeStart,
2563 BarrierComplete,
2564 InjectBarrierFail,
2565 CollectBarrierFail,
2566 WorkerNodePanic,
2567 AutoSchemaChangeFail,
2568 SinkFail,
2569 Recovery,
2570 }
2571 impl<'de> serde::Deserialize<'de> for GeneratedField {
2572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2573 where
2574 D: serde::Deserializer<'de>,
2575 {
2576 struct GeneratedVisitor;
2577
2578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2579 type Value = GeneratedField;
2580
2581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2582 write!(formatter, "expected one of: {:?}", &FIELDS)
2583 }
2584
2585 #[allow(unused_variables)]
2586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2587 where
2588 E: serde::de::Error,
2589 {
2590 match value {
2591 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2592 "timestamp" => Ok(GeneratedField::Timestamp),
2593 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2594 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2595 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2596 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2597 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2598 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2599 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2600 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2601 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2602 "recovery" => Ok(GeneratedField::Recovery),
2603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2604 }
2605 }
2606 }
2607 deserializer.deserialize_identifier(GeneratedVisitor)
2608 }
2609 }
2610 struct GeneratedVisitor;
2611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2612 type Value = EventLog;
2613
2614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2615 formatter.write_str("struct meta.EventLog")
2616 }
2617
2618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2619 where
2620 V: serde::de::MapAccess<'de>,
2621 {
2622 let mut unique_id__ = None;
2623 let mut timestamp__ = None;
2624 let mut event__ = None;
2625 while let Some(k) = map_.next_key()? {
2626 match k {
2627 GeneratedField::UniqueId => {
2628 if unique_id__.is_some() {
2629 return Err(serde::de::Error::duplicate_field("uniqueId"));
2630 }
2631 unique_id__ = map_.next_value()?;
2632 }
2633 GeneratedField::Timestamp => {
2634 if timestamp__.is_some() {
2635 return Err(serde::de::Error::duplicate_field("timestamp"));
2636 }
2637 timestamp__ =
2638 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2639 ;
2640 }
2641 GeneratedField::CreateStreamJobFail => {
2642 if event__.is_some() {
2643 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2644 }
2645 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2646;
2647 }
2648 GeneratedField::DirtyStreamJobClear => {
2649 if event__.is_some() {
2650 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2651 }
2652 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2653;
2654 }
2655 GeneratedField::MetaNodeStart => {
2656 if event__.is_some() {
2657 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2658 }
2659 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2660;
2661 }
2662 GeneratedField::BarrierComplete => {
2663 if event__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2665 }
2666 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2667;
2668 }
2669 GeneratedField::InjectBarrierFail => {
2670 if event__.is_some() {
2671 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2672 }
2673 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2674;
2675 }
2676 GeneratedField::CollectBarrierFail => {
2677 if event__.is_some() {
2678 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2679 }
2680 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2681;
2682 }
2683 GeneratedField::WorkerNodePanic => {
2684 if event__.is_some() {
2685 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2686 }
2687 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2688;
2689 }
2690 GeneratedField::AutoSchemaChangeFail => {
2691 if event__.is_some() {
2692 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2693 }
2694 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2695;
2696 }
2697 GeneratedField::SinkFail => {
2698 if event__.is_some() {
2699 return Err(serde::de::Error::duplicate_field("sinkFail"));
2700 }
2701 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2702;
2703 }
2704 GeneratedField::Recovery => {
2705 if event__.is_some() {
2706 return Err(serde::de::Error::duplicate_field("recovery"));
2707 }
2708 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2709;
2710 }
2711 }
2712 }
2713 Ok(EventLog {
2714 unique_id: unique_id__,
2715 timestamp: timestamp__,
2716 event: event__,
2717 })
2718 }
2719 }
2720 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2721 }
2722}
2723impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2724 #[allow(deprecated)]
2725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2726 where
2727 S: serde::Serializer,
2728 {
2729 use serde::ser::SerializeStruct;
2730 let mut len = 0;
2731 if self.table_id != 0 {
2732 len += 1;
2733 }
2734 if !self.table_name.is_empty() {
2735 len += 1;
2736 }
2737 if !self.cdc_table_id.is_empty() {
2738 len += 1;
2739 }
2740 if !self.upstream_ddl.is_empty() {
2741 len += 1;
2742 }
2743 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2744 if self.table_id != 0 {
2745 struct_ser.serialize_field("tableId", &self.table_id)?;
2746 }
2747 if !self.table_name.is_empty() {
2748 struct_ser.serialize_field("tableName", &self.table_name)?;
2749 }
2750 if !self.cdc_table_id.is_empty() {
2751 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2752 }
2753 if !self.upstream_ddl.is_empty() {
2754 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2755 }
2756 struct_ser.end()
2757 }
2758}
2759impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2760 #[allow(deprecated)]
2761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2762 where
2763 D: serde::Deserializer<'de>,
2764 {
2765 const FIELDS: &[&str] = &[
2766 "table_id",
2767 "tableId",
2768 "table_name",
2769 "tableName",
2770 "cdc_table_id",
2771 "cdcTableId",
2772 "upstream_ddl",
2773 "upstreamDdl",
2774 ];
2775
2776 #[allow(clippy::enum_variant_names)]
2777 enum GeneratedField {
2778 TableId,
2779 TableName,
2780 CdcTableId,
2781 UpstreamDdl,
2782 }
2783 impl<'de> serde::Deserialize<'de> for GeneratedField {
2784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2785 where
2786 D: serde::Deserializer<'de>,
2787 {
2788 struct GeneratedVisitor;
2789
2790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2791 type Value = GeneratedField;
2792
2793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2794 write!(formatter, "expected one of: {:?}", &FIELDS)
2795 }
2796
2797 #[allow(unused_variables)]
2798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2799 where
2800 E: serde::de::Error,
2801 {
2802 match value {
2803 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2804 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2805 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2806 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2808 }
2809 }
2810 }
2811 deserializer.deserialize_identifier(GeneratedVisitor)
2812 }
2813 }
2814 struct GeneratedVisitor;
2815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2816 type Value = event_log::EventAutoSchemaChangeFail;
2817
2818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2819 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2820 }
2821
2822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2823 where
2824 V: serde::de::MapAccess<'de>,
2825 {
2826 let mut table_id__ = None;
2827 let mut table_name__ = None;
2828 let mut cdc_table_id__ = None;
2829 let mut upstream_ddl__ = None;
2830 while let Some(k) = map_.next_key()? {
2831 match k {
2832 GeneratedField::TableId => {
2833 if table_id__.is_some() {
2834 return Err(serde::de::Error::duplicate_field("tableId"));
2835 }
2836 table_id__ =
2837 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2838 ;
2839 }
2840 GeneratedField::TableName => {
2841 if table_name__.is_some() {
2842 return Err(serde::de::Error::duplicate_field("tableName"));
2843 }
2844 table_name__ = Some(map_.next_value()?);
2845 }
2846 GeneratedField::CdcTableId => {
2847 if cdc_table_id__.is_some() {
2848 return Err(serde::de::Error::duplicate_field("cdcTableId"));
2849 }
2850 cdc_table_id__ = Some(map_.next_value()?);
2851 }
2852 GeneratedField::UpstreamDdl => {
2853 if upstream_ddl__.is_some() {
2854 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
2855 }
2856 upstream_ddl__ = Some(map_.next_value()?);
2857 }
2858 }
2859 }
2860 Ok(event_log::EventAutoSchemaChangeFail {
2861 table_id: table_id__.unwrap_or_default(),
2862 table_name: table_name__.unwrap_or_default(),
2863 cdc_table_id: cdc_table_id__.unwrap_or_default(),
2864 upstream_ddl: upstream_ddl__.unwrap_or_default(),
2865 })
2866 }
2867 }
2868 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
2869 }
2870}
2871impl serde::Serialize for event_log::EventBarrierComplete {
2872 #[allow(deprecated)]
2873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2874 where
2875 S: serde::Serializer,
2876 {
2877 use serde::ser::SerializeStruct;
2878 let mut len = 0;
2879 if self.prev_epoch != 0 {
2880 len += 1;
2881 }
2882 if self.cur_epoch != 0 {
2883 len += 1;
2884 }
2885 if self.duration_sec != 0. {
2886 len += 1;
2887 }
2888 if !self.command.is_empty() {
2889 len += 1;
2890 }
2891 if !self.barrier_kind.is_empty() {
2892 len += 1;
2893 }
2894 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
2895 if self.prev_epoch != 0 {
2896 #[allow(clippy::needless_borrow)]
2897 #[allow(clippy::needless_borrows_for_generic_args)]
2898 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
2899 }
2900 if self.cur_epoch != 0 {
2901 #[allow(clippy::needless_borrow)]
2902 #[allow(clippy::needless_borrows_for_generic_args)]
2903 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
2904 }
2905 if self.duration_sec != 0. {
2906 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
2907 }
2908 if !self.command.is_empty() {
2909 struct_ser.serialize_field("command", &self.command)?;
2910 }
2911 if !self.barrier_kind.is_empty() {
2912 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
2913 }
2914 struct_ser.end()
2915 }
2916}
2917impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
2918 #[allow(deprecated)]
2919 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2920 where
2921 D: serde::Deserializer<'de>,
2922 {
2923 const FIELDS: &[&str] = &[
2924 "prev_epoch",
2925 "prevEpoch",
2926 "cur_epoch",
2927 "curEpoch",
2928 "duration_sec",
2929 "durationSec",
2930 "command",
2931 "barrier_kind",
2932 "barrierKind",
2933 ];
2934
2935 #[allow(clippy::enum_variant_names)]
2936 enum GeneratedField {
2937 PrevEpoch,
2938 CurEpoch,
2939 DurationSec,
2940 Command,
2941 BarrierKind,
2942 }
2943 impl<'de> serde::Deserialize<'de> for GeneratedField {
2944 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2945 where
2946 D: serde::Deserializer<'de>,
2947 {
2948 struct GeneratedVisitor;
2949
2950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2951 type Value = GeneratedField;
2952
2953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2954 write!(formatter, "expected one of: {:?}", &FIELDS)
2955 }
2956
2957 #[allow(unused_variables)]
2958 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2959 where
2960 E: serde::de::Error,
2961 {
2962 match value {
2963 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
2964 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
2965 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
2966 "command" => Ok(GeneratedField::Command),
2967 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
2968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2969 }
2970 }
2971 }
2972 deserializer.deserialize_identifier(GeneratedVisitor)
2973 }
2974 }
2975 struct GeneratedVisitor;
2976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2977 type Value = event_log::EventBarrierComplete;
2978
2979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2980 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
2981 }
2982
2983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
2984 where
2985 V: serde::de::MapAccess<'de>,
2986 {
2987 let mut prev_epoch__ = None;
2988 let mut cur_epoch__ = None;
2989 let mut duration_sec__ = None;
2990 let mut command__ = None;
2991 let mut barrier_kind__ = None;
2992 while let Some(k) = map_.next_key()? {
2993 match k {
2994 GeneratedField::PrevEpoch => {
2995 if prev_epoch__.is_some() {
2996 return Err(serde::de::Error::duplicate_field("prevEpoch"));
2997 }
2998 prev_epoch__ =
2999 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3000 ;
3001 }
3002 GeneratedField::CurEpoch => {
3003 if cur_epoch__.is_some() {
3004 return Err(serde::de::Error::duplicate_field("curEpoch"));
3005 }
3006 cur_epoch__ =
3007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3008 ;
3009 }
3010 GeneratedField::DurationSec => {
3011 if duration_sec__.is_some() {
3012 return Err(serde::de::Error::duplicate_field("durationSec"));
3013 }
3014 duration_sec__ =
3015 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3016 ;
3017 }
3018 GeneratedField::Command => {
3019 if command__.is_some() {
3020 return Err(serde::de::Error::duplicate_field("command"));
3021 }
3022 command__ = Some(map_.next_value()?);
3023 }
3024 GeneratedField::BarrierKind => {
3025 if barrier_kind__.is_some() {
3026 return Err(serde::de::Error::duplicate_field("barrierKind"));
3027 }
3028 barrier_kind__ = Some(map_.next_value()?);
3029 }
3030 }
3031 }
3032 Ok(event_log::EventBarrierComplete {
3033 prev_epoch: prev_epoch__.unwrap_or_default(),
3034 cur_epoch: cur_epoch__.unwrap_or_default(),
3035 duration_sec: duration_sec__.unwrap_or_default(),
3036 command: command__.unwrap_or_default(),
3037 barrier_kind: barrier_kind__.unwrap_or_default(),
3038 })
3039 }
3040 }
3041 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3042 }
3043}
3044impl serde::Serialize for event_log::EventCollectBarrierFail {
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.error.is_empty() {
3053 len += 1;
3054 }
3055 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3056 if !self.error.is_empty() {
3057 struct_ser.serialize_field("error", &self.error)?;
3058 }
3059 struct_ser.end()
3060 }
3061}
3062impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3063 #[allow(deprecated)]
3064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3065 where
3066 D: serde::Deserializer<'de>,
3067 {
3068 const FIELDS: &[&str] = &[
3069 "error",
3070 ];
3071
3072 #[allow(clippy::enum_variant_names)]
3073 enum GeneratedField {
3074 Error,
3075 }
3076 impl<'de> serde::Deserialize<'de> for GeneratedField {
3077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3078 where
3079 D: serde::Deserializer<'de>,
3080 {
3081 struct GeneratedVisitor;
3082
3083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3084 type Value = GeneratedField;
3085
3086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3087 write!(formatter, "expected one of: {:?}", &FIELDS)
3088 }
3089
3090 #[allow(unused_variables)]
3091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3092 where
3093 E: serde::de::Error,
3094 {
3095 match value {
3096 "error" => Ok(GeneratedField::Error),
3097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3098 }
3099 }
3100 }
3101 deserializer.deserialize_identifier(GeneratedVisitor)
3102 }
3103 }
3104 struct GeneratedVisitor;
3105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3106 type Value = event_log::EventCollectBarrierFail;
3107
3108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3109 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3110 }
3111
3112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3113 where
3114 V: serde::de::MapAccess<'de>,
3115 {
3116 let mut error__ = None;
3117 while let Some(k) = map_.next_key()? {
3118 match k {
3119 GeneratedField::Error => {
3120 if error__.is_some() {
3121 return Err(serde::de::Error::duplicate_field("error"));
3122 }
3123 error__ = Some(map_.next_value()?);
3124 }
3125 }
3126 }
3127 Ok(event_log::EventCollectBarrierFail {
3128 error: error__.unwrap_or_default(),
3129 })
3130 }
3131 }
3132 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3133 }
3134}
3135impl serde::Serialize for event_log::EventCreateStreamJobFail {
3136 #[allow(deprecated)]
3137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3138 where
3139 S: serde::Serializer,
3140 {
3141 use serde::ser::SerializeStruct;
3142 let mut len = 0;
3143 if self.id != 0 {
3144 len += 1;
3145 }
3146 if !self.name.is_empty() {
3147 len += 1;
3148 }
3149 if !self.definition.is_empty() {
3150 len += 1;
3151 }
3152 if !self.error.is_empty() {
3153 len += 1;
3154 }
3155 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3156 if self.id != 0 {
3157 struct_ser.serialize_field("id", &self.id)?;
3158 }
3159 if !self.name.is_empty() {
3160 struct_ser.serialize_field("name", &self.name)?;
3161 }
3162 if !self.definition.is_empty() {
3163 struct_ser.serialize_field("definition", &self.definition)?;
3164 }
3165 if !self.error.is_empty() {
3166 struct_ser.serialize_field("error", &self.error)?;
3167 }
3168 struct_ser.end()
3169 }
3170}
3171impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3172 #[allow(deprecated)]
3173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3174 where
3175 D: serde::Deserializer<'de>,
3176 {
3177 const FIELDS: &[&str] = &[
3178 "id",
3179 "name",
3180 "definition",
3181 "error",
3182 ];
3183
3184 #[allow(clippy::enum_variant_names)]
3185 enum GeneratedField {
3186 Id,
3187 Name,
3188 Definition,
3189 Error,
3190 }
3191 impl<'de> serde::Deserialize<'de> for GeneratedField {
3192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3193 where
3194 D: serde::Deserializer<'de>,
3195 {
3196 struct GeneratedVisitor;
3197
3198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3199 type Value = GeneratedField;
3200
3201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3202 write!(formatter, "expected one of: {:?}", &FIELDS)
3203 }
3204
3205 #[allow(unused_variables)]
3206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3207 where
3208 E: serde::de::Error,
3209 {
3210 match value {
3211 "id" => Ok(GeneratedField::Id),
3212 "name" => Ok(GeneratedField::Name),
3213 "definition" => Ok(GeneratedField::Definition),
3214 "error" => Ok(GeneratedField::Error),
3215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3216 }
3217 }
3218 }
3219 deserializer.deserialize_identifier(GeneratedVisitor)
3220 }
3221 }
3222 struct GeneratedVisitor;
3223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3224 type Value = event_log::EventCreateStreamJobFail;
3225
3226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3227 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3228 }
3229
3230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3231 where
3232 V: serde::de::MapAccess<'de>,
3233 {
3234 let mut id__ = None;
3235 let mut name__ = None;
3236 let mut definition__ = None;
3237 let mut error__ = None;
3238 while let Some(k) = map_.next_key()? {
3239 match k {
3240 GeneratedField::Id => {
3241 if id__.is_some() {
3242 return Err(serde::de::Error::duplicate_field("id"));
3243 }
3244 id__ =
3245 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3246 ;
3247 }
3248 GeneratedField::Name => {
3249 if name__.is_some() {
3250 return Err(serde::de::Error::duplicate_field("name"));
3251 }
3252 name__ = Some(map_.next_value()?);
3253 }
3254 GeneratedField::Definition => {
3255 if definition__.is_some() {
3256 return Err(serde::de::Error::duplicate_field("definition"));
3257 }
3258 definition__ = Some(map_.next_value()?);
3259 }
3260 GeneratedField::Error => {
3261 if error__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("error"));
3263 }
3264 error__ = Some(map_.next_value()?);
3265 }
3266 }
3267 }
3268 Ok(event_log::EventCreateStreamJobFail {
3269 id: id__.unwrap_or_default(),
3270 name: name__.unwrap_or_default(),
3271 definition: definition__.unwrap_or_default(),
3272 error: error__.unwrap_or_default(),
3273 })
3274 }
3275 }
3276 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3277 }
3278}
3279impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3280 #[allow(deprecated)]
3281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3282 where
3283 S: serde::Serializer,
3284 {
3285 use serde::ser::SerializeStruct;
3286 let mut len = 0;
3287 if self.id != 0 {
3288 len += 1;
3289 }
3290 if !self.name.is_empty() {
3291 len += 1;
3292 }
3293 if !self.definition.is_empty() {
3294 len += 1;
3295 }
3296 if !self.error.is_empty() {
3297 len += 1;
3298 }
3299 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3300 if self.id != 0 {
3301 struct_ser.serialize_field("id", &self.id)?;
3302 }
3303 if !self.name.is_empty() {
3304 struct_ser.serialize_field("name", &self.name)?;
3305 }
3306 if !self.definition.is_empty() {
3307 struct_ser.serialize_field("definition", &self.definition)?;
3308 }
3309 if !self.error.is_empty() {
3310 struct_ser.serialize_field("error", &self.error)?;
3311 }
3312 struct_ser.end()
3313 }
3314}
3315impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3316 #[allow(deprecated)]
3317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3318 where
3319 D: serde::Deserializer<'de>,
3320 {
3321 const FIELDS: &[&str] = &[
3322 "id",
3323 "name",
3324 "definition",
3325 "error",
3326 ];
3327
3328 #[allow(clippy::enum_variant_names)]
3329 enum GeneratedField {
3330 Id,
3331 Name,
3332 Definition,
3333 Error,
3334 }
3335 impl<'de> serde::Deserialize<'de> for GeneratedField {
3336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3337 where
3338 D: serde::Deserializer<'de>,
3339 {
3340 struct GeneratedVisitor;
3341
3342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3343 type Value = GeneratedField;
3344
3345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3346 write!(formatter, "expected one of: {:?}", &FIELDS)
3347 }
3348
3349 #[allow(unused_variables)]
3350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3351 where
3352 E: serde::de::Error,
3353 {
3354 match value {
3355 "id" => Ok(GeneratedField::Id),
3356 "name" => Ok(GeneratedField::Name),
3357 "definition" => Ok(GeneratedField::Definition),
3358 "error" => Ok(GeneratedField::Error),
3359 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3360 }
3361 }
3362 }
3363 deserializer.deserialize_identifier(GeneratedVisitor)
3364 }
3365 }
3366 struct GeneratedVisitor;
3367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3368 type Value = event_log::EventDirtyStreamJobClear;
3369
3370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3371 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3372 }
3373
3374 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3375 where
3376 V: serde::de::MapAccess<'de>,
3377 {
3378 let mut id__ = None;
3379 let mut name__ = None;
3380 let mut definition__ = None;
3381 let mut error__ = None;
3382 while let Some(k) = map_.next_key()? {
3383 match k {
3384 GeneratedField::Id => {
3385 if id__.is_some() {
3386 return Err(serde::de::Error::duplicate_field("id"));
3387 }
3388 id__ =
3389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3390 ;
3391 }
3392 GeneratedField::Name => {
3393 if name__.is_some() {
3394 return Err(serde::de::Error::duplicate_field("name"));
3395 }
3396 name__ = Some(map_.next_value()?);
3397 }
3398 GeneratedField::Definition => {
3399 if definition__.is_some() {
3400 return Err(serde::de::Error::duplicate_field("definition"));
3401 }
3402 definition__ = Some(map_.next_value()?);
3403 }
3404 GeneratedField::Error => {
3405 if error__.is_some() {
3406 return Err(serde::de::Error::duplicate_field("error"));
3407 }
3408 error__ = Some(map_.next_value()?);
3409 }
3410 }
3411 }
3412 Ok(event_log::EventDirtyStreamJobClear {
3413 id: id__.unwrap_or_default(),
3414 name: name__.unwrap_or_default(),
3415 definition: definition__.unwrap_or_default(),
3416 error: error__.unwrap_or_default(),
3417 })
3418 }
3419 }
3420 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3421 }
3422}
3423impl serde::Serialize for event_log::EventInjectBarrierFail {
3424 #[allow(deprecated)]
3425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3426 where
3427 S: serde::Serializer,
3428 {
3429 use serde::ser::SerializeStruct;
3430 let mut len = 0;
3431 if self.prev_epoch != 0 {
3432 len += 1;
3433 }
3434 if self.cur_epoch != 0 {
3435 len += 1;
3436 }
3437 if !self.error.is_empty() {
3438 len += 1;
3439 }
3440 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3441 if self.prev_epoch != 0 {
3442 #[allow(clippy::needless_borrow)]
3443 #[allow(clippy::needless_borrows_for_generic_args)]
3444 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3445 }
3446 if self.cur_epoch != 0 {
3447 #[allow(clippy::needless_borrow)]
3448 #[allow(clippy::needless_borrows_for_generic_args)]
3449 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3450 }
3451 if !self.error.is_empty() {
3452 struct_ser.serialize_field("error", &self.error)?;
3453 }
3454 struct_ser.end()
3455 }
3456}
3457impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3458 #[allow(deprecated)]
3459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3460 where
3461 D: serde::Deserializer<'de>,
3462 {
3463 const FIELDS: &[&str] = &[
3464 "prev_epoch",
3465 "prevEpoch",
3466 "cur_epoch",
3467 "curEpoch",
3468 "error",
3469 ];
3470
3471 #[allow(clippy::enum_variant_names)]
3472 enum GeneratedField {
3473 PrevEpoch,
3474 CurEpoch,
3475 Error,
3476 }
3477 impl<'de> serde::Deserialize<'de> for GeneratedField {
3478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3479 where
3480 D: serde::Deserializer<'de>,
3481 {
3482 struct GeneratedVisitor;
3483
3484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3485 type Value = GeneratedField;
3486
3487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3488 write!(formatter, "expected one of: {:?}", &FIELDS)
3489 }
3490
3491 #[allow(unused_variables)]
3492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3493 where
3494 E: serde::de::Error,
3495 {
3496 match value {
3497 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3498 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3499 "error" => Ok(GeneratedField::Error),
3500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3501 }
3502 }
3503 }
3504 deserializer.deserialize_identifier(GeneratedVisitor)
3505 }
3506 }
3507 struct GeneratedVisitor;
3508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3509 type Value = event_log::EventInjectBarrierFail;
3510
3511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3512 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3513 }
3514
3515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3516 where
3517 V: serde::de::MapAccess<'de>,
3518 {
3519 let mut prev_epoch__ = None;
3520 let mut cur_epoch__ = None;
3521 let mut error__ = None;
3522 while let Some(k) = map_.next_key()? {
3523 match k {
3524 GeneratedField::PrevEpoch => {
3525 if prev_epoch__.is_some() {
3526 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3527 }
3528 prev_epoch__ =
3529 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3530 ;
3531 }
3532 GeneratedField::CurEpoch => {
3533 if cur_epoch__.is_some() {
3534 return Err(serde::de::Error::duplicate_field("curEpoch"));
3535 }
3536 cur_epoch__ =
3537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3538 ;
3539 }
3540 GeneratedField::Error => {
3541 if error__.is_some() {
3542 return Err(serde::de::Error::duplicate_field("error"));
3543 }
3544 error__ = Some(map_.next_value()?);
3545 }
3546 }
3547 }
3548 Ok(event_log::EventInjectBarrierFail {
3549 prev_epoch: prev_epoch__.unwrap_or_default(),
3550 cur_epoch: cur_epoch__.unwrap_or_default(),
3551 error: error__.unwrap_or_default(),
3552 })
3553 }
3554 }
3555 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3556 }
3557}
3558impl serde::Serialize for event_log::EventMetaNodeStart {
3559 #[allow(deprecated)]
3560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3561 where
3562 S: serde::Serializer,
3563 {
3564 use serde::ser::SerializeStruct;
3565 let mut len = 0;
3566 if !self.advertise_addr.is_empty() {
3567 len += 1;
3568 }
3569 if !self.listen_addr.is_empty() {
3570 len += 1;
3571 }
3572 if !self.opts.is_empty() {
3573 len += 1;
3574 }
3575 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3576 if !self.advertise_addr.is_empty() {
3577 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3578 }
3579 if !self.listen_addr.is_empty() {
3580 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3581 }
3582 if !self.opts.is_empty() {
3583 struct_ser.serialize_field("opts", &self.opts)?;
3584 }
3585 struct_ser.end()
3586 }
3587}
3588impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3589 #[allow(deprecated)]
3590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3591 where
3592 D: serde::Deserializer<'de>,
3593 {
3594 const FIELDS: &[&str] = &[
3595 "advertise_addr",
3596 "advertiseAddr",
3597 "listen_addr",
3598 "listenAddr",
3599 "opts",
3600 ];
3601
3602 #[allow(clippy::enum_variant_names)]
3603 enum GeneratedField {
3604 AdvertiseAddr,
3605 ListenAddr,
3606 Opts,
3607 }
3608 impl<'de> serde::Deserialize<'de> for GeneratedField {
3609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3610 where
3611 D: serde::Deserializer<'de>,
3612 {
3613 struct GeneratedVisitor;
3614
3615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3616 type Value = GeneratedField;
3617
3618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3619 write!(formatter, "expected one of: {:?}", &FIELDS)
3620 }
3621
3622 #[allow(unused_variables)]
3623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3624 where
3625 E: serde::de::Error,
3626 {
3627 match value {
3628 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3629 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3630 "opts" => Ok(GeneratedField::Opts),
3631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3632 }
3633 }
3634 }
3635 deserializer.deserialize_identifier(GeneratedVisitor)
3636 }
3637 }
3638 struct GeneratedVisitor;
3639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3640 type Value = event_log::EventMetaNodeStart;
3641
3642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3644 }
3645
3646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3647 where
3648 V: serde::de::MapAccess<'de>,
3649 {
3650 let mut advertise_addr__ = None;
3651 let mut listen_addr__ = None;
3652 let mut opts__ = None;
3653 while let Some(k) = map_.next_key()? {
3654 match k {
3655 GeneratedField::AdvertiseAddr => {
3656 if advertise_addr__.is_some() {
3657 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3658 }
3659 advertise_addr__ = Some(map_.next_value()?);
3660 }
3661 GeneratedField::ListenAddr => {
3662 if listen_addr__.is_some() {
3663 return Err(serde::de::Error::duplicate_field("listenAddr"));
3664 }
3665 listen_addr__ = Some(map_.next_value()?);
3666 }
3667 GeneratedField::Opts => {
3668 if opts__.is_some() {
3669 return Err(serde::de::Error::duplicate_field("opts"));
3670 }
3671 opts__ = Some(map_.next_value()?);
3672 }
3673 }
3674 }
3675 Ok(event_log::EventMetaNodeStart {
3676 advertise_addr: advertise_addr__.unwrap_or_default(),
3677 listen_addr: listen_addr__.unwrap_or_default(),
3678 opts: opts__.unwrap_or_default(),
3679 })
3680 }
3681 }
3682 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3683 }
3684}
3685impl serde::Serialize for event_log::EventRecovery {
3686 #[allow(deprecated)]
3687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3688 where
3689 S: serde::Serializer,
3690 {
3691 use serde::ser::SerializeStruct;
3692 let mut len = 0;
3693 if self.recovery_event.is_some() {
3694 len += 1;
3695 }
3696 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3697 if let Some(v) = self.recovery_event.as_ref() {
3698 match v {
3699 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3700 struct_ser.serialize_field("globalStart", v)?;
3701 }
3702 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3703 struct_ser.serialize_field("globalSuccess", v)?;
3704 }
3705 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3706 struct_ser.serialize_field("globalFailure", v)?;
3707 }
3708 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3709 struct_ser.serialize_field("databaseStart", v)?;
3710 }
3711 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3712 struct_ser.serialize_field("databaseFailure", v)?;
3713 }
3714 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3715 struct_ser.serialize_field("databaseSuccess", v)?;
3716 }
3717 }
3718 }
3719 struct_ser.end()
3720 }
3721}
3722impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3723 #[allow(deprecated)]
3724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3725 where
3726 D: serde::Deserializer<'de>,
3727 {
3728 const FIELDS: &[&str] = &[
3729 "global_start",
3730 "globalStart",
3731 "global_success",
3732 "globalSuccess",
3733 "global_failure",
3734 "globalFailure",
3735 "database_start",
3736 "databaseStart",
3737 "database_failure",
3738 "databaseFailure",
3739 "database_success",
3740 "databaseSuccess",
3741 ];
3742
3743 #[allow(clippy::enum_variant_names)]
3744 enum GeneratedField {
3745 GlobalStart,
3746 GlobalSuccess,
3747 GlobalFailure,
3748 DatabaseStart,
3749 DatabaseFailure,
3750 DatabaseSuccess,
3751 }
3752 impl<'de> serde::Deserialize<'de> for GeneratedField {
3753 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3754 where
3755 D: serde::Deserializer<'de>,
3756 {
3757 struct GeneratedVisitor;
3758
3759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3760 type Value = GeneratedField;
3761
3762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3763 write!(formatter, "expected one of: {:?}", &FIELDS)
3764 }
3765
3766 #[allow(unused_variables)]
3767 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3768 where
3769 E: serde::de::Error,
3770 {
3771 match value {
3772 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3773 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3774 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3775 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3776 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3777 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3779 }
3780 }
3781 }
3782 deserializer.deserialize_identifier(GeneratedVisitor)
3783 }
3784 }
3785 struct GeneratedVisitor;
3786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3787 type Value = event_log::EventRecovery;
3788
3789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790 formatter.write_str("struct meta.EventLog.EventRecovery")
3791 }
3792
3793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3794 where
3795 V: serde::de::MapAccess<'de>,
3796 {
3797 let mut recovery_event__ = None;
3798 while let Some(k) = map_.next_key()? {
3799 match k {
3800 GeneratedField::GlobalStart => {
3801 if recovery_event__.is_some() {
3802 return Err(serde::de::Error::duplicate_field("globalStart"));
3803 }
3804 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3805;
3806 }
3807 GeneratedField::GlobalSuccess => {
3808 if recovery_event__.is_some() {
3809 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3810 }
3811 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3812;
3813 }
3814 GeneratedField::GlobalFailure => {
3815 if recovery_event__.is_some() {
3816 return Err(serde::de::Error::duplicate_field("globalFailure"));
3817 }
3818 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3819;
3820 }
3821 GeneratedField::DatabaseStart => {
3822 if recovery_event__.is_some() {
3823 return Err(serde::de::Error::duplicate_field("databaseStart"));
3824 }
3825 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3826;
3827 }
3828 GeneratedField::DatabaseFailure => {
3829 if recovery_event__.is_some() {
3830 return Err(serde::de::Error::duplicate_field("databaseFailure"));
3831 }
3832 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
3833;
3834 }
3835 GeneratedField::DatabaseSuccess => {
3836 if recovery_event__.is_some() {
3837 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
3838 }
3839 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
3840;
3841 }
3842 }
3843 }
3844 Ok(event_log::EventRecovery {
3845 recovery_event: recovery_event__,
3846 })
3847 }
3848 }
3849 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
3850 }
3851}
3852impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
3853 #[allow(deprecated)]
3854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3855 where
3856 S: serde::Serializer,
3857 {
3858 use serde::ser::SerializeStruct;
3859 let mut len = 0;
3860 if self.database_id != 0 {
3861 len += 1;
3862 }
3863 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
3864 if self.database_id != 0 {
3865 struct_ser.serialize_field("databaseId", &self.database_id)?;
3866 }
3867 struct_ser.end()
3868 }
3869}
3870impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
3871 #[allow(deprecated)]
3872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3873 where
3874 D: serde::Deserializer<'de>,
3875 {
3876 const FIELDS: &[&str] = &[
3877 "database_id",
3878 "databaseId",
3879 ];
3880
3881 #[allow(clippy::enum_variant_names)]
3882 enum GeneratedField {
3883 DatabaseId,
3884 }
3885 impl<'de> serde::Deserialize<'de> for GeneratedField {
3886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3887 where
3888 D: serde::Deserializer<'de>,
3889 {
3890 struct GeneratedVisitor;
3891
3892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3893 type Value = GeneratedField;
3894
3895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3896 write!(formatter, "expected one of: {:?}", &FIELDS)
3897 }
3898
3899 #[allow(unused_variables)]
3900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3901 where
3902 E: serde::de::Error,
3903 {
3904 match value {
3905 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3906 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3907 }
3908 }
3909 }
3910 deserializer.deserialize_identifier(GeneratedVisitor)
3911 }
3912 }
3913 struct GeneratedVisitor;
3914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3915 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
3916
3917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
3919 }
3920
3921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
3922 where
3923 V: serde::de::MapAccess<'de>,
3924 {
3925 let mut database_id__ = None;
3926 while let Some(k) = map_.next_key()? {
3927 match k {
3928 GeneratedField::DatabaseId => {
3929 if database_id__.is_some() {
3930 return Err(serde::de::Error::duplicate_field("databaseId"));
3931 }
3932 database_id__ =
3933 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3934 ;
3935 }
3936 }
3937 }
3938 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
3939 database_id: database_id__.unwrap_or_default(),
3940 })
3941 }
3942 }
3943 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
3944 }
3945}
3946impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
3947 #[allow(deprecated)]
3948 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3949 where
3950 S: serde::Serializer,
3951 {
3952 use serde::ser::SerializeStruct;
3953 let mut len = 0;
3954 if self.database_id != 0 {
3955 len += 1;
3956 }
3957 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
3958 if self.database_id != 0 {
3959 struct_ser.serialize_field("databaseId", &self.database_id)?;
3960 }
3961 struct_ser.end()
3962 }
3963}
3964impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
3965 #[allow(deprecated)]
3966 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3967 where
3968 D: serde::Deserializer<'de>,
3969 {
3970 const FIELDS: &[&str] = &[
3971 "database_id",
3972 "databaseId",
3973 ];
3974
3975 #[allow(clippy::enum_variant_names)]
3976 enum GeneratedField {
3977 DatabaseId,
3978 }
3979 impl<'de> serde::Deserialize<'de> for GeneratedField {
3980 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3981 where
3982 D: serde::Deserializer<'de>,
3983 {
3984 struct GeneratedVisitor;
3985
3986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3987 type Value = GeneratedField;
3988
3989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3990 write!(formatter, "expected one of: {:?}", &FIELDS)
3991 }
3992
3993 #[allow(unused_variables)]
3994 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3995 where
3996 E: serde::de::Error,
3997 {
3998 match value {
3999 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4001 }
4002 }
4003 }
4004 deserializer.deserialize_identifier(GeneratedVisitor)
4005 }
4006 }
4007 struct GeneratedVisitor;
4008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4009 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4010
4011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4012 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4013 }
4014
4015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4016 where
4017 V: serde::de::MapAccess<'de>,
4018 {
4019 let mut database_id__ = None;
4020 while let Some(k) = map_.next_key()? {
4021 match k {
4022 GeneratedField::DatabaseId => {
4023 if database_id__.is_some() {
4024 return Err(serde::de::Error::duplicate_field("databaseId"));
4025 }
4026 database_id__ =
4027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4028 ;
4029 }
4030 }
4031 }
4032 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4033 database_id: database_id__.unwrap_or_default(),
4034 })
4035 }
4036 }
4037 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4038 }
4039}
4040impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4041 #[allow(deprecated)]
4042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4043 where
4044 S: serde::Serializer,
4045 {
4046 use serde::ser::SerializeStruct;
4047 let mut len = 0;
4048 if self.database_id != 0 {
4049 len += 1;
4050 }
4051 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4052 if self.database_id != 0 {
4053 struct_ser.serialize_field("databaseId", &self.database_id)?;
4054 }
4055 struct_ser.end()
4056 }
4057}
4058impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4059 #[allow(deprecated)]
4060 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4061 where
4062 D: serde::Deserializer<'de>,
4063 {
4064 const FIELDS: &[&str] = &[
4065 "database_id",
4066 "databaseId",
4067 ];
4068
4069 #[allow(clippy::enum_variant_names)]
4070 enum GeneratedField {
4071 DatabaseId,
4072 }
4073 impl<'de> serde::Deserialize<'de> for GeneratedField {
4074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4075 where
4076 D: serde::Deserializer<'de>,
4077 {
4078 struct GeneratedVisitor;
4079
4080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4081 type Value = GeneratedField;
4082
4083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4084 write!(formatter, "expected one of: {:?}", &FIELDS)
4085 }
4086
4087 #[allow(unused_variables)]
4088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4089 where
4090 E: serde::de::Error,
4091 {
4092 match value {
4093 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4095 }
4096 }
4097 }
4098 deserializer.deserialize_identifier(GeneratedVisitor)
4099 }
4100 }
4101 struct GeneratedVisitor;
4102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4103 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4104
4105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4107 }
4108
4109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4110 where
4111 V: serde::de::MapAccess<'de>,
4112 {
4113 let mut database_id__ = None;
4114 while let Some(k) = map_.next_key()? {
4115 match k {
4116 GeneratedField::DatabaseId => {
4117 if database_id__.is_some() {
4118 return Err(serde::de::Error::duplicate_field("databaseId"));
4119 }
4120 database_id__ =
4121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4122 ;
4123 }
4124 }
4125 }
4126 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4127 database_id: database_id__.unwrap_or_default(),
4128 })
4129 }
4130 }
4131 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4132 }
4133}
4134impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4135 #[allow(deprecated)]
4136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4137 where
4138 S: serde::Serializer,
4139 {
4140 use serde::ser::SerializeStruct;
4141 let mut len = 0;
4142 if !self.reason.is_empty() {
4143 len += 1;
4144 }
4145 if !self.error.is_empty() {
4146 len += 1;
4147 }
4148 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4149 if !self.reason.is_empty() {
4150 struct_ser.serialize_field("reason", &self.reason)?;
4151 }
4152 if !self.error.is_empty() {
4153 struct_ser.serialize_field("error", &self.error)?;
4154 }
4155 struct_ser.end()
4156 }
4157}
4158impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4159 #[allow(deprecated)]
4160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4161 where
4162 D: serde::Deserializer<'de>,
4163 {
4164 const FIELDS: &[&str] = &[
4165 "reason",
4166 "error",
4167 ];
4168
4169 #[allow(clippy::enum_variant_names)]
4170 enum GeneratedField {
4171 Reason,
4172 Error,
4173 }
4174 impl<'de> serde::Deserialize<'de> for GeneratedField {
4175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4176 where
4177 D: serde::Deserializer<'de>,
4178 {
4179 struct GeneratedVisitor;
4180
4181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4182 type Value = GeneratedField;
4183
4184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4185 write!(formatter, "expected one of: {:?}", &FIELDS)
4186 }
4187
4188 #[allow(unused_variables)]
4189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4190 where
4191 E: serde::de::Error,
4192 {
4193 match value {
4194 "reason" => Ok(GeneratedField::Reason),
4195 "error" => Ok(GeneratedField::Error),
4196 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4197 }
4198 }
4199 }
4200 deserializer.deserialize_identifier(GeneratedVisitor)
4201 }
4202 }
4203 struct GeneratedVisitor;
4204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4205 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4206
4207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4208 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4209 }
4210
4211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4212 where
4213 V: serde::de::MapAccess<'de>,
4214 {
4215 let mut reason__ = None;
4216 let mut error__ = None;
4217 while let Some(k) = map_.next_key()? {
4218 match k {
4219 GeneratedField::Reason => {
4220 if reason__.is_some() {
4221 return Err(serde::de::Error::duplicate_field("reason"));
4222 }
4223 reason__ = Some(map_.next_value()?);
4224 }
4225 GeneratedField::Error => {
4226 if error__.is_some() {
4227 return Err(serde::de::Error::duplicate_field("error"));
4228 }
4229 error__ = Some(map_.next_value()?);
4230 }
4231 }
4232 }
4233 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4234 reason: reason__.unwrap_or_default(),
4235 error: error__.unwrap_or_default(),
4236 })
4237 }
4238 }
4239 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4240 }
4241}
4242impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4243 #[allow(deprecated)]
4244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4245 where
4246 S: serde::Serializer,
4247 {
4248 use serde::ser::SerializeStruct;
4249 let mut len = 0;
4250 if !self.reason.is_empty() {
4251 len += 1;
4252 }
4253 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4254 if !self.reason.is_empty() {
4255 struct_ser.serialize_field("reason", &self.reason)?;
4256 }
4257 struct_ser.end()
4258 }
4259}
4260impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4261 #[allow(deprecated)]
4262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4263 where
4264 D: serde::Deserializer<'de>,
4265 {
4266 const FIELDS: &[&str] = &[
4267 "reason",
4268 ];
4269
4270 #[allow(clippy::enum_variant_names)]
4271 enum GeneratedField {
4272 Reason,
4273 }
4274 impl<'de> serde::Deserialize<'de> for GeneratedField {
4275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4276 where
4277 D: serde::Deserializer<'de>,
4278 {
4279 struct GeneratedVisitor;
4280
4281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4282 type Value = GeneratedField;
4283
4284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4285 write!(formatter, "expected one of: {:?}", &FIELDS)
4286 }
4287
4288 #[allow(unused_variables)]
4289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4290 where
4291 E: serde::de::Error,
4292 {
4293 match value {
4294 "reason" => Ok(GeneratedField::Reason),
4295 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4296 }
4297 }
4298 }
4299 deserializer.deserialize_identifier(GeneratedVisitor)
4300 }
4301 }
4302 struct GeneratedVisitor;
4303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4304 type Value = event_log::event_recovery::GlobalRecoveryStart;
4305
4306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4307 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4308 }
4309
4310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4311 where
4312 V: serde::de::MapAccess<'de>,
4313 {
4314 let mut reason__ = None;
4315 while let Some(k) = map_.next_key()? {
4316 match k {
4317 GeneratedField::Reason => {
4318 if reason__.is_some() {
4319 return Err(serde::de::Error::duplicate_field("reason"));
4320 }
4321 reason__ = Some(map_.next_value()?);
4322 }
4323 }
4324 }
4325 Ok(event_log::event_recovery::GlobalRecoveryStart {
4326 reason: reason__.unwrap_or_default(),
4327 })
4328 }
4329 }
4330 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4331 }
4332}
4333impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4334 #[allow(deprecated)]
4335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4336 where
4337 S: serde::Serializer,
4338 {
4339 use serde::ser::SerializeStruct;
4340 let mut len = 0;
4341 if !self.reason.is_empty() {
4342 len += 1;
4343 }
4344 if self.duration_secs != 0. {
4345 len += 1;
4346 }
4347 if !self.running_database_ids.is_empty() {
4348 len += 1;
4349 }
4350 if !self.recovering_database_ids.is_empty() {
4351 len += 1;
4352 }
4353 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4354 if !self.reason.is_empty() {
4355 struct_ser.serialize_field("reason", &self.reason)?;
4356 }
4357 if self.duration_secs != 0. {
4358 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4359 }
4360 if !self.running_database_ids.is_empty() {
4361 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4362 }
4363 if !self.recovering_database_ids.is_empty() {
4364 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4365 }
4366 struct_ser.end()
4367 }
4368}
4369impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4370 #[allow(deprecated)]
4371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4372 where
4373 D: serde::Deserializer<'de>,
4374 {
4375 const FIELDS: &[&str] = &[
4376 "reason",
4377 "duration_secs",
4378 "durationSecs",
4379 "running_database_ids",
4380 "runningDatabaseIds",
4381 "recovering_database_ids",
4382 "recoveringDatabaseIds",
4383 ];
4384
4385 #[allow(clippy::enum_variant_names)]
4386 enum GeneratedField {
4387 Reason,
4388 DurationSecs,
4389 RunningDatabaseIds,
4390 RecoveringDatabaseIds,
4391 }
4392 impl<'de> serde::Deserialize<'de> for GeneratedField {
4393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4394 where
4395 D: serde::Deserializer<'de>,
4396 {
4397 struct GeneratedVisitor;
4398
4399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4400 type Value = GeneratedField;
4401
4402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4403 write!(formatter, "expected one of: {:?}", &FIELDS)
4404 }
4405
4406 #[allow(unused_variables)]
4407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4408 where
4409 E: serde::de::Error,
4410 {
4411 match value {
4412 "reason" => Ok(GeneratedField::Reason),
4413 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4414 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4415 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4417 }
4418 }
4419 }
4420 deserializer.deserialize_identifier(GeneratedVisitor)
4421 }
4422 }
4423 struct GeneratedVisitor;
4424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4425 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4426
4427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4428 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4429 }
4430
4431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4432 where
4433 V: serde::de::MapAccess<'de>,
4434 {
4435 let mut reason__ = None;
4436 let mut duration_secs__ = None;
4437 let mut running_database_ids__ = None;
4438 let mut recovering_database_ids__ = None;
4439 while let Some(k) = map_.next_key()? {
4440 match k {
4441 GeneratedField::Reason => {
4442 if reason__.is_some() {
4443 return Err(serde::de::Error::duplicate_field("reason"));
4444 }
4445 reason__ = Some(map_.next_value()?);
4446 }
4447 GeneratedField::DurationSecs => {
4448 if duration_secs__.is_some() {
4449 return Err(serde::de::Error::duplicate_field("durationSecs"));
4450 }
4451 duration_secs__ =
4452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4453 ;
4454 }
4455 GeneratedField::RunningDatabaseIds => {
4456 if running_database_ids__.is_some() {
4457 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4458 }
4459 running_database_ids__ =
4460 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4461 .into_iter().map(|x| x.0).collect())
4462 ;
4463 }
4464 GeneratedField::RecoveringDatabaseIds => {
4465 if recovering_database_ids__.is_some() {
4466 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4467 }
4468 recovering_database_ids__ =
4469 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4470 .into_iter().map(|x| x.0).collect())
4471 ;
4472 }
4473 }
4474 }
4475 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4476 reason: reason__.unwrap_or_default(),
4477 duration_secs: duration_secs__.unwrap_or_default(),
4478 running_database_ids: running_database_ids__.unwrap_or_default(),
4479 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4480 })
4481 }
4482 }
4483 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4484 }
4485}
4486impl serde::Serialize for event_log::EventSinkFail {
4487 #[allow(deprecated)]
4488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4489 where
4490 S: serde::Serializer,
4491 {
4492 use serde::ser::SerializeStruct;
4493 let mut len = 0;
4494 if self.sink_id != 0 {
4495 len += 1;
4496 }
4497 if !self.sink_name.is_empty() {
4498 len += 1;
4499 }
4500 if !self.connector.is_empty() {
4501 len += 1;
4502 }
4503 if !self.error.is_empty() {
4504 len += 1;
4505 }
4506 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4507 if self.sink_id != 0 {
4508 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4509 }
4510 if !self.sink_name.is_empty() {
4511 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4512 }
4513 if !self.connector.is_empty() {
4514 struct_ser.serialize_field("connector", &self.connector)?;
4515 }
4516 if !self.error.is_empty() {
4517 struct_ser.serialize_field("error", &self.error)?;
4518 }
4519 struct_ser.end()
4520 }
4521}
4522impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4523 #[allow(deprecated)]
4524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4525 where
4526 D: serde::Deserializer<'de>,
4527 {
4528 const FIELDS: &[&str] = &[
4529 "sink_id",
4530 "sinkId",
4531 "sink_name",
4532 "sinkName",
4533 "connector",
4534 "error",
4535 ];
4536
4537 #[allow(clippy::enum_variant_names)]
4538 enum GeneratedField {
4539 SinkId,
4540 SinkName,
4541 Connector,
4542 Error,
4543 }
4544 impl<'de> serde::Deserialize<'de> for GeneratedField {
4545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4546 where
4547 D: serde::Deserializer<'de>,
4548 {
4549 struct GeneratedVisitor;
4550
4551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4552 type Value = GeneratedField;
4553
4554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4555 write!(formatter, "expected one of: {:?}", &FIELDS)
4556 }
4557
4558 #[allow(unused_variables)]
4559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4560 where
4561 E: serde::de::Error,
4562 {
4563 match value {
4564 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4565 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4566 "connector" => Ok(GeneratedField::Connector),
4567 "error" => Ok(GeneratedField::Error),
4568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4569 }
4570 }
4571 }
4572 deserializer.deserialize_identifier(GeneratedVisitor)
4573 }
4574 }
4575 struct GeneratedVisitor;
4576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4577 type Value = event_log::EventSinkFail;
4578
4579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4580 formatter.write_str("struct meta.EventLog.EventSinkFail")
4581 }
4582
4583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4584 where
4585 V: serde::de::MapAccess<'de>,
4586 {
4587 let mut sink_id__ = None;
4588 let mut sink_name__ = None;
4589 let mut connector__ = None;
4590 let mut error__ = None;
4591 while let Some(k) = map_.next_key()? {
4592 match k {
4593 GeneratedField::SinkId => {
4594 if sink_id__.is_some() {
4595 return Err(serde::de::Error::duplicate_field("sinkId"));
4596 }
4597 sink_id__ =
4598 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4599 ;
4600 }
4601 GeneratedField::SinkName => {
4602 if sink_name__.is_some() {
4603 return Err(serde::de::Error::duplicate_field("sinkName"));
4604 }
4605 sink_name__ = Some(map_.next_value()?);
4606 }
4607 GeneratedField::Connector => {
4608 if connector__.is_some() {
4609 return Err(serde::de::Error::duplicate_field("connector"));
4610 }
4611 connector__ = Some(map_.next_value()?);
4612 }
4613 GeneratedField::Error => {
4614 if error__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("error"));
4616 }
4617 error__ = Some(map_.next_value()?);
4618 }
4619 }
4620 }
4621 Ok(event_log::EventSinkFail {
4622 sink_id: sink_id__.unwrap_or_default(),
4623 sink_name: sink_name__.unwrap_or_default(),
4624 connector: connector__.unwrap_or_default(),
4625 error: error__.unwrap_or_default(),
4626 })
4627 }
4628 }
4629 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4630 }
4631}
4632impl serde::Serialize for event_log::EventWorkerNodePanic {
4633 #[allow(deprecated)]
4634 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4635 where
4636 S: serde::Serializer,
4637 {
4638 use serde::ser::SerializeStruct;
4639 let mut len = 0;
4640 if self.worker_id != 0 {
4641 len += 1;
4642 }
4643 if self.worker_type != 0 {
4644 len += 1;
4645 }
4646 if self.host_addr.is_some() {
4647 len += 1;
4648 }
4649 if !self.panic_info.is_empty() {
4650 len += 1;
4651 }
4652 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4653 if self.worker_id != 0 {
4654 struct_ser.serialize_field("workerId", &self.worker_id)?;
4655 }
4656 if self.worker_type != 0 {
4657 let v = super::common::WorkerType::try_from(self.worker_type)
4658 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4659 struct_ser.serialize_field("workerType", &v)?;
4660 }
4661 if let Some(v) = self.host_addr.as_ref() {
4662 struct_ser.serialize_field("hostAddr", v)?;
4663 }
4664 if !self.panic_info.is_empty() {
4665 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4666 }
4667 struct_ser.end()
4668 }
4669}
4670impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4671 #[allow(deprecated)]
4672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4673 where
4674 D: serde::Deserializer<'de>,
4675 {
4676 const FIELDS: &[&str] = &[
4677 "worker_id",
4678 "workerId",
4679 "worker_type",
4680 "workerType",
4681 "host_addr",
4682 "hostAddr",
4683 "panic_info",
4684 "panicInfo",
4685 ];
4686
4687 #[allow(clippy::enum_variant_names)]
4688 enum GeneratedField {
4689 WorkerId,
4690 WorkerType,
4691 HostAddr,
4692 PanicInfo,
4693 }
4694 impl<'de> serde::Deserialize<'de> for GeneratedField {
4695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4696 where
4697 D: serde::Deserializer<'de>,
4698 {
4699 struct GeneratedVisitor;
4700
4701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4702 type Value = GeneratedField;
4703
4704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4705 write!(formatter, "expected one of: {:?}", &FIELDS)
4706 }
4707
4708 #[allow(unused_variables)]
4709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4710 where
4711 E: serde::de::Error,
4712 {
4713 match value {
4714 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4715 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4716 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4717 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4719 }
4720 }
4721 }
4722 deserializer.deserialize_identifier(GeneratedVisitor)
4723 }
4724 }
4725 struct GeneratedVisitor;
4726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4727 type Value = event_log::EventWorkerNodePanic;
4728
4729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4730 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4731 }
4732
4733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4734 where
4735 V: serde::de::MapAccess<'de>,
4736 {
4737 let mut worker_id__ = None;
4738 let mut worker_type__ = None;
4739 let mut host_addr__ = None;
4740 let mut panic_info__ = None;
4741 while let Some(k) = map_.next_key()? {
4742 match k {
4743 GeneratedField::WorkerId => {
4744 if worker_id__.is_some() {
4745 return Err(serde::de::Error::duplicate_field("workerId"));
4746 }
4747 worker_id__ =
4748 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4749 ;
4750 }
4751 GeneratedField::WorkerType => {
4752 if worker_type__.is_some() {
4753 return Err(serde::de::Error::duplicate_field("workerType"));
4754 }
4755 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4756 }
4757 GeneratedField::HostAddr => {
4758 if host_addr__.is_some() {
4759 return Err(serde::de::Error::duplicate_field("hostAddr"));
4760 }
4761 host_addr__ = map_.next_value()?;
4762 }
4763 GeneratedField::PanicInfo => {
4764 if panic_info__.is_some() {
4765 return Err(serde::de::Error::duplicate_field("panicInfo"));
4766 }
4767 panic_info__ = Some(map_.next_value()?);
4768 }
4769 }
4770 }
4771 Ok(event_log::EventWorkerNodePanic {
4772 worker_id: worker_id__.unwrap_or_default(),
4773 worker_type: worker_type__.unwrap_or_default(),
4774 host_addr: host_addr__,
4775 panic_info: panic_info__.unwrap_or_default(),
4776 })
4777 }
4778 }
4779 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4780 }
4781}
4782impl serde::Serialize for FlushRequest {
4783 #[allow(deprecated)]
4784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4785 where
4786 S: serde::Serializer,
4787 {
4788 use serde::ser::SerializeStruct;
4789 let mut len = 0;
4790 if self.database_id != 0 {
4791 len += 1;
4792 }
4793 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4794 if self.database_id != 0 {
4795 struct_ser.serialize_field("databaseId", &self.database_id)?;
4796 }
4797 struct_ser.end()
4798 }
4799}
4800impl<'de> serde::Deserialize<'de> for FlushRequest {
4801 #[allow(deprecated)]
4802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4803 where
4804 D: serde::Deserializer<'de>,
4805 {
4806 const FIELDS: &[&str] = &[
4807 "database_id",
4808 "databaseId",
4809 ];
4810
4811 #[allow(clippy::enum_variant_names)]
4812 enum GeneratedField {
4813 DatabaseId,
4814 }
4815 impl<'de> serde::Deserialize<'de> for GeneratedField {
4816 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4817 where
4818 D: serde::Deserializer<'de>,
4819 {
4820 struct GeneratedVisitor;
4821
4822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4823 type Value = GeneratedField;
4824
4825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4826 write!(formatter, "expected one of: {:?}", &FIELDS)
4827 }
4828
4829 #[allow(unused_variables)]
4830 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4831 where
4832 E: serde::de::Error,
4833 {
4834 match value {
4835 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4836 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4837 }
4838 }
4839 }
4840 deserializer.deserialize_identifier(GeneratedVisitor)
4841 }
4842 }
4843 struct GeneratedVisitor;
4844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4845 type Value = FlushRequest;
4846
4847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4848 formatter.write_str("struct meta.FlushRequest")
4849 }
4850
4851 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
4852 where
4853 V: serde::de::MapAccess<'de>,
4854 {
4855 let mut database_id__ = None;
4856 while let Some(k) = map_.next_key()? {
4857 match k {
4858 GeneratedField::DatabaseId => {
4859 if database_id__.is_some() {
4860 return Err(serde::de::Error::duplicate_field("databaseId"));
4861 }
4862 database_id__ =
4863 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4864 ;
4865 }
4866 }
4867 }
4868 Ok(FlushRequest {
4869 database_id: database_id__.unwrap_or_default(),
4870 })
4871 }
4872 }
4873 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
4874 }
4875}
4876impl serde::Serialize for FlushResponse {
4877 #[allow(deprecated)]
4878 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4879 where
4880 S: serde::Serializer,
4881 {
4882 use serde::ser::SerializeStruct;
4883 let mut len = 0;
4884 if self.status.is_some() {
4885 len += 1;
4886 }
4887 if self.hummock_version_id != 0 {
4888 len += 1;
4889 }
4890 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
4891 if let Some(v) = self.status.as_ref() {
4892 struct_ser.serialize_field("status", v)?;
4893 }
4894 if self.hummock_version_id != 0 {
4895 #[allow(clippy::needless_borrow)]
4896 #[allow(clippy::needless_borrows_for_generic_args)]
4897 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
4898 }
4899 struct_ser.end()
4900 }
4901}
4902impl<'de> serde::Deserialize<'de> for FlushResponse {
4903 #[allow(deprecated)]
4904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4905 where
4906 D: serde::Deserializer<'de>,
4907 {
4908 const FIELDS: &[&str] = &[
4909 "status",
4910 "hummock_version_id",
4911 "hummockVersionId",
4912 ];
4913
4914 #[allow(clippy::enum_variant_names)]
4915 enum GeneratedField {
4916 Status,
4917 HummockVersionId,
4918 }
4919 impl<'de> serde::Deserialize<'de> for GeneratedField {
4920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4921 where
4922 D: serde::Deserializer<'de>,
4923 {
4924 struct GeneratedVisitor;
4925
4926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4927 type Value = GeneratedField;
4928
4929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4930 write!(formatter, "expected one of: {:?}", &FIELDS)
4931 }
4932
4933 #[allow(unused_variables)]
4934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4935 where
4936 E: serde::de::Error,
4937 {
4938 match value {
4939 "status" => Ok(GeneratedField::Status),
4940 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
4941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4942 }
4943 }
4944 }
4945 deserializer.deserialize_identifier(GeneratedVisitor)
4946 }
4947 }
4948 struct GeneratedVisitor;
4949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4950 type Value = FlushResponse;
4951
4952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4953 formatter.write_str("struct meta.FlushResponse")
4954 }
4955
4956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
4957 where
4958 V: serde::de::MapAccess<'de>,
4959 {
4960 let mut status__ = None;
4961 let mut hummock_version_id__ = None;
4962 while let Some(k) = map_.next_key()? {
4963 match k {
4964 GeneratedField::Status => {
4965 if status__.is_some() {
4966 return Err(serde::de::Error::duplicate_field("status"));
4967 }
4968 status__ = map_.next_value()?;
4969 }
4970 GeneratedField::HummockVersionId => {
4971 if hummock_version_id__.is_some() {
4972 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
4973 }
4974 hummock_version_id__ =
4975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4976 ;
4977 }
4978 }
4979 }
4980 Ok(FlushResponse {
4981 status: status__,
4982 hummock_version_id: hummock_version_id__.unwrap_or_default(),
4983 })
4984 }
4985 }
4986 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
4987 }
4988}
4989impl serde::Serialize for FragmentDistribution {
4990 #[allow(deprecated)]
4991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4992 where
4993 S: serde::Serializer,
4994 {
4995 use serde::ser::SerializeStruct;
4996 let mut len = 0;
4997 if self.fragment_id != 0 {
4998 len += 1;
4999 }
5000 if self.table_id != 0 {
5001 len += 1;
5002 }
5003 if self.distribution_type != 0 {
5004 len += 1;
5005 }
5006 if !self.state_table_ids.is_empty() {
5007 len += 1;
5008 }
5009 if !self.upstream_fragment_ids.is_empty() {
5010 len += 1;
5011 }
5012 if self.fragment_type_mask != 0 {
5013 len += 1;
5014 }
5015 if self.parallelism != 0 {
5016 len += 1;
5017 }
5018 if self.vnode_count != 0 {
5019 len += 1;
5020 }
5021 if self.node.is_some() {
5022 len += 1;
5023 }
5024 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5025 if self.fragment_id != 0 {
5026 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5027 }
5028 if self.table_id != 0 {
5029 struct_ser.serialize_field("tableId", &self.table_id)?;
5030 }
5031 if self.distribution_type != 0 {
5032 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5033 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5034 struct_ser.serialize_field("distributionType", &v)?;
5035 }
5036 if !self.state_table_ids.is_empty() {
5037 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5038 }
5039 if !self.upstream_fragment_ids.is_empty() {
5040 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5041 }
5042 if self.fragment_type_mask != 0 {
5043 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5044 }
5045 if self.parallelism != 0 {
5046 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5047 }
5048 if self.vnode_count != 0 {
5049 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5050 }
5051 if let Some(v) = self.node.as_ref() {
5052 struct_ser.serialize_field("node", v)?;
5053 }
5054 struct_ser.end()
5055 }
5056}
5057impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5058 #[allow(deprecated)]
5059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5060 where
5061 D: serde::Deserializer<'de>,
5062 {
5063 const FIELDS: &[&str] = &[
5064 "fragment_id",
5065 "fragmentId",
5066 "table_id",
5067 "tableId",
5068 "distribution_type",
5069 "distributionType",
5070 "state_table_ids",
5071 "stateTableIds",
5072 "upstream_fragment_ids",
5073 "upstreamFragmentIds",
5074 "fragment_type_mask",
5075 "fragmentTypeMask",
5076 "parallelism",
5077 "vnode_count",
5078 "vnodeCount",
5079 "node",
5080 ];
5081
5082 #[allow(clippy::enum_variant_names)]
5083 enum GeneratedField {
5084 FragmentId,
5085 TableId,
5086 DistributionType,
5087 StateTableIds,
5088 UpstreamFragmentIds,
5089 FragmentTypeMask,
5090 Parallelism,
5091 VnodeCount,
5092 Node,
5093 }
5094 impl<'de> serde::Deserialize<'de> for GeneratedField {
5095 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5096 where
5097 D: serde::Deserializer<'de>,
5098 {
5099 struct GeneratedVisitor;
5100
5101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5102 type Value = GeneratedField;
5103
5104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5105 write!(formatter, "expected one of: {:?}", &FIELDS)
5106 }
5107
5108 #[allow(unused_variables)]
5109 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5110 where
5111 E: serde::de::Error,
5112 {
5113 match value {
5114 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5115 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5116 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5117 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5118 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5119 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5120 "parallelism" => Ok(GeneratedField::Parallelism),
5121 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5122 "node" => Ok(GeneratedField::Node),
5123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5124 }
5125 }
5126 }
5127 deserializer.deserialize_identifier(GeneratedVisitor)
5128 }
5129 }
5130 struct GeneratedVisitor;
5131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5132 type Value = FragmentDistribution;
5133
5134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5135 formatter.write_str("struct meta.FragmentDistribution")
5136 }
5137
5138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5139 where
5140 V: serde::de::MapAccess<'de>,
5141 {
5142 let mut fragment_id__ = None;
5143 let mut table_id__ = None;
5144 let mut distribution_type__ = None;
5145 let mut state_table_ids__ = None;
5146 let mut upstream_fragment_ids__ = None;
5147 let mut fragment_type_mask__ = None;
5148 let mut parallelism__ = None;
5149 let mut vnode_count__ = None;
5150 let mut node__ = None;
5151 while let Some(k) = map_.next_key()? {
5152 match k {
5153 GeneratedField::FragmentId => {
5154 if fragment_id__.is_some() {
5155 return Err(serde::de::Error::duplicate_field("fragmentId"));
5156 }
5157 fragment_id__ =
5158 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5159 ;
5160 }
5161 GeneratedField::TableId => {
5162 if table_id__.is_some() {
5163 return Err(serde::de::Error::duplicate_field("tableId"));
5164 }
5165 table_id__ =
5166 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5167 ;
5168 }
5169 GeneratedField::DistributionType => {
5170 if distribution_type__.is_some() {
5171 return Err(serde::de::Error::duplicate_field("distributionType"));
5172 }
5173 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5174 }
5175 GeneratedField::StateTableIds => {
5176 if state_table_ids__.is_some() {
5177 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5178 }
5179 state_table_ids__ =
5180 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5181 .into_iter().map(|x| x.0).collect())
5182 ;
5183 }
5184 GeneratedField::UpstreamFragmentIds => {
5185 if upstream_fragment_ids__.is_some() {
5186 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5187 }
5188 upstream_fragment_ids__ =
5189 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5190 .into_iter().map(|x| x.0).collect())
5191 ;
5192 }
5193 GeneratedField::FragmentTypeMask => {
5194 if fragment_type_mask__.is_some() {
5195 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5196 }
5197 fragment_type_mask__ =
5198 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5199 ;
5200 }
5201 GeneratedField::Parallelism => {
5202 if parallelism__.is_some() {
5203 return Err(serde::de::Error::duplicate_field("parallelism"));
5204 }
5205 parallelism__ =
5206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5207 ;
5208 }
5209 GeneratedField::VnodeCount => {
5210 if vnode_count__.is_some() {
5211 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5212 }
5213 vnode_count__ =
5214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5215 ;
5216 }
5217 GeneratedField::Node => {
5218 if node__.is_some() {
5219 return Err(serde::de::Error::duplicate_field("node"));
5220 }
5221 node__ = map_.next_value()?;
5222 }
5223 }
5224 }
5225 Ok(FragmentDistribution {
5226 fragment_id: fragment_id__.unwrap_or_default(),
5227 table_id: table_id__.unwrap_or_default(),
5228 distribution_type: distribution_type__.unwrap_or_default(),
5229 state_table_ids: state_table_ids__.unwrap_or_default(),
5230 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5231 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5232 parallelism: parallelism__.unwrap_or_default(),
5233 vnode_count: vnode_count__.unwrap_or_default(),
5234 node: node__,
5235 })
5236 }
5237 }
5238 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5239 }
5240}
5241impl serde::Serialize for FragmentIdToActorIdMap {
5242 #[allow(deprecated)]
5243 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5244 where
5245 S: serde::Serializer,
5246 {
5247 use serde::ser::SerializeStruct;
5248 let mut len = 0;
5249 if !self.map.is_empty() {
5250 len += 1;
5251 }
5252 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5253 if !self.map.is_empty() {
5254 struct_ser.serialize_field("map", &self.map)?;
5255 }
5256 struct_ser.end()
5257 }
5258}
5259impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5260 #[allow(deprecated)]
5261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5262 where
5263 D: serde::Deserializer<'de>,
5264 {
5265 const FIELDS: &[&str] = &[
5266 "map",
5267 ];
5268
5269 #[allow(clippy::enum_variant_names)]
5270 enum GeneratedField {
5271 Map,
5272 }
5273 impl<'de> serde::Deserialize<'de> for GeneratedField {
5274 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5275 where
5276 D: serde::Deserializer<'de>,
5277 {
5278 struct GeneratedVisitor;
5279
5280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5281 type Value = GeneratedField;
5282
5283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5284 write!(formatter, "expected one of: {:?}", &FIELDS)
5285 }
5286
5287 #[allow(unused_variables)]
5288 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5289 where
5290 E: serde::de::Error,
5291 {
5292 match value {
5293 "map" => Ok(GeneratedField::Map),
5294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5295 }
5296 }
5297 }
5298 deserializer.deserialize_identifier(GeneratedVisitor)
5299 }
5300 }
5301 struct GeneratedVisitor;
5302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5303 type Value = FragmentIdToActorIdMap;
5304
5305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5306 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5307 }
5308
5309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5310 where
5311 V: serde::de::MapAccess<'de>,
5312 {
5313 let mut map__ = None;
5314 while let Some(k) = map_.next_key()? {
5315 match k {
5316 GeneratedField::Map => {
5317 if map__.is_some() {
5318 return Err(serde::de::Error::duplicate_field("map"));
5319 }
5320 map__ = Some(
5321 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5322 .into_iter().map(|(k,v)| (k.0, v)).collect()
5323 );
5324 }
5325 }
5326 }
5327 Ok(FragmentIdToActorIdMap {
5328 map: map__.unwrap_or_default(),
5329 })
5330 }
5331 }
5332 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5333 }
5334}
5335impl serde::Serialize for FragmentToRelationMap {
5336 #[allow(deprecated)]
5337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5338 where
5339 S: serde::Serializer,
5340 {
5341 use serde::ser::SerializeStruct;
5342 let mut len = 0;
5343 if !self.in_map.is_empty() {
5344 len += 1;
5345 }
5346 if !self.out_map.is_empty() {
5347 len += 1;
5348 }
5349 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5350 if !self.in_map.is_empty() {
5351 struct_ser.serialize_field("inMap", &self.in_map)?;
5352 }
5353 if !self.out_map.is_empty() {
5354 struct_ser.serialize_field("outMap", &self.out_map)?;
5355 }
5356 struct_ser.end()
5357 }
5358}
5359impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5360 #[allow(deprecated)]
5361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5362 where
5363 D: serde::Deserializer<'de>,
5364 {
5365 const FIELDS: &[&str] = &[
5366 "in_map",
5367 "inMap",
5368 "out_map",
5369 "outMap",
5370 ];
5371
5372 #[allow(clippy::enum_variant_names)]
5373 enum GeneratedField {
5374 InMap,
5375 OutMap,
5376 }
5377 impl<'de> serde::Deserialize<'de> for GeneratedField {
5378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5379 where
5380 D: serde::Deserializer<'de>,
5381 {
5382 struct GeneratedVisitor;
5383
5384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5385 type Value = GeneratedField;
5386
5387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5388 write!(formatter, "expected one of: {:?}", &FIELDS)
5389 }
5390
5391 #[allow(unused_variables)]
5392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5393 where
5394 E: serde::de::Error,
5395 {
5396 match value {
5397 "inMap" | "in_map" => Ok(GeneratedField::InMap),
5398 "outMap" | "out_map" => Ok(GeneratedField::OutMap),
5399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5400 }
5401 }
5402 }
5403 deserializer.deserialize_identifier(GeneratedVisitor)
5404 }
5405 }
5406 struct GeneratedVisitor;
5407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5408 type Value = FragmentToRelationMap;
5409
5410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5411 formatter.write_str("struct meta.FragmentToRelationMap")
5412 }
5413
5414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5415 where
5416 V: serde::de::MapAccess<'de>,
5417 {
5418 let mut in_map__ = None;
5419 let mut out_map__ = None;
5420 while let Some(k) = map_.next_key()? {
5421 match k {
5422 GeneratedField::InMap => {
5423 if in_map__.is_some() {
5424 return Err(serde::de::Error::duplicate_field("inMap"));
5425 }
5426 in_map__ = Some(
5427 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5428 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5429 );
5430 }
5431 GeneratedField::OutMap => {
5432 if out_map__.is_some() {
5433 return Err(serde::de::Error::duplicate_field("outMap"));
5434 }
5435 out_map__ = Some(
5436 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5437 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5438 );
5439 }
5440 }
5441 }
5442 Ok(FragmentToRelationMap {
5443 in_map: in_map__.unwrap_or_default(),
5444 out_map: out_map__.unwrap_or_default(),
5445 })
5446 }
5447 }
5448 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5449 }
5450}
5451impl serde::Serialize for FragmentWorkerSlotMapping {
5452 #[allow(deprecated)]
5453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5454 where
5455 S: serde::Serializer,
5456 {
5457 use serde::ser::SerializeStruct;
5458 let mut len = 0;
5459 if self.fragment_id != 0 {
5460 len += 1;
5461 }
5462 if self.mapping.is_some() {
5463 len += 1;
5464 }
5465 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5466 if self.fragment_id != 0 {
5467 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5468 }
5469 if let Some(v) = self.mapping.as_ref() {
5470 struct_ser.serialize_field("mapping", v)?;
5471 }
5472 struct_ser.end()
5473 }
5474}
5475impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5476 #[allow(deprecated)]
5477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5478 where
5479 D: serde::Deserializer<'de>,
5480 {
5481 const FIELDS: &[&str] = &[
5482 "fragment_id",
5483 "fragmentId",
5484 "mapping",
5485 ];
5486
5487 #[allow(clippy::enum_variant_names)]
5488 enum GeneratedField {
5489 FragmentId,
5490 Mapping,
5491 }
5492 impl<'de> serde::Deserialize<'de> for GeneratedField {
5493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5494 where
5495 D: serde::Deserializer<'de>,
5496 {
5497 struct GeneratedVisitor;
5498
5499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5500 type Value = GeneratedField;
5501
5502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5503 write!(formatter, "expected one of: {:?}", &FIELDS)
5504 }
5505
5506 #[allow(unused_variables)]
5507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5508 where
5509 E: serde::de::Error,
5510 {
5511 match value {
5512 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5513 "mapping" => Ok(GeneratedField::Mapping),
5514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5515 }
5516 }
5517 }
5518 deserializer.deserialize_identifier(GeneratedVisitor)
5519 }
5520 }
5521 struct GeneratedVisitor;
5522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5523 type Value = FragmentWorkerSlotMapping;
5524
5525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5526 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5527 }
5528
5529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5530 where
5531 V: serde::de::MapAccess<'de>,
5532 {
5533 let mut fragment_id__ = None;
5534 let mut mapping__ = None;
5535 while let Some(k) = map_.next_key()? {
5536 match k {
5537 GeneratedField::FragmentId => {
5538 if fragment_id__.is_some() {
5539 return Err(serde::de::Error::duplicate_field("fragmentId"));
5540 }
5541 fragment_id__ =
5542 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5543 ;
5544 }
5545 GeneratedField::Mapping => {
5546 if mapping__.is_some() {
5547 return Err(serde::de::Error::duplicate_field("mapping"));
5548 }
5549 mapping__ = map_.next_value()?;
5550 }
5551 }
5552 }
5553 Ok(FragmentWorkerSlotMapping {
5554 fragment_id: fragment_id__.unwrap_or_default(),
5555 mapping: mapping__,
5556 })
5557 }
5558 }
5559 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5560 }
5561}
5562impl serde::Serialize for FragmentWorkerSlotMappings {
5563 #[allow(deprecated)]
5564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5565 where
5566 S: serde::Serializer,
5567 {
5568 use serde::ser::SerializeStruct;
5569 let mut len = 0;
5570 if !self.mappings.is_empty() {
5571 len += 1;
5572 }
5573 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5574 if !self.mappings.is_empty() {
5575 struct_ser.serialize_field("mappings", &self.mappings)?;
5576 }
5577 struct_ser.end()
5578 }
5579}
5580impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5581 #[allow(deprecated)]
5582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5583 where
5584 D: serde::Deserializer<'de>,
5585 {
5586 const FIELDS: &[&str] = &[
5587 "mappings",
5588 ];
5589
5590 #[allow(clippy::enum_variant_names)]
5591 enum GeneratedField {
5592 Mappings,
5593 }
5594 impl<'de> serde::Deserialize<'de> for GeneratedField {
5595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5596 where
5597 D: serde::Deserializer<'de>,
5598 {
5599 struct GeneratedVisitor;
5600
5601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5602 type Value = GeneratedField;
5603
5604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5605 write!(formatter, "expected one of: {:?}", &FIELDS)
5606 }
5607
5608 #[allow(unused_variables)]
5609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5610 where
5611 E: serde::de::Error,
5612 {
5613 match value {
5614 "mappings" => Ok(GeneratedField::Mappings),
5615 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5616 }
5617 }
5618 }
5619 deserializer.deserialize_identifier(GeneratedVisitor)
5620 }
5621 }
5622 struct GeneratedVisitor;
5623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5624 type Value = FragmentWorkerSlotMappings;
5625
5626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5627 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5628 }
5629
5630 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5631 where
5632 V: serde::de::MapAccess<'de>,
5633 {
5634 let mut mappings__ = None;
5635 while let Some(k) = map_.next_key()? {
5636 match k {
5637 GeneratedField::Mappings => {
5638 if mappings__.is_some() {
5639 return Err(serde::de::Error::duplicate_field("mappings"));
5640 }
5641 mappings__ = Some(map_.next_value()?);
5642 }
5643 }
5644 }
5645 Ok(FragmentWorkerSlotMappings {
5646 mappings: mappings__.unwrap_or_default(),
5647 })
5648 }
5649 }
5650 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5651 }
5652}
5653impl serde::Serialize for GetClusterInfoRequest {
5654 #[allow(deprecated)]
5655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5656 where
5657 S: serde::Serializer,
5658 {
5659 use serde::ser::SerializeStruct;
5660 let len = 0;
5661 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5662 struct_ser.end()
5663 }
5664}
5665impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5666 #[allow(deprecated)]
5667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5668 where
5669 D: serde::Deserializer<'de>,
5670 {
5671 const FIELDS: &[&str] = &[
5672 ];
5673
5674 #[allow(clippy::enum_variant_names)]
5675 enum GeneratedField {
5676 }
5677 impl<'de> serde::Deserialize<'de> for GeneratedField {
5678 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5679 where
5680 D: serde::Deserializer<'de>,
5681 {
5682 struct GeneratedVisitor;
5683
5684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5685 type Value = GeneratedField;
5686
5687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5688 write!(formatter, "expected one of: {:?}", &FIELDS)
5689 }
5690
5691 #[allow(unused_variables)]
5692 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5693 where
5694 E: serde::de::Error,
5695 {
5696 Err(serde::de::Error::unknown_field(value, FIELDS))
5697 }
5698 }
5699 deserializer.deserialize_identifier(GeneratedVisitor)
5700 }
5701 }
5702 struct GeneratedVisitor;
5703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5704 type Value = GetClusterInfoRequest;
5705
5706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5707 formatter.write_str("struct meta.GetClusterInfoRequest")
5708 }
5709
5710 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5711 where
5712 V: serde::de::MapAccess<'de>,
5713 {
5714 while map_.next_key::<GeneratedField>()?.is_some() {
5715 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5716 }
5717 Ok(GetClusterInfoRequest {
5718 })
5719 }
5720 }
5721 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5722 }
5723}
5724impl serde::Serialize for GetClusterInfoResponse {
5725 #[allow(deprecated)]
5726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5727 where
5728 S: serde::Serializer,
5729 {
5730 use serde::ser::SerializeStruct;
5731 let mut len = 0;
5732 if !self.worker_nodes.is_empty() {
5733 len += 1;
5734 }
5735 if !self.table_fragments.is_empty() {
5736 len += 1;
5737 }
5738 if !self.actor_splits.is_empty() {
5739 len += 1;
5740 }
5741 if !self.source_infos.is_empty() {
5742 len += 1;
5743 }
5744 if self.revision != 0 {
5745 len += 1;
5746 }
5747 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5748 if !self.worker_nodes.is_empty() {
5749 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5750 }
5751 if !self.table_fragments.is_empty() {
5752 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5753 }
5754 if !self.actor_splits.is_empty() {
5755 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5756 }
5757 if !self.source_infos.is_empty() {
5758 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5759 }
5760 if self.revision != 0 {
5761 #[allow(clippy::needless_borrow)]
5762 #[allow(clippy::needless_borrows_for_generic_args)]
5763 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5764 }
5765 struct_ser.end()
5766 }
5767}
5768impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5769 #[allow(deprecated)]
5770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5771 where
5772 D: serde::Deserializer<'de>,
5773 {
5774 const FIELDS: &[&str] = &[
5775 "worker_nodes",
5776 "workerNodes",
5777 "table_fragments",
5778 "tableFragments",
5779 "actor_splits",
5780 "actorSplits",
5781 "source_infos",
5782 "sourceInfos",
5783 "revision",
5784 ];
5785
5786 #[allow(clippy::enum_variant_names)]
5787 enum GeneratedField {
5788 WorkerNodes,
5789 TableFragments,
5790 ActorSplits,
5791 SourceInfos,
5792 Revision,
5793 }
5794 impl<'de> serde::Deserialize<'de> for GeneratedField {
5795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5796 where
5797 D: serde::Deserializer<'de>,
5798 {
5799 struct GeneratedVisitor;
5800
5801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5802 type Value = GeneratedField;
5803
5804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5805 write!(formatter, "expected one of: {:?}", &FIELDS)
5806 }
5807
5808 #[allow(unused_variables)]
5809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5810 where
5811 E: serde::de::Error,
5812 {
5813 match value {
5814 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5815 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5816 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5817 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5818 "revision" => Ok(GeneratedField::Revision),
5819 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5820 }
5821 }
5822 }
5823 deserializer.deserialize_identifier(GeneratedVisitor)
5824 }
5825 }
5826 struct GeneratedVisitor;
5827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5828 type Value = GetClusterInfoResponse;
5829
5830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5831 formatter.write_str("struct meta.GetClusterInfoResponse")
5832 }
5833
5834 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5835 where
5836 V: serde::de::MapAccess<'de>,
5837 {
5838 let mut worker_nodes__ = None;
5839 let mut table_fragments__ = None;
5840 let mut actor_splits__ = None;
5841 let mut source_infos__ = None;
5842 let mut revision__ = None;
5843 while let Some(k) = map_.next_key()? {
5844 match k {
5845 GeneratedField::WorkerNodes => {
5846 if worker_nodes__.is_some() {
5847 return Err(serde::de::Error::duplicate_field("workerNodes"));
5848 }
5849 worker_nodes__ = Some(map_.next_value()?);
5850 }
5851 GeneratedField::TableFragments => {
5852 if table_fragments__.is_some() {
5853 return Err(serde::de::Error::duplicate_field("tableFragments"));
5854 }
5855 table_fragments__ = Some(map_.next_value()?);
5856 }
5857 GeneratedField::ActorSplits => {
5858 if actor_splits__.is_some() {
5859 return Err(serde::de::Error::duplicate_field("actorSplits"));
5860 }
5861 actor_splits__ = Some(
5862 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5863 .into_iter().map(|(k,v)| (k.0, v)).collect()
5864 );
5865 }
5866 GeneratedField::SourceInfos => {
5867 if source_infos__.is_some() {
5868 return Err(serde::de::Error::duplicate_field("sourceInfos"));
5869 }
5870 source_infos__ = Some(
5871 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5872 .into_iter().map(|(k,v)| (k.0, v)).collect()
5873 );
5874 }
5875 GeneratedField::Revision => {
5876 if revision__.is_some() {
5877 return Err(serde::de::Error::duplicate_field("revision"));
5878 }
5879 revision__ =
5880 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5881 ;
5882 }
5883 }
5884 }
5885 Ok(GetClusterInfoResponse {
5886 worker_nodes: worker_nodes__.unwrap_or_default(),
5887 table_fragments: table_fragments__.unwrap_or_default(),
5888 actor_splits: actor_splits__.unwrap_or_default(),
5889 source_infos: source_infos__.unwrap_or_default(),
5890 revision: revision__.unwrap_or_default(),
5891 })
5892 }
5893 }
5894 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
5895 }
5896}
5897impl serde::Serialize for GetClusterLimitsRequest {
5898 #[allow(deprecated)]
5899 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5900 where
5901 S: serde::Serializer,
5902 {
5903 use serde::ser::SerializeStruct;
5904 let len = 0;
5905 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
5906 struct_ser.end()
5907 }
5908}
5909impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
5910 #[allow(deprecated)]
5911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5912 where
5913 D: serde::Deserializer<'de>,
5914 {
5915 const FIELDS: &[&str] = &[
5916 ];
5917
5918 #[allow(clippy::enum_variant_names)]
5919 enum GeneratedField {
5920 }
5921 impl<'de> serde::Deserialize<'de> for GeneratedField {
5922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5923 where
5924 D: serde::Deserializer<'de>,
5925 {
5926 struct GeneratedVisitor;
5927
5928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5929 type Value = GeneratedField;
5930
5931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5932 write!(formatter, "expected one of: {:?}", &FIELDS)
5933 }
5934
5935 #[allow(unused_variables)]
5936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5937 where
5938 E: serde::de::Error,
5939 {
5940 Err(serde::de::Error::unknown_field(value, FIELDS))
5941 }
5942 }
5943 deserializer.deserialize_identifier(GeneratedVisitor)
5944 }
5945 }
5946 struct GeneratedVisitor;
5947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5948 type Value = GetClusterLimitsRequest;
5949
5950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5951 formatter.write_str("struct meta.GetClusterLimitsRequest")
5952 }
5953
5954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
5955 where
5956 V: serde::de::MapAccess<'de>,
5957 {
5958 while map_.next_key::<GeneratedField>()?.is_some() {
5959 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5960 }
5961 Ok(GetClusterLimitsRequest {
5962 })
5963 }
5964 }
5965 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
5966 }
5967}
5968impl serde::Serialize for GetClusterLimitsResponse {
5969 #[allow(deprecated)]
5970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5971 where
5972 S: serde::Serializer,
5973 {
5974 use serde::ser::SerializeStruct;
5975 let mut len = 0;
5976 if !self.active_limits.is_empty() {
5977 len += 1;
5978 }
5979 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
5980 if !self.active_limits.is_empty() {
5981 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
5982 }
5983 struct_ser.end()
5984 }
5985}
5986impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
5987 #[allow(deprecated)]
5988 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5989 where
5990 D: serde::Deserializer<'de>,
5991 {
5992 const FIELDS: &[&str] = &[
5993 "active_limits",
5994 "activeLimits",
5995 ];
5996
5997 #[allow(clippy::enum_variant_names)]
5998 enum GeneratedField {
5999 ActiveLimits,
6000 }
6001 impl<'de> serde::Deserialize<'de> for GeneratedField {
6002 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6003 where
6004 D: serde::Deserializer<'de>,
6005 {
6006 struct GeneratedVisitor;
6007
6008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6009 type Value = GeneratedField;
6010
6011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6012 write!(formatter, "expected one of: {:?}", &FIELDS)
6013 }
6014
6015 #[allow(unused_variables)]
6016 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6017 where
6018 E: serde::de::Error,
6019 {
6020 match value {
6021 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6022 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6023 }
6024 }
6025 }
6026 deserializer.deserialize_identifier(GeneratedVisitor)
6027 }
6028 }
6029 struct GeneratedVisitor;
6030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6031 type Value = GetClusterLimitsResponse;
6032
6033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6034 formatter.write_str("struct meta.GetClusterLimitsResponse")
6035 }
6036
6037 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6038 where
6039 V: serde::de::MapAccess<'de>,
6040 {
6041 let mut active_limits__ = None;
6042 while let Some(k) = map_.next_key()? {
6043 match k {
6044 GeneratedField::ActiveLimits => {
6045 if active_limits__.is_some() {
6046 return Err(serde::de::Error::duplicate_field("activeLimits"));
6047 }
6048 active_limits__ = Some(map_.next_value()?);
6049 }
6050 }
6051 }
6052 Ok(GetClusterLimitsResponse {
6053 active_limits: active_limits__.unwrap_or_default(),
6054 })
6055 }
6056 }
6057 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6058 }
6059}
6060impl serde::Serialize for GetClusterRecoveryStatusRequest {
6061 #[allow(deprecated)]
6062 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6063 where
6064 S: serde::Serializer,
6065 {
6066 use serde::ser::SerializeStruct;
6067 let len = 0;
6068 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6069 struct_ser.end()
6070 }
6071}
6072impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6073 #[allow(deprecated)]
6074 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6075 where
6076 D: serde::Deserializer<'de>,
6077 {
6078 const FIELDS: &[&str] = &[
6079 ];
6080
6081 #[allow(clippy::enum_variant_names)]
6082 enum GeneratedField {
6083 }
6084 impl<'de> serde::Deserialize<'de> for GeneratedField {
6085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6086 where
6087 D: serde::Deserializer<'de>,
6088 {
6089 struct GeneratedVisitor;
6090
6091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6092 type Value = GeneratedField;
6093
6094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6095 write!(formatter, "expected one of: {:?}", &FIELDS)
6096 }
6097
6098 #[allow(unused_variables)]
6099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6100 where
6101 E: serde::de::Error,
6102 {
6103 Err(serde::de::Error::unknown_field(value, FIELDS))
6104 }
6105 }
6106 deserializer.deserialize_identifier(GeneratedVisitor)
6107 }
6108 }
6109 struct GeneratedVisitor;
6110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6111 type Value = GetClusterRecoveryStatusRequest;
6112
6113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6114 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6115 }
6116
6117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6118 where
6119 V: serde::de::MapAccess<'de>,
6120 {
6121 while map_.next_key::<GeneratedField>()?.is_some() {
6122 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6123 }
6124 Ok(GetClusterRecoveryStatusRequest {
6125 })
6126 }
6127 }
6128 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6129 }
6130}
6131impl serde::Serialize for GetClusterRecoveryStatusResponse {
6132 #[allow(deprecated)]
6133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6134 where
6135 S: serde::Serializer,
6136 {
6137 use serde::ser::SerializeStruct;
6138 let mut len = 0;
6139 if self.status != 0 {
6140 len += 1;
6141 }
6142 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6143 if self.status != 0 {
6144 let v = RecoveryStatus::try_from(self.status)
6145 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6146 struct_ser.serialize_field("status", &v)?;
6147 }
6148 struct_ser.end()
6149 }
6150}
6151impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6152 #[allow(deprecated)]
6153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6154 where
6155 D: serde::Deserializer<'de>,
6156 {
6157 const FIELDS: &[&str] = &[
6158 "status",
6159 ];
6160
6161 #[allow(clippy::enum_variant_names)]
6162 enum GeneratedField {
6163 Status,
6164 }
6165 impl<'de> serde::Deserialize<'de> for GeneratedField {
6166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6167 where
6168 D: serde::Deserializer<'de>,
6169 {
6170 struct GeneratedVisitor;
6171
6172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6173 type Value = GeneratedField;
6174
6175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6176 write!(formatter, "expected one of: {:?}", &FIELDS)
6177 }
6178
6179 #[allow(unused_variables)]
6180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6181 where
6182 E: serde::de::Error,
6183 {
6184 match value {
6185 "status" => Ok(GeneratedField::Status),
6186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6187 }
6188 }
6189 }
6190 deserializer.deserialize_identifier(GeneratedVisitor)
6191 }
6192 }
6193 struct GeneratedVisitor;
6194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6195 type Value = GetClusterRecoveryStatusResponse;
6196
6197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6198 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6199 }
6200
6201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6202 where
6203 V: serde::de::MapAccess<'de>,
6204 {
6205 let mut status__ = None;
6206 while let Some(k) = map_.next_key()? {
6207 match k {
6208 GeneratedField::Status => {
6209 if status__.is_some() {
6210 return Err(serde::de::Error::duplicate_field("status"));
6211 }
6212 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6213 }
6214 }
6215 }
6216 Ok(GetClusterRecoveryStatusResponse {
6217 status: status__.unwrap_or_default(),
6218 })
6219 }
6220 }
6221 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6222 }
6223}
6224impl serde::Serialize for GetFragmentByIdRequest {
6225 #[allow(deprecated)]
6226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6227 where
6228 S: serde::Serializer,
6229 {
6230 use serde::ser::SerializeStruct;
6231 let mut len = 0;
6232 if self.fragment_id != 0 {
6233 len += 1;
6234 }
6235 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6236 if self.fragment_id != 0 {
6237 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6238 }
6239 struct_ser.end()
6240 }
6241}
6242impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6243 #[allow(deprecated)]
6244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6245 where
6246 D: serde::Deserializer<'de>,
6247 {
6248 const FIELDS: &[&str] = &[
6249 "fragment_id",
6250 "fragmentId",
6251 ];
6252
6253 #[allow(clippy::enum_variant_names)]
6254 enum GeneratedField {
6255 FragmentId,
6256 }
6257 impl<'de> serde::Deserialize<'de> for GeneratedField {
6258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6259 where
6260 D: serde::Deserializer<'de>,
6261 {
6262 struct GeneratedVisitor;
6263
6264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6265 type Value = GeneratedField;
6266
6267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6268 write!(formatter, "expected one of: {:?}", &FIELDS)
6269 }
6270
6271 #[allow(unused_variables)]
6272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6273 where
6274 E: serde::de::Error,
6275 {
6276 match value {
6277 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6279 }
6280 }
6281 }
6282 deserializer.deserialize_identifier(GeneratedVisitor)
6283 }
6284 }
6285 struct GeneratedVisitor;
6286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6287 type Value = GetFragmentByIdRequest;
6288
6289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6290 formatter.write_str("struct meta.GetFragmentByIdRequest")
6291 }
6292
6293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6294 where
6295 V: serde::de::MapAccess<'de>,
6296 {
6297 let mut fragment_id__ = None;
6298 while let Some(k) = map_.next_key()? {
6299 match k {
6300 GeneratedField::FragmentId => {
6301 if fragment_id__.is_some() {
6302 return Err(serde::de::Error::duplicate_field("fragmentId"));
6303 }
6304 fragment_id__ =
6305 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6306 ;
6307 }
6308 }
6309 }
6310 Ok(GetFragmentByIdRequest {
6311 fragment_id: fragment_id__.unwrap_or_default(),
6312 })
6313 }
6314 }
6315 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6316 }
6317}
6318impl serde::Serialize for GetFragmentByIdResponse {
6319 #[allow(deprecated)]
6320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6321 where
6322 S: serde::Serializer,
6323 {
6324 use serde::ser::SerializeStruct;
6325 let mut len = 0;
6326 if self.distribution.is_some() {
6327 len += 1;
6328 }
6329 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6330 if let Some(v) = self.distribution.as_ref() {
6331 struct_ser.serialize_field("distribution", v)?;
6332 }
6333 struct_ser.end()
6334 }
6335}
6336impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6337 #[allow(deprecated)]
6338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6339 where
6340 D: serde::Deserializer<'de>,
6341 {
6342 const FIELDS: &[&str] = &[
6343 "distribution",
6344 ];
6345
6346 #[allow(clippy::enum_variant_names)]
6347 enum GeneratedField {
6348 Distribution,
6349 }
6350 impl<'de> serde::Deserialize<'de> for GeneratedField {
6351 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6352 where
6353 D: serde::Deserializer<'de>,
6354 {
6355 struct GeneratedVisitor;
6356
6357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6358 type Value = GeneratedField;
6359
6360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6361 write!(formatter, "expected one of: {:?}", &FIELDS)
6362 }
6363
6364 #[allow(unused_variables)]
6365 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6366 where
6367 E: serde::de::Error,
6368 {
6369 match value {
6370 "distribution" => Ok(GeneratedField::Distribution),
6371 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6372 }
6373 }
6374 }
6375 deserializer.deserialize_identifier(GeneratedVisitor)
6376 }
6377 }
6378 struct GeneratedVisitor;
6379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6380 type Value = GetFragmentByIdResponse;
6381
6382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6383 formatter.write_str("struct meta.GetFragmentByIdResponse")
6384 }
6385
6386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6387 where
6388 V: serde::de::MapAccess<'de>,
6389 {
6390 let mut distribution__ = None;
6391 while let Some(k) = map_.next_key()? {
6392 match k {
6393 GeneratedField::Distribution => {
6394 if distribution__.is_some() {
6395 return Err(serde::de::Error::duplicate_field("distribution"));
6396 }
6397 distribution__ = map_.next_value()?;
6398 }
6399 }
6400 }
6401 Ok(GetFragmentByIdResponse {
6402 distribution: distribution__,
6403 })
6404 }
6405 }
6406 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6407 }
6408}
6409impl serde::Serialize for GetMetaStoreInfoRequest {
6410 #[allow(deprecated)]
6411 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6412 where
6413 S: serde::Serializer,
6414 {
6415 use serde::ser::SerializeStruct;
6416 let len = 0;
6417 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6418 struct_ser.end()
6419 }
6420}
6421impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6422 #[allow(deprecated)]
6423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6424 where
6425 D: serde::Deserializer<'de>,
6426 {
6427 const FIELDS: &[&str] = &[
6428 ];
6429
6430 #[allow(clippy::enum_variant_names)]
6431 enum GeneratedField {
6432 }
6433 impl<'de> serde::Deserialize<'de> for GeneratedField {
6434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6435 where
6436 D: serde::Deserializer<'de>,
6437 {
6438 struct GeneratedVisitor;
6439
6440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6441 type Value = GeneratedField;
6442
6443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6444 write!(formatter, "expected one of: {:?}", &FIELDS)
6445 }
6446
6447 #[allow(unused_variables)]
6448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6449 where
6450 E: serde::de::Error,
6451 {
6452 Err(serde::de::Error::unknown_field(value, FIELDS))
6453 }
6454 }
6455 deserializer.deserialize_identifier(GeneratedVisitor)
6456 }
6457 }
6458 struct GeneratedVisitor;
6459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6460 type Value = GetMetaStoreInfoRequest;
6461
6462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6463 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6464 }
6465
6466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6467 where
6468 V: serde::de::MapAccess<'de>,
6469 {
6470 while map_.next_key::<GeneratedField>()?.is_some() {
6471 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6472 }
6473 Ok(GetMetaStoreInfoRequest {
6474 })
6475 }
6476 }
6477 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6478 }
6479}
6480impl serde::Serialize for GetMetaStoreInfoResponse {
6481 #[allow(deprecated)]
6482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6483 where
6484 S: serde::Serializer,
6485 {
6486 use serde::ser::SerializeStruct;
6487 let mut len = 0;
6488 if !self.meta_store_endpoint.is_empty() {
6489 len += 1;
6490 }
6491 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6492 if !self.meta_store_endpoint.is_empty() {
6493 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6494 }
6495 struct_ser.end()
6496 }
6497}
6498impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6499 #[allow(deprecated)]
6500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6501 where
6502 D: serde::Deserializer<'de>,
6503 {
6504 const FIELDS: &[&str] = &[
6505 "meta_store_endpoint",
6506 "metaStoreEndpoint",
6507 ];
6508
6509 #[allow(clippy::enum_variant_names)]
6510 enum GeneratedField {
6511 MetaStoreEndpoint,
6512 }
6513 impl<'de> serde::Deserialize<'de> for GeneratedField {
6514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6515 where
6516 D: serde::Deserializer<'de>,
6517 {
6518 struct GeneratedVisitor;
6519
6520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6521 type Value = GeneratedField;
6522
6523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6524 write!(formatter, "expected one of: {:?}", &FIELDS)
6525 }
6526
6527 #[allow(unused_variables)]
6528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6529 where
6530 E: serde::de::Error,
6531 {
6532 match value {
6533 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6535 }
6536 }
6537 }
6538 deserializer.deserialize_identifier(GeneratedVisitor)
6539 }
6540 }
6541 struct GeneratedVisitor;
6542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6543 type Value = GetMetaStoreInfoResponse;
6544
6545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6546 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6547 }
6548
6549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6550 where
6551 V: serde::de::MapAccess<'de>,
6552 {
6553 let mut meta_store_endpoint__ = None;
6554 while let Some(k) = map_.next_key()? {
6555 match k {
6556 GeneratedField::MetaStoreEndpoint => {
6557 if meta_store_endpoint__.is_some() {
6558 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6559 }
6560 meta_store_endpoint__ = Some(map_.next_value()?);
6561 }
6562 }
6563 }
6564 Ok(GetMetaStoreInfoResponse {
6565 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6566 })
6567 }
6568 }
6569 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6570 }
6571}
6572impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6573 #[allow(deprecated)]
6574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6575 where
6576 S: serde::Serializer,
6577 {
6578 use serde::ser::SerializeStruct;
6579 let len = 0;
6580 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6581 struct_ser.end()
6582 }
6583}
6584impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6585 #[allow(deprecated)]
6586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6587 where
6588 D: serde::Deserializer<'de>,
6589 {
6590 const FIELDS: &[&str] = &[
6591 ];
6592
6593 #[allow(clippy::enum_variant_names)]
6594 enum GeneratedField {
6595 }
6596 impl<'de> serde::Deserialize<'de> for GeneratedField {
6597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6598 where
6599 D: serde::Deserializer<'de>,
6600 {
6601 struct GeneratedVisitor;
6602
6603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6604 type Value = GeneratedField;
6605
6606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6607 write!(formatter, "expected one of: {:?}", &FIELDS)
6608 }
6609
6610 #[allow(unused_variables)]
6611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6612 where
6613 E: serde::de::Error,
6614 {
6615 Err(serde::de::Error::unknown_field(value, FIELDS))
6616 }
6617 }
6618 deserializer.deserialize_identifier(GeneratedVisitor)
6619 }
6620 }
6621 struct GeneratedVisitor;
6622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6623 type Value = GetServerlessStreamingJobsStatusRequest;
6624
6625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6626 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6627 }
6628
6629 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6630 where
6631 V: serde::de::MapAccess<'de>,
6632 {
6633 while map_.next_key::<GeneratedField>()?.is_some() {
6634 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6635 }
6636 Ok(GetServerlessStreamingJobsStatusRequest {
6637 })
6638 }
6639 }
6640 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6641 }
6642}
6643impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6644 #[allow(deprecated)]
6645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6646 where
6647 S: serde::Serializer,
6648 {
6649 use serde::ser::SerializeStruct;
6650 let mut len = 0;
6651 if !self.streaming_job_statuses.is_empty() {
6652 len += 1;
6653 }
6654 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6655 if !self.streaming_job_statuses.is_empty() {
6656 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6657 }
6658 struct_ser.end()
6659 }
6660}
6661impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6662 #[allow(deprecated)]
6663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6664 where
6665 D: serde::Deserializer<'de>,
6666 {
6667 const FIELDS: &[&str] = &[
6668 "streaming_job_statuses",
6669 "streamingJobStatuses",
6670 ];
6671
6672 #[allow(clippy::enum_variant_names)]
6673 enum GeneratedField {
6674 StreamingJobStatuses,
6675 }
6676 impl<'de> serde::Deserialize<'de> for GeneratedField {
6677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6678 where
6679 D: serde::Deserializer<'de>,
6680 {
6681 struct GeneratedVisitor;
6682
6683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6684 type Value = GeneratedField;
6685
6686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6687 write!(formatter, "expected one of: {:?}", &FIELDS)
6688 }
6689
6690 #[allow(unused_variables)]
6691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6692 where
6693 E: serde::de::Error,
6694 {
6695 match value {
6696 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6697 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6698 }
6699 }
6700 }
6701 deserializer.deserialize_identifier(GeneratedVisitor)
6702 }
6703 }
6704 struct GeneratedVisitor;
6705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6706 type Value = GetServerlessStreamingJobsStatusResponse;
6707
6708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6709 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6710 }
6711
6712 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6713 where
6714 V: serde::de::MapAccess<'de>,
6715 {
6716 let mut streaming_job_statuses__ = None;
6717 while let Some(k) = map_.next_key()? {
6718 match k {
6719 GeneratedField::StreamingJobStatuses => {
6720 if streaming_job_statuses__.is_some() {
6721 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6722 }
6723 streaming_job_statuses__ = Some(map_.next_value()?);
6724 }
6725 }
6726 }
6727 Ok(GetServerlessStreamingJobsStatusResponse {
6728 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6729 })
6730 }
6731 }
6732 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6733 }
6734}
6735impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6736 #[allow(deprecated)]
6737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6738 where
6739 S: serde::Serializer,
6740 {
6741 use serde::ser::SerializeStruct;
6742 let mut len = 0;
6743 if self.table_id != 0 {
6744 len += 1;
6745 }
6746 if !self.node_label.is_empty() {
6747 len += 1;
6748 }
6749 if self.backfill_done {
6750 len += 1;
6751 }
6752 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6753 if self.table_id != 0 {
6754 struct_ser.serialize_field("tableId", &self.table_id)?;
6755 }
6756 if !self.node_label.is_empty() {
6757 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6758 }
6759 if self.backfill_done {
6760 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6761 }
6762 struct_ser.end()
6763 }
6764}
6765impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6766 #[allow(deprecated)]
6767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6768 where
6769 D: serde::Deserializer<'de>,
6770 {
6771 const FIELDS: &[&str] = &[
6772 "table_id",
6773 "tableId",
6774 "node_label",
6775 "nodeLabel",
6776 "backfill_done",
6777 "backfillDone",
6778 ];
6779
6780 #[allow(clippy::enum_variant_names)]
6781 enum GeneratedField {
6782 TableId,
6783 NodeLabel,
6784 BackfillDone,
6785 }
6786 impl<'de> serde::Deserialize<'de> for GeneratedField {
6787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6788 where
6789 D: serde::Deserializer<'de>,
6790 {
6791 struct GeneratedVisitor;
6792
6793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6794 type Value = GeneratedField;
6795
6796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6797 write!(formatter, "expected one of: {:?}", &FIELDS)
6798 }
6799
6800 #[allow(unused_variables)]
6801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6802 where
6803 E: serde::de::Error,
6804 {
6805 match value {
6806 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6807 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6808 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6810 }
6811 }
6812 }
6813 deserializer.deserialize_identifier(GeneratedVisitor)
6814 }
6815 }
6816 struct GeneratedVisitor;
6817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6818 type Value = get_serverless_streaming_jobs_status_response::Status;
6819
6820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6821 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6822 }
6823
6824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6825 where
6826 V: serde::de::MapAccess<'de>,
6827 {
6828 let mut table_id__ = None;
6829 let mut node_label__ = None;
6830 let mut backfill_done__ = None;
6831 while let Some(k) = map_.next_key()? {
6832 match k {
6833 GeneratedField::TableId => {
6834 if table_id__.is_some() {
6835 return Err(serde::de::Error::duplicate_field("tableId"));
6836 }
6837 table_id__ =
6838 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6839 ;
6840 }
6841 GeneratedField::NodeLabel => {
6842 if node_label__.is_some() {
6843 return Err(serde::de::Error::duplicate_field("nodeLabel"));
6844 }
6845 node_label__ = Some(map_.next_value()?);
6846 }
6847 GeneratedField::BackfillDone => {
6848 if backfill_done__.is_some() {
6849 return Err(serde::de::Error::duplicate_field("backfillDone"));
6850 }
6851 backfill_done__ = Some(map_.next_value()?);
6852 }
6853 }
6854 }
6855 Ok(get_serverless_streaming_jobs_status_response::Status {
6856 table_id: table_id__.unwrap_or_default(),
6857 node_label: node_label__.unwrap_or_default(),
6858 backfill_done: backfill_done__.unwrap_or_default(),
6859 })
6860 }
6861 }
6862 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
6863 }
6864}
6865impl serde::Serialize for GetServingVnodeMappingsRequest {
6866 #[allow(deprecated)]
6867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6868 where
6869 S: serde::Serializer,
6870 {
6871 use serde::ser::SerializeStruct;
6872 let len = 0;
6873 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
6874 struct_ser.end()
6875 }
6876}
6877impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
6878 #[allow(deprecated)]
6879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6880 where
6881 D: serde::Deserializer<'de>,
6882 {
6883 const FIELDS: &[&str] = &[
6884 ];
6885
6886 #[allow(clippy::enum_variant_names)]
6887 enum GeneratedField {
6888 }
6889 impl<'de> serde::Deserialize<'de> for GeneratedField {
6890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6891 where
6892 D: serde::Deserializer<'de>,
6893 {
6894 struct GeneratedVisitor;
6895
6896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6897 type Value = GeneratedField;
6898
6899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6900 write!(formatter, "expected one of: {:?}", &FIELDS)
6901 }
6902
6903 #[allow(unused_variables)]
6904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6905 where
6906 E: serde::de::Error,
6907 {
6908 Err(serde::de::Error::unknown_field(value, FIELDS))
6909 }
6910 }
6911 deserializer.deserialize_identifier(GeneratedVisitor)
6912 }
6913 }
6914 struct GeneratedVisitor;
6915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6916 type Value = GetServingVnodeMappingsRequest;
6917
6918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6919 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
6920 }
6921
6922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
6923 where
6924 V: serde::de::MapAccess<'de>,
6925 {
6926 while map_.next_key::<GeneratedField>()?.is_some() {
6927 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6928 }
6929 Ok(GetServingVnodeMappingsRequest {
6930 })
6931 }
6932 }
6933 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
6934 }
6935}
6936impl serde::Serialize for GetServingVnodeMappingsResponse {
6937 #[allow(deprecated)]
6938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6939 where
6940 S: serde::Serializer,
6941 {
6942 use serde::ser::SerializeStruct;
6943 let mut len = 0;
6944 if !self.fragment_to_table.is_empty() {
6945 len += 1;
6946 }
6947 if !self.worker_slot_mappings.is_empty() {
6948 len += 1;
6949 }
6950 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
6951 if !self.fragment_to_table.is_empty() {
6952 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
6953 }
6954 if !self.worker_slot_mappings.is_empty() {
6955 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
6956 }
6957 struct_ser.end()
6958 }
6959}
6960impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
6961 #[allow(deprecated)]
6962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6963 where
6964 D: serde::Deserializer<'de>,
6965 {
6966 const FIELDS: &[&str] = &[
6967 "fragment_to_table",
6968 "fragmentToTable",
6969 "worker_slot_mappings",
6970 "workerSlotMappings",
6971 ];
6972
6973 #[allow(clippy::enum_variant_names)]
6974 enum GeneratedField {
6975 FragmentToTable,
6976 WorkerSlotMappings,
6977 }
6978 impl<'de> serde::Deserialize<'de> for GeneratedField {
6979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6980 where
6981 D: serde::Deserializer<'de>,
6982 {
6983 struct GeneratedVisitor;
6984
6985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6986 type Value = GeneratedField;
6987
6988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6989 write!(formatter, "expected one of: {:?}", &FIELDS)
6990 }
6991
6992 #[allow(unused_variables)]
6993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6994 where
6995 E: serde::de::Error,
6996 {
6997 match value {
6998 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
6999 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7001 }
7002 }
7003 }
7004 deserializer.deserialize_identifier(GeneratedVisitor)
7005 }
7006 }
7007 struct GeneratedVisitor;
7008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7009 type Value = GetServingVnodeMappingsResponse;
7010
7011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7012 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7013 }
7014
7015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7016 where
7017 V: serde::de::MapAccess<'de>,
7018 {
7019 let mut fragment_to_table__ = None;
7020 let mut worker_slot_mappings__ = None;
7021 while let Some(k) = map_.next_key()? {
7022 match k {
7023 GeneratedField::FragmentToTable => {
7024 if fragment_to_table__.is_some() {
7025 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7026 }
7027 fragment_to_table__ = Some(
7028 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7029 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7030 );
7031 }
7032 GeneratedField::WorkerSlotMappings => {
7033 if worker_slot_mappings__.is_some() {
7034 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7035 }
7036 worker_slot_mappings__ = Some(map_.next_value()?);
7037 }
7038 }
7039 }
7040 Ok(GetServingVnodeMappingsResponse {
7041 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7042 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7043 })
7044 }
7045 }
7046 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7047 }
7048}
7049impl serde::Serialize for GetSessionParamsRequest {
7050 #[allow(deprecated)]
7051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7052 where
7053 S: serde::Serializer,
7054 {
7055 use serde::ser::SerializeStruct;
7056 let len = 0;
7057 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7058 struct_ser.end()
7059 }
7060}
7061impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7062 #[allow(deprecated)]
7063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7064 where
7065 D: serde::Deserializer<'de>,
7066 {
7067 const FIELDS: &[&str] = &[
7068 ];
7069
7070 #[allow(clippy::enum_variant_names)]
7071 enum GeneratedField {
7072 }
7073 impl<'de> serde::Deserialize<'de> for GeneratedField {
7074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7075 where
7076 D: serde::Deserializer<'de>,
7077 {
7078 struct GeneratedVisitor;
7079
7080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7081 type Value = GeneratedField;
7082
7083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7084 write!(formatter, "expected one of: {:?}", &FIELDS)
7085 }
7086
7087 #[allow(unused_variables)]
7088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7089 where
7090 E: serde::de::Error,
7091 {
7092 Err(serde::de::Error::unknown_field(value, FIELDS))
7093 }
7094 }
7095 deserializer.deserialize_identifier(GeneratedVisitor)
7096 }
7097 }
7098 struct GeneratedVisitor;
7099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7100 type Value = GetSessionParamsRequest;
7101
7102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7103 formatter.write_str("struct meta.GetSessionParamsRequest")
7104 }
7105
7106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7107 where
7108 V: serde::de::MapAccess<'de>,
7109 {
7110 while map_.next_key::<GeneratedField>()?.is_some() {
7111 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7112 }
7113 Ok(GetSessionParamsRequest {
7114 })
7115 }
7116 }
7117 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7118 }
7119}
7120impl serde::Serialize for GetSessionParamsResponse {
7121 #[allow(deprecated)]
7122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7123 where
7124 S: serde::Serializer,
7125 {
7126 use serde::ser::SerializeStruct;
7127 let mut len = 0;
7128 if !self.params.is_empty() {
7129 len += 1;
7130 }
7131 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7132 if !self.params.is_empty() {
7133 struct_ser.serialize_field("params", &self.params)?;
7134 }
7135 struct_ser.end()
7136 }
7137}
7138impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7139 #[allow(deprecated)]
7140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7141 where
7142 D: serde::Deserializer<'de>,
7143 {
7144 const FIELDS: &[&str] = &[
7145 "params",
7146 ];
7147
7148 #[allow(clippy::enum_variant_names)]
7149 enum GeneratedField {
7150 Params,
7151 }
7152 impl<'de> serde::Deserialize<'de> for GeneratedField {
7153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7154 where
7155 D: serde::Deserializer<'de>,
7156 {
7157 struct GeneratedVisitor;
7158
7159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7160 type Value = GeneratedField;
7161
7162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7163 write!(formatter, "expected one of: {:?}", &FIELDS)
7164 }
7165
7166 #[allow(unused_variables)]
7167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7168 where
7169 E: serde::de::Error,
7170 {
7171 match value {
7172 "params" => Ok(GeneratedField::Params),
7173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7174 }
7175 }
7176 }
7177 deserializer.deserialize_identifier(GeneratedVisitor)
7178 }
7179 }
7180 struct GeneratedVisitor;
7181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7182 type Value = GetSessionParamsResponse;
7183
7184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7185 formatter.write_str("struct meta.GetSessionParamsResponse")
7186 }
7187
7188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7189 where
7190 V: serde::de::MapAccess<'de>,
7191 {
7192 let mut params__ = None;
7193 while let Some(k) = map_.next_key()? {
7194 match k {
7195 GeneratedField::Params => {
7196 if params__.is_some() {
7197 return Err(serde::de::Error::duplicate_field("params"));
7198 }
7199 params__ = Some(map_.next_value()?);
7200 }
7201 }
7202 }
7203 Ok(GetSessionParamsResponse {
7204 params: params__.unwrap_or_default(),
7205 })
7206 }
7207 }
7208 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7209 }
7210}
7211impl serde::Serialize for GetSystemParamsRequest {
7212 #[allow(deprecated)]
7213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7214 where
7215 S: serde::Serializer,
7216 {
7217 use serde::ser::SerializeStruct;
7218 let len = 0;
7219 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7220 struct_ser.end()
7221 }
7222}
7223impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7224 #[allow(deprecated)]
7225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7226 where
7227 D: serde::Deserializer<'de>,
7228 {
7229 const FIELDS: &[&str] = &[
7230 ];
7231
7232 #[allow(clippy::enum_variant_names)]
7233 enum GeneratedField {
7234 }
7235 impl<'de> serde::Deserialize<'de> for GeneratedField {
7236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7237 where
7238 D: serde::Deserializer<'de>,
7239 {
7240 struct GeneratedVisitor;
7241
7242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7243 type Value = GeneratedField;
7244
7245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7246 write!(formatter, "expected one of: {:?}", &FIELDS)
7247 }
7248
7249 #[allow(unused_variables)]
7250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7251 where
7252 E: serde::de::Error,
7253 {
7254 Err(serde::de::Error::unknown_field(value, FIELDS))
7255 }
7256 }
7257 deserializer.deserialize_identifier(GeneratedVisitor)
7258 }
7259 }
7260 struct GeneratedVisitor;
7261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7262 type Value = GetSystemParamsRequest;
7263
7264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7265 formatter.write_str("struct meta.GetSystemParamsRequest")
7266 }
7267
7268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7269 where
7270 V: serde::de::MapAccess<'de>,
7271 {
7272 while map_.next_key::<GeneratedField>()?.is_some() {
7273 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7274 }
7275 Ok(GetSystemParamsRequest {
7276 })
7277 }
7278 }
7279 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7280 }
7281}
7282impl serde::Serialize for GetSystemParamsResponse {
7283 #[allow(deprecated)]
7284 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7285 where
7286 S: serde::Serializer,
7287 {
7288 use serde::ser::SerializeStruct;
7289 let mut len = 0;
7290 if self.params.is_some() {
7291 len += 1;
7292 }
7293 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7294 if let Some(v) = self.params.as_ref() {
7295 struct_ser.serialize_field("params", v)?;
7296 }
7297 struct_ser.end()
7298 }
7299}
7300impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7301 #[allow(deprecated)]
7302 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7303 where
7304 D: serde::Deserializer<'de>,
7305 {
7306 const FIELDS: &[&str] = &[
7307 "params",
7308 ];
7309
7310 #[allow(clippy::enum_variant_names)]
7311 enum GeneratedField {
7312 Params,
7313 }
7314 impl<'de> serde::Deserialize<'de> for GeneratedField {
7315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7316 where
7317 D: serde::Deserializer<'de>,
7318 {
7319 struct GeneratedVisitor;
7320
7321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7322 type Value = GeneratedField;
7323
7324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7325 write!(formatter, "expected one of: {:?}", &FIELDS)
7326 }
7327
7328 #[allow(unused_variables)]
7329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7330 where
7331 E: serde::de::Error,
7332 {
7333 match value {
7334 "params" => Ok(GeneratedField::Params),
7335 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7336 }
7337 }
7338 }
7339 deserializer.deserialize_identifier(GeneratedVisitor)
7340 }
7341 }
7342 struct GeneratedVisitor;
7343 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7344 type Value = GetSystemParamsResponse;
7345
7346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7347 formatter.write_str("struct meta.GetSystemParamsResponse")
7348 }
7349
7350 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7351 where
7352 V: serde::de::MapAccess<'de>,
7353 {
7354 let mut params__ = None;
7355 while let Some(k) = map_.next_key()? {
7356 match k {
7357 GeneratedField::Params => {
7358 if params__.is_some() {
7359 return Err(serde::de::Error::duplicate_field("params"));
7360 }
7361 params__ = map_.next_value()?;
7362 }
7363 }
7364 }
7365 Ok(GetSystemParamsResponse {
7366 params: params__,
7367 })
7368 }
7369 }
7370 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7371 }
7372}
7373impl serde::Serialize for GetTelemetryInfoRequest {
7374 #[allow(deprecated)]
7375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7376 where
7377 S: serde::Serializer,
7378 {
7379 use serde::ser::SerializeStruct;
7380 let len = 0;
7381 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7382 struct_ser.end()
7383 }
7384}
7385impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7386 #[allow(deprecated)]
7387 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7388 where
7389 D: serde::Deserializer<'de>,
7390 {
7391 const FIELDS: &[&str] = &[
7392 ];
7393
7394 #[allow(clippy::enum_variant_names)]
7395 enum GeneratedField {
7396 }
7397 impl<'de> serde::Deserialize<'de> for GeneratedField {
7398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7399 where
7400 D: serde::Deserializer<'de>,
7401 {
7402 struct GeneratedVisitor;
7403
7404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7405 type Value = GeneratedField;
7406
7407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7408 write!(formatter, "expected one of: {:?}", &FIELDS)
7409 }
7410
7411 #[allow(unused_variables)]
7412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7413 where
7414 E: serde::de::Error,
7415 {
7416 Err(serde::de::Error::unknown_field(value, FIELDS))
7417 }
7418 }
7419 deserializer.deserialize_identifier(GeneratedVisitor)
7420 }
7421 }
7422 struct GeneratedVisitor;
7423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7424 type Value = GetTelemetryInfoRequest;
7425
7426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7427 formatter.write_str("struct meta.GetTelemetryInfoRequest")
7428 }
7429
7430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7431 where
7432 V: serde::de::MapAccess<'de>,
7433 {
7434 while map_.next_key::<GeneratedField>()?.is_some() {
7435 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7436 }
7437 Ok(GetTelemetryInfoRequest {
7438 })
7439 }
7440 }
7441 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7442 }
7443}
7444impl serde::Serialize for HeartbeatRequest {
7445 #[allow(deprecated)]
7446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7447 where
7448 S: serde::Serializer,
7449 {
7450 use serde::ser::SerializeStruct;
7451 let mut len = 0;
7452 if self.node_id != 0 {
7453 len += 1;
7454 }
7455 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7456 if self.node_id != 0 {
7457 struct_ser.serialize_field("nodeId", &self.node_id)?;
7458 }
7459 struct_ser.end()
7460 }
7461}
7462impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7463 #[allow(deprecated)]
7464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7465 where
7466 D: serde::Deserializer<'de>,
7467 {
7468 const FIELDS: &[&str] = &[
7469 "node_id",
7470 "nodeId",
7471 ];
7472
7473 #[allow(clippy::enum_variant_names)]
7474 enum GeneratedField {
7475 NodeId,
7476 }
7477 impl<'de> serde::Deserialize<'de> for GeneratedField {
7478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7479 where
7480 D: serde::Deserializer<'de>,
7481 {
7482 struct GeneratedVisitor;
7483
7484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7485 type Value = GeneratedField;
7486
7487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7488 write!(formatter, "expected one of: {:?}", &FIELDS)
7489 }
7490
7491 #[allow(unused_variables)]
7492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7493 where
7494 E: serde::de::Error,
7495 {
7496 match value {
7497 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7498 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7499 }
7500 }
7501 }
7502 deserializer.deserialize_identifier(GeneratedVisitor)
7503 }
7504 }
7505 struct GeneratedVisitor;
7506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7507 type Value = HeartbeatRequest;
7508
7509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7510 formatter.write_str("struct meta.HeartbeatRequest")
7511 }
7512
7513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7514 where
7515 V: serde::de::MapAccess<'de>,
7516 {
7517 let mut node_id__ = None;
7518 while let Some(k) = map_.next_key()? {
7519 match k {
7520 GeneratedField::NodeId => {
7521 if node_id__.is_some() {
7522 return Err(serde::de::Error::duplicate_field("nodeId"));
7523 }
7524 node_id__ =
7525 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7526 ;
7527 }
7528 }
7529 }
7530 Ok(HeartbeatRequest {
7531 node_id: node_id__.unwrap_or_default(),
7532 })
7533 }
7534 }
7535 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7536 }
7537}
7538impl serde::Serialize for HeartbeatResponse {
7539 #[allow(deprecated)]
7540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7541 where
7542 S: serde::Serializer,
7543 {
7544 use serde::ser::SerializeStruct;
7545 let mut len = 0;
7546 if self.status.is_some() {
7547 len += 1;
7548 }
7549 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7550 if let Some(v) = self.status.as_ref() {
7551 struct_ser.serialize_field("status", v)?;
7552 }
7553 struct_ser.end()
7554 }
7555}
7556impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7557 #[allow(deprecated)]
7558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7559 where
7560 D: serde::Deserializer<'de>,
7561 {
7562 const FIELDS: &[&str] = &[
7563 "status",
7564 ];
7565
7566 #[allow(clippy::enum_variant_names)]
7567 enum GeneratedField {
7568 Status,
7569 }
7570 impl<'de> serde::Deserialize<'de> for GeneratedField {
7571 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7572 where
7573 D: serde::Deserializer<'de>,
7574 {
7575 struct GeneratedVisitor;
7576
7577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7578 type Value = GeneratedField;
7579
7580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7581 write!(formatter, "expected one of: {:?}", &FIELDS)
7582 }
7583
7584 #[allow(unused_variables)]
7585 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7586 where
7587 E: serde::de::Error,
7588 {
7589 match value {
7590 "status" => Ok(GeneratedField::Status),
7591 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7592 }
7593 }
7594 }
7595 deserializer.deserialize_identifier(GeneratedVisitor)
7596 }
7597 }
7598 struct GeneratedVisitor;
7599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7600 type Value = HeartbeatResponse;
7601
7602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7603 formatter.write_str("struct meta.HeartbeatResponse")
7604 }
7605
7606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7607 where
7608 V: serde::de::MapAccess<'de>,
7609 {
7610 let mut status__ = None;
7611 while let Some(k) = map_.next_key()? {
7612 match k {
7613 GeneratedField::Status => {
7614 if status__.is_some() {
7615 return Err(serde::de::Error::duplicate_field("status"));
7616 }
7617 status__ = map_.next_value()?;
7618 }
7619 }
7620 }
7621 Ok(HeartbeatResponse {
7622 status: status__,
7623 })
7624 }
7625 }
7626 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7627 }
7628}
7629impl serde::Serialize for ListActorSplitsRequest {
7630 #[allow(deprecated)]
7631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7632 where
7633 S: serde::Serializer,
7634 {
7635 use serde::ser::SerializeStruct;
7636 let len = 0;
7637 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7638 struct_ser.end()
7639 }
7640}
7641impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7642 #[allow(deprecated)]
7643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7644 where
7645 D: serde::Deserializer<'de>,
7646 {
7647 const FIELDS: &[&str] = &[
7648 ];
7649
7650 #[allow(clippy::enum_variant_names)]
7651 enum GeneratedField {
7652 }
7653 impl<'de> serde::Deserialize<'de> for GeneratedField {
7654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7655 where
7656 D: serde::Deserializer<'de>,
7657 {
7658 struct GeneratedVisitor;
7659
7660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7661 type Value = GeneratedField;
7662
7663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7664 write!(formatter, "expected one of: {:?}", &FIELDS)
7665 }
7666
7667 #[allow(unused_variables)]
7668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7669 where
7670 E: serde::de::Error,
7671 {
7672 Err(serde::de::Error::unknown_field(value, FIELDS))
7673 }
7674 }
7675 deserializer.deserialize_identifier(GeneratedVisitor)
7676 }
7677 }
7678 struct GeneratedVisitor;
7679 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7680 type Value = ListActorSplitsRequest;
7681
7682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7683 formatter.write_str("struct meta.ListActorSplitsRequest")
7684 }
7685
7686 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7687 where
7688 V: serde::de::MapAccess<'de>,
7689 {
7690 while map_.next_key::<GeneratedField>()?.is_some() {
7691 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7692 }
7693 Ok(ListActorSplitsRequest {
7694 })
7695 }
7696 }
7697 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7698 }
7699}
7700impl serde::Serialize for ListActorSplitsResponse {
7701 #[allow(deprecated)]
7702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7703 where
7704 S: serde::Serializer,
7705 {
7706 use serde::ser::SerializeStruct;
7707 let mut len = 0;
7708 if !self.actor_splits.is_empty() {
7709 len += 1;
7710 }
7711 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7712 if !self.actor_splits.is_empty() {
7713 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7714 }
7715 struct_ser.end()
7716 }
7717}
7718impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7719 #[allow(deprecated)]
7720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7721 where
7722 D: serde::Deserializer<'de>,
7723 {
7724 const FIELDS: &[&str] = &[
7725 "actor_splits",
7726 "actorSplits",
7727 ];
7728
7729 #[allow(clippy::enum_variant_names)]
7730 enum GeneratedField {
7731 ActorSplits,
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 match value {
7753 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7755 }
7756 }
7757 }
7758 deserializer.deserialize_identifier(GeneratedVisitor)
7759 }
7760 }
7761 struct GeneratedVisitor;
7762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7763 type Value = ListActorSplitsResponse;
7764
7765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7766 formatter.write_str("struct meta.ListActorSplitsResponse")
7767 }
7768
7769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7770 where
7771 V: serde::de::MapAccess<'de>,
7772 {
7773 let mut actor_splits__ = None;
7774 while let Some(k) = map_.next_key()? {
7775 match k {
7776 GeneratedField::ActorSplits => {
7777 if actor_splits__.is_some() {
7778 return Err(serde::de::Error::duplicate_field("actorSplits"));
7779 }
7780 actor_splits__ = Some(map_.next_value()?);
7781 }
7782 }
7783 }
7784 Ok(ListActorSplitsResponse {
7785 actor_splits: actor_splits__.unwrap_or_default(),
7786 })
7787 }
7788 }
7789 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7790 }
7791}
7792impl serde::Serialize for list_actor_splits_response::ActorSplit {
7793 #[allow(deprecated)]
7794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7795 where
7796 S: serde::Serializer,
7797 {
7798 use serde::ser::SerializeStruct;
7799 let mut len = 0;
7800 if self.actor_id != 0 {
7801 len += 1;
7802 }
7803 if self.fragment_id != 0 {
7804 len += 1;
7805 }
7806 if self.source_id != 0 {
7807 len += 1;
7808 }
7809 if !self.split_id.is_empty() {
7810 len += 1;
7811 }
7812 if self.fragment_type != 0 {
7813 len += 1;
7814 }
7815 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7816 if self.actor_id != 0 {
7817 struct_ser.serialize_field("actorId", &self.actor_id)?;
7818 }
7819 if self.fragment_id != 0 {
7820 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7821 }
7822 if self.source_id != 0 {
7823 struct_ser.serialize_field("sourceId", &self.source_id)?;
7824 }
7825 if !self.split_id.is_empty() {
7826 struct_ser.serialize_field("splitId", &self.split_id)?;
7827 }
7828 if self.fragment_type != 0 {
7829 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7830 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7831 struct_ser.serialize_field("fragmentType", &v)?;
7832 }
7833 struct_ser.end()
7834 }
7835}
7836impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7837 #[allow(deprecated)]
7838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7839 where
7840 D: serde::Deserializer<'de>,
7841 {
7842 const FIELDS: &[&str] = &[
7843 "actor_id",
7844 "actorId",
7845 "fragment_id",
7846 "fragmentId",
7847 "source_id",
7848 "sourceId",
7849 "split_id",
7850 "splitId",
7851 "fragment_type",
7852 "fragmentType",
7853 ];
7854
7855 #[allow(clippy::enum_variant_names)]
7856 enum GeneratedField {
7857 ActorId,
7858 FragmentId,
7859 SourceId,
7860 SplitId,
7861 FragmentType,
7862 }
7863 impl<'de> serde::Deserialize<'de> for GeneratedField {
7864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7865 where
7866 D: serde::Deserializer<'de>,
7867 {
7868 struct GeneratedVisitor;
7869
7870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7871 type Value = GeneratedField;
7872
7873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7874 write!(formatter, "expected one of: {:?}", &FIELDS)
7875 }
7876
7877 #[allow(unused_variables)]
7878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7879 where
7880 E: serde::de::Error,
7881 {
7882 match value {
7883 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7884 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7885 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7886 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
7887 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
7888 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7889 }
7890 }
7891 }
7892 deserializer.deserialize_identifier(GeneratedVisitor)
7893 }
7894 }
7895 struct GeneratedVisitor;
7896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7897 type Value = list_actor_splits_response::ActorSplit;
7898
7899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7900 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
7901 }
7902
7903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
7904 where
7905 V: serde::de::MapAccess<'de>,
7906 {
7907 let mut actor_id__ = None;
7908 let mut fragment_id__ = None;
7909 let mut source_id__ = None;
7910 let mut split_id__ = None;
7911 let mut fragment_type__ = None;
7912 while let Some(k) = map_.next_key()? {
7913 match k {
7914 GeneratedField::ActorId => {
7915 if actor_id__.is_some() {
7916 return Err(serde::de::Error::duplicate_field("actorId"));
7917 }
7918 actor_id__ =
7919 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7920 ;
7921 }
7922 GeneratedField::FragmentId => {
7923 if fragment_id__.is_some() {
7924 return Err(serde::de::Error::duplicate_field("fragmentId"));
7925 }
7926 fragment_id__ =
7927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7928 ;
7929 }
7930 GeneratedField::SourceId => {
7931 if source_id__.is_some() {
7932 return Err(serde::de::Error::duplicate_field("sourceId"));
7933 }
7934 source_id__ =
7935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7936 ;
7937 }
7938 GeneratedField::SplitId => {
7939 if split_id__.is_some() {
7940 return Err(serde::de::Error::duplicate_field("splitId"));
7941 }
7942 split_id__ = Some(map_.next_value()?);
7943 }
7944 GeneratedField::FragmentType => {
7945 if fragment_type__.is_some() {
7946 return Err(serde::de::Error::duplicate_field("fragmentType"));
7947 }
7948 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
7949 }
7950 }
7951 }
7952 Ok(list_actor_splits_response::ActorSplit {
7953 actor_id: actor_id__.unwrap_or_default(),
7954 fragment_id: fragment_id__.unwrap_or_default(),
7955 source_id: source_id__.unwrap_or_default(),
7956 split_id: split_id__.unwrap_or_default(),
7957 fragment_type: fragment_type__.unwrap_or_default(),
7958 })
7959 }
7960 }
7961 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
7962 }
7963}
7964impl serde::Serialize for list_actor_splits_response::FragmentType {
7965 #[allow(deprecated)]
7966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7967 where
7968 S: serde::Serializer,
7969 {
7970 let variant = match self {
7971 Self::Unspecified => "UNSPECIFIED",
7972 Self::NonSharedSource => "NON_SHARED_SOURCE",
7973 Self::SharedSource => "SHARED_SOURCE",
7974 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
7975 };
7976 serializer.serialize_str(variant)
7977 }
7978}
7979impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
7980 #[allow(deprecated)]
7981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7982 where
7983 D: serde::Deserializer<'de>,
7984 {
7985 const FIELDS: &[&str] = &[
7986 "UNSPECIFIED",
7987 "NON_SHARED_SOURCE",
7988 "SHARED_SOURCE",
7989 "SHARED_SOURCE_BACKFILL",
7990 ];
7991
7992 struct GeneratedVisitor;
7993
7994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7995 type Value = list_actor_splits_response::FragmentType;
7996
7997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7998 write!(formatter, "expected one of: {:?}", &FIELDS)
7999 }
8000
8001 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8002 where
8003 E: serde::de::Error,
8004 {
8005 i32::try_from(v)
8006 .ok()
8007 .and_then(|x| x.try_into().ok())
8008 .ok_or_else(|| {
8009 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8010 })
8011 }
8012
8013 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8014 where
8015 E: serde::de::Error,
8016 {
8017 i32::try_from(v)
8018 .ok()
8019 .and_then(|x| x.try_into().ok())
8020 .ok_or_else(|| {
8021 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8022 })
8023 }
8024
8025 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8026 where
8027 E: serde::de::Error,
8028 {
8029 match value {
8030 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8031 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8032 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8033 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8034 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8035 }
8036 }
8037 }
8038 deserializer.deserialize_any(GeneratedVisitor)
8039 }
8040}
8041impl serde::Serialize for ListActorStatesRequest {
8042 #[allow(deprecated)]
8043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8044 where
8045 S: serde::Serializer,
8046 {
8047 use serde::ser::SerializeStruct;
8048 let len = 0;
8049 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8050 struct_ser.end()
8051 }
8052}
8053impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8054 #[allow(deprecated)]
8055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8056 where
8057 D: serde::Deserializer<'de>,
8058 {
8059 const FIELDS: &[&str] = &[
8060 ];
8061
8062 #[allow(clippy::enum_variant_names)]
8063 enum GeneratedField {
8064 }
8065 impl<'de> serde::Deserialize<'de> for GeneratedField {
8066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8067 where
8068 D: serde::Deserializer<'de>,
8069 {
8070 struct GeneratedVisitor;
8071
8072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8073 type Value = GeneratedField;
8074
8075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8076 write!(formatter, "expected one of: {:?}", &FIELDS)
8077 }
8078
8079 #[allow(unused_variables)]
8080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8081 where
8082 E: serde::de::Error,
8083 {
8084 Err(serde::de::Error::unknown_field(value, FIELDS))
8085 }
8086 }
8087 deserializer.deserialize_identifier(GeneratedVisitor)
8088 }
8089 }
8090 struct GeneratedVisitor;
8091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8092 type Value = ListActorStatesRequest;
8093
8094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8095 formatter.write_str("struct meta.ListActorStatesRequest")
8096 }
8097
8098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8099 where
8100 V: serde::de::MapAccess<'de>,
8101 {
8102 while map_.next_key::<GeneratedField>()?.is_some() {
8103 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8104 }
8105 Ok(ListActorStatesRequest {
8106 })
8107 }
8108 }
8109 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8110 }
8111}
8112impl serde::Serialize for ListActorStatesResponse {
8113 #[allow(deprecated)]
8114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8115 where
8116 S: serde::Serializer,
8117 {
8118 use serde::ser::SerializeStruct;
8119 let mut len = 0;
8120 if !self.states.is_empty() {
8121 len += 1;
8122 }
8123 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8124 if !self.states.is_empty() {
8125 struct_ser.serialize_field("states", &self.states)?;
8126 }
8127 struct_ser.end()
8128 }
8129}
8130impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8131 #[allow(deprecated)]
8132 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8133 where
8134 D: serde::Deserializer<'de>,
8135 {
8136 const FIELDS: &[&str] = &[
8137 "states",
8138 ];
8139
8140 #[allow(clippy::enum_variant_names)]
8141 enum GeneratedField {
8142 States,
8143 }
8144 impl<'de> serde::Deserialize<'de> for GeneratedField {
8145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8146 where
8147 D: serde::Deserializer<'de>,
8148 {
8149 struct GeneratedVisitor;
8150
8151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8152 type Value = GeneratedField;
8153
8154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8155 write!(formatter, "expected one of: {:?}", &FIELDS)
8156 }
8157
8158 #[allow(unused_variables)]
8159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8160 where
8161 E: serde::de::Error,
8162 {
8163 match value {
8164 "states" => Ok(GeneratedField::States),
8165 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8166 }
8167 }
8168 }
8169 deserializer.deserialize_identifier(GeneratedVisitor)
8170 }
8171 }
8172 struct GeneratedVisitor;
8173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8174 type Value = ListActorStatesResponse;
8175
8176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8177 formatter.write_str("struct meta.ListActorStatesResponse")
8178 }
8179
8180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8181 where
8182 V: serde::de::MapAccess<'de>,
8183 {
8184 let mut states__ = None;
8185 while let Some(k) = map_.next_key()? {
8186 match k {
8187 GeneratedField::States => {
8188 if states__.is_some() {
8189 return Err(serde::de::Error::duplicate_field("states"));
8190 }
8191 states__ = Some(map_.next_value()?);
8192 }
8193 }
8194 }
8195 Ok(ListActorStatesResponse {
8196 states: states__.unwrap_or_default(),
8197 })
8198 }
8199 }
8200 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8201 }
8202}
8203impl serde::Serialize for list_actor_states_response::ActorState {
8204 #[allow(deprecated)]
8205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8206 where
8207 S: serde::Serializer,
8208 {
8209 use serde::ser::SerializeStruct;
8210 let mut len = 0;
8211 if self.actor_id != 0 {
8212 len += 1;
8213 }
8214 if self.fragment_id != 0 {
8215 len += 1;
8216 }
8217 if self.state != 0 {
8218 len += 1;
8219 }
8220 if self.worker_id != 0 {
8221 len += 1;
8222 }
8223 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8224 if self.actor_id != 0 {
8225 struct_ser.serialize_field("actorId", &self.actor_id)?;
8226 }
8227 if self.fragment_id != 0 {
8228 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8229 }
8230 if self.state != 0 {
8231 let v = table_fragments::actor_status::ActorState::try_from(self.state)
8232 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
8233 struct_ser.serialize_field("state", &v)?;
8234 }
8235 if self.worker_id != 0 {
8236 struct_ser.serialize_field("workerId", &self.worker_id)?;
8237 }
8238 struct_ser.end()
8239 }
8240}
8241impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8242 #[allow(deprecated)]
8243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8244 where
8245 D: serde::Deserializer<'de>,
8246 {
8247 const FIELDS: &[&str] = &[
8248 "actor_id",
8249 "actorId",
8250 "fragment_id",
8251 "fragmentId",
8252 "state",
8253 "worker_id",
8254 "workerId",
8255 ];
8256
8257 #[allow(clippy::enum_variant_names)]
8258 enum GeneratedField {
8259 ActorId,
8260 FragmentId,
8261 State,
8262 WorkerId,
8263 }
8264 impl<'de> serde::Deserialize<'de> for GeneratedField {
8265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8266 where
8267 D: serde::Deserializer<'de>,
8268 {
8269 struct GeneratedVisitor;
8270
8271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8272 type Value = GeneratedField;
8273
8274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8275 write!(formatter, "expected one of: {:?}", &FIELDS)
8276 }
8277
8278 #[allow(unused_variables)]
8279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8280 where
8281 E: serde::de::Error,
8282 {
8283 match value {
8284 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8285 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8286 "state" => Ok(GeneratedField::State),
8287 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8289 }
8290 }
8291 }
8292 deserializer.deserialize_identifier(GeneratedVisitor)
8293 }
8294 }
8295 struct GeneratedVisitor;
8296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8297 type Value = list_actor_states_response::ActorState;
8298
8299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8300 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8301 }
8302
8303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8304 where
8305 V: serde::de::MapAccess<'de>,
8306 {
8307 let mut actor_id__ = None;
8308 let mut fragment_id__ = None;
8309 let mut state__ = None;
8310 let mut worker_id__ = None;
8311 while let Some(k) = map_.next_key()? {
8312 match k {
8313 GeneratedField::ActorId => {
8314 if actor_id__.is_some() {
8315 return Err(serde::de::Error::duplicate_field("actorId"));
8316 }
8317 actor_id__ =
8318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8319 ;
8320 }
8321 GeneratedField::FragmentId => {
8322 if fragment_id__.is_some() {
8323 return Err(serde::de::Error::duplicate_field("fragmentId"));
8324 }
8325 fragment_id__ =
8326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8327 ;
8328 }
8329 GeneratedField::State => {
8330 if state__.is_some() {
8331 return Err(serde::de::Error::duplicate_field("state"));
8332 }
8333 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
8334 }
8335 GeneratedField::WorkerId => {
8336 if worker_id__.is_some() {
8337 return Err(serde::de::Error::duplicate_field("workerId"));
8338 }
8339 worker_id__ =
8340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8341 ;
8342 }
8343 }
8344 }
8345 Ok(list_actor_states_response::ActorState {
8346 actor_id: actor_id__.unwrap_or_default(),
8347 fragment_id: fragment_id__.unwrap_or_default(),
8348 state: state__.unwrap_or_default(),
8349 worker_id: worker_id__.unwrap_or_default(),
8350 })
8351 }
8352 }
8353 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8354 }
8355}
8356impl serde::Serialize for ListAllNodesRequest {
8357 #[allow(deprecated)]
8358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8359 where
8360 S: serde::Serializer,
8361 {
8362 use serde::ser::SerializeStruct;
8363 let mut len = 0;
8364 if self.worker_type.is_some() {
8365 len += 1;
8366 }
8367 if self.include_starting_nodes {
8368 len += 1;
8369 }
8370 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8371 if let Some(v) = self.worker_type.as_ref() {
8372 let v = super::common::WorkerType::try_from(*v)
8373 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8374 struct_ser.serialize_field("workerType", &v)?;
8375 }
8376 if self.include_starting_nodes {
8377 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8378 }
8379 struct_ser.end()
8380 }
8381}
8382impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8383 #[allow(deprecated)]
8384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8385 where
8386 D: serde::Deserializer<'de>,
8387 {
8388 const FIELDS: &[&str] = &[
8389 "worker_type",
8390 "workerType",
8391 "include_starting_nodes",
8392 "includeStartingNodes",
8393 ];
8394
8395 #[allow(clippy::enum_variant_names)]
8396 enum GeneratedField {
8397 WorkerType,
8398 IncludeStartingNodes,
8399 }
8400 impl<'de> serde::Deserialize<'de> for GeneratedField {
8401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8402 where
8403 D: serde::Deserializer<'de>,
8404 {
8405 struct GeneratedVisitor;
8406
8407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8408 type Value = GeneratedField;
8409
8410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8411 write!(formatter, "expected one of: {:?}", &FIELDS)
8412 }
8413
8414 #[allow(unused_variables)]
8415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8416 where
8417 E: serde::de::Error,
8418 {
8419 match value {
8420 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8421 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8422 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8423 }
8424 }
8425 }
8426 deserializer.deserialize_identifier(GeneratedVisitor)
8427 }
8428 }
8429 struct GeneratedVisitor;
8430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8431 type Value = ListAllNodesRequest;
8432
8433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8434 formatter.write_str("struct meta.ListAllNodesRequest")
8435 }
8436
8437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8438 where
8439 V: serde::de::MapAccess<'de>,
8440 {
8441 let mut worker_type__ = None;
8442 let mut include_starting_nodes__ = None;
8443 while let Some(k) = map_.next_key()? {
8444 match k {
8445 GeneratedField::WorkerType => {
8446 if worker_type__.is_some() {
8447 return Err(serde::de::Error::duplicate_field("workerType"));
8448 }
8449 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8450 }
8451 GeneratedField::IncludeStartingNodes => {
8452 if include_starting_nodes__.is_some() {
8453 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8454 }
8455 include_starting_nodes__ = Some(map_.next_value()?);
8456 }
8457 }
8458 }
8459 Ok(ListAllNodesRequest {
8460 worker_type: worker_type__,
8461 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8462 })
8463 }
8464 }
8465 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8466 }
8467}
8468impl serde::Serialize for ListAllNodesResponse {
8469 #[allow(deprecated)]
8470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8471 where
8472 S: serde::Serializer,
8473 {
8474 use serde::ser::SerializeStruct;
8475 let mut len = 0;
8476 if self.status.is_some() {
8477 len += 1;
8478 }
8479 if !self.nodes.is_empty() {
8480 len += 1;
8481 }
8482 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8483 if let Some(v) = self.status.as_ref() {
8484 struct_ser.serialize_field("status", v)?;
8485 }
8486 if !self.nodes.is_empty() {
8487 struct_ser.serialize_field("nodes", &self.nodes)?;
8488 }
8489 struct_ser.end()
8490 }
8491}
8492impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8493 #[allow(deprecated)]
8494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8495 where
8496 D: serde::Deserializer<'de>,
8497 {
8498 const FIELDS: &[&str] = &[
8499 "status",
8500 "nodes",
8501 ];
8502
8503 #[allow(clippy::enum_variant_names)]
8504 enum GeneratedField {
8505 Status,
8506 Nodes,
8507 }
8508 impl<'de> serde::Deserialize<'de> for GeneratedField {
8509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8510 where
8511 D: serde::Deserializer<'de>,
8512 {
8513 struct GeneratedVisitor;
8514
8515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8516 type Value = GeneratedField;
8517
8518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8519 write!(formatter, "expected one of: {:?}", &FIELDS)
8520 }
8521
8522 #[allow(unused_variables)]
8523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8524 where
8525 E: serde::de::Error,
8526 {
8527 match value {
8528 "status" => Ok(GeneratedField::Status),
8529 "nodes" => Ok(GeneratedField::Nodes),
8530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8531 }
8532 }
8533 }
8534 deserializer.deserialize_identifier(GeneratedVisitor)
8535 }
8536 }
8537 struct GeneratedVisitor;
8538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8539 type Value = ListAllNodesResponse;
8540
8541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8542 formatter.write_str("struct meta.ListAllNodesResponse")
8543 }
8544
8545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8546 where
8547 V: serde::de::MapAccess<'de>,
8548 {
8549 let mut status__ = None;
8550 let mut nodes__ = None;
8551 while let Some(k) = map_.next_key()? {
8552 match k {
8553 GeneratedField::Status => {
8554 if status__.is_some() {
8555 return Err(serde::de::Error::duplicate_field("status"));
8556 }
8557 status__ = map_.next_value()?;
8558 }
8559 GeneratedField::Nodes => {
8560 if nodes__.is_some() {
8561 return Err(serde::de::Error::duplicate_field("nodes"));
8562 }
8563 nodes__ = Some(map_.next_value()?);
8564 }
8565 }
8566 }
8567 Ok(ListAllNodesResponse {
8568 status: status__,
8569 nodes: nodes__.unwrap_or_default(),
8570 })
8571 }
8572 }
8573 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8574 }
8575}
8576impl serde::Serialize for ListCreatingStreamScanFragmentDistributionRequest {
8577 #[allow(deprecated)]
8578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8579 where
8580 S: serde::Serializer,
8581 {
8582 use serde::ser::SerializeStruct;
8583 let len = 0;
8584 let struct_ser = serializer.serialize_struct("meta.ListCreatingStreamScanFragmentDistributionRequest", len)?;
8585 struct_ser.end()
8586 }
8587}
8588impl<'de> serde::Deserialize<'de> for ListCreatingStreamScanFragmentDistributionRequest {
8589 #[allow(deprecated)]
8590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8591 where
8592 D: serde::Deserializer<'de>,
8593 {
8594 const FIELDS: &[&str] = &[
8595 ];
8596
8597 #[allow(clippy::enum_variant_names)]
8598 enum GeneratedField {
8599 }
8600 impl<'de> serde::Deserialize<'de> for GeneratedField {
8601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8602 where
8603 D: serde::Deserializer<'de>,
8604 {
8605 struct GeneratedVisitor;
8606
8607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8608 type Value = GeneratedField;
8609
8610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8611 write!(formatter, "expected one of: {:?}", &FIELDS)
8612 }
8613
8614 #[allow(unused_variables)]
8615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8616 where
8617 E: serde::de::Error,
8618 {
8619 Err(serde::de::Error::unknown_field(value, FIELDS))
8620 }
8621 }
8622 deserializer.deserialize_identifier(GeneratedVisitor)
8623 }
8624 }
8625 struct GeneratedVisitor;
8626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8627 type Value = ListCreatingStreamScanFragmentDistributionRequest;
8628
8629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8630 formatter.write_str("struct meta.ListCreatingStreamScanFragmentDistributionRequest")
8631 }
8632
8633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingStreamScanFragmentDistributionRequest, V::Error>
8634 where
8635 V: serde::de::MapAccess<'de>,
8636 {
8637 while map_.next_key::<GeneratedField>()?.is_some() {
8638 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8639 }
8640 Ok(ListCreatingStreamScanFragmentDistributionRequest {
8641 })
8642 }
8643 }
8644 deserializer.deserialize_struct("meta.ListCreatingStreamScanFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8645 }
8646}
8647impl serde::Serialize for ListCreatingStreamScanFragmentDistributionResponse {
8648 #[allow(deprecated)]
8649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8650 where
8651 S: serde::Serializer,
8652 {
8653 use serde::ser::SerializeStruct;
8654 let mut len = 0;
8655 if !self.distributions.is_empty() {
8656 len += 1;
8657 }
8658 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingStreamScanFragmentDistributionResponse", len)?;
8659 if !self.distributions.is_empty() {
8660 struct_ser.serialize_field("distributions", &self.distributions)?;
8661 }
8662 struct_ser.end()
8663 }
8664}
8665impl<'de> serde::Deserialize<'de> for ListCreatingStreamScanFragmentDistributionResponse {
8666 #[allow(deprecated)]
8667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8668 where
8669 D: serde::Deserializer<'de>,
8670 {
8671 const FIELDS: &[&str] = &[
8672 "distributions",
8673 ];
8674
8675 #[allow(clippy::enum_variant_names)]
8676 enum GeneratedField {
8677 Distributions,
8678 }
8679 impl<'de> serde::Deserialize<'de> for GeneratedField {
8680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8681 where
8682 D: serde::Deserializer<'de>,
8683 {
8684 struct GeneratedVisitor;
8685
8686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8687 type Value = GeneratedField;
8688
8689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8690 write!(formatter, "expected one of: {:?}", &FIELDS)
8691 }
8692
8693 #[allow(unused_variables)]
8694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8695 where
8696 E: serde::de::Error,
8697 {
8698 match value {
8699 "distributions" => Ok(GeneratedField::Distributions),
8700 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8701 }
8702 }
8703 }
8704 deserializer.deserialize_identifier(GeneratedVisitor)
8705 }
8706 }
8707 struct GeneratedVisitor;
8708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8709 type Value = ListCreatingStreamScanFragmentDistributionResponse;
8710
8711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8712 formatter.write_str("struct meta.ListCreatingStreamScanFragmentDistributionResponse")
8713 }
8714
8715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingStreamScanFragmentDistributionResponse, V::Error>
8716 where
8717 V: serde::de::MapAccess<'de>,
8718 {
8719 let mut distributions__ = None;
8720 while let Some(k) = map_.next_key()? {
8721 match k {
8722 GeneratedField::Distributions => {
8723 if distributions__.is_some() {
8724 return Err(serde::de::Error::duplicate_field("distributions"));
8725 }
8726 distributions__ = Some(map_.next_value()?);
8727 }
8728 }
8729 }
8730 Ok(ListCreatingStreamScanFragmentDistributionResponse {
8731 distributions: distributions__.unwrap_or_default(),
8732 })
8733 }
8734 }
8735 deserializer.deserialize_struct("meta.ListCreatingStreamScanFragmentDistributionResponse", FIELDS, GeneratedVisitor)
8736 }
8737}
8738impl serde::Serialize for ListEventLogRequest {
8739 #[allow(deprecated)]
8740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8741 where
8742 S: serde::Serializer,
8743 {
8744 use serde::ser::SerializeStruct;
8745 let len = 0;
8746 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
8747 struct_ser.end()
8748 }
8749}
8750impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
8751 #[allow(deprecated)]
8752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8753 where
8754 D: serde::Deserializer<'de>,
8755 {
8756 const FIELDS: &[&str] = &[
8757 ];
8758
8759 #[allow(clippy::enum_variant_names)]
8760 enum GeneratedField {
8761 }
8762 impl<'de> serde::Deserialize<'de> for GeneratedField {
8763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8764 where
8765 D: serde::Deserializer<'de>,
8766 {
8767 struct GeneratedVisitor;
8768
8769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8770 type Value = GeneratedField;
8771
8772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8773 write!(formatter, "expected one of: {:?}", &FIELDS)
8774 }
8775
8776 #[allow(unused_variables)]
8777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8778 where
8779 E: serde::de::Error,
8780 {
8781 Err(serde::de::Error::unknown_field(value, FIELDS))
8782 }
8783 }
8784 deserializer.deserialize_identifier(GeneratedVisitor)
8785 }
8786 }
8787 struct GeneratedVisitor;
8788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8789 type Value = ListEventLogRequest;
8790
8791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8792 formatter.write_str("struct meta.ListEventLogRequest")
8793 }
8794
8795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
8796 where
8797 V: serde::de::MapAccess<'de>,
8798 {
8799 while map_.next_key::<GeneratedField>()?.is_some() {
8800 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8801 }
8802 Ok(ListEventLogRequest {
8803 })
8804 }
8805 }
8806 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
8807 }
8808}
8809impl serde::Serialize for ListEventLogResponse {
8810 #[allow(deprecated)]
8811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8812 where
8813 S: serde::Serializer,
8814 {
8815 use serde::ser::SerializeStruct;
8816 let mut len = 0;
8817 if !self.event_logs.is_empty() {
8818 len += 1;
8819 }
8820 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
8821 if !self.event_logs.is_empty() {
8822 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
8823 }
8824 struct_ser.end()
8825 }
8826}
8827impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
8828 #[allow(deprecated)]
8829 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8830 where
8831 D: serde::Deserializer<'de>,
8832 {
8833 const FIELDS: &[&str] = &[
8834 "event_logs",
8835 "eventLogs",
8836 ];
8837
8838 #[allow(clippy::enum_variant_names)]
8839 enum GeneratedField {
8840 EventLogs,
8841 }
8842 impl<'de> serde::Deserialize<'de> for GeneratedField {
8843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8844 where
8845 D: serde::Deserializer<'de>,
8846 {
8847 struct GeneratedVisitor;
8848
8849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8850 type Value = GeneratedField;
8851
8852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8853 write!(formatter, "expected one of: {:?}", &FIELDS)
8854 }
8855
8856 #[allow(unused_variables)]
8857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8858 where
8859 E: serde::de::Error,
8860 {
8861 match value {
8862 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
8863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8864 }
8865 }
8866 }
8867 deserializer.deserialize_identifier(GeneratedVisitor)
8868 }
8869 }
8870 struct GeneratedVisitor;
8871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8872 type Value = ListEventLogResponse;
8873
8874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8875 formatter.write_str("struct meta.ListEventLogResponse")
8876 }
8877
8878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
8879 where
8880 V: serde::de::MapAccess<'de>,
8881 {
8882 let mut event_logs__ = None;
8883 while let Some(k) = map_.next_key()? {
8884 match k {
8885 GeneratedField::EventLogs => {
8886 if event_logs__.is_some() {
8887 return Err(serde::de::Error::duplicate_field("eventLogs"));
8888 }
8889 event_logs__ = Some(map_.next_value()?);
8890 }
8891 }
8892 }
8893 Ok(ListEventLogResponse {
8894 event_logs: event_logs__.unwrap_or_default(),
8895 })
8896 }
8897 }
8898 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
8899 }
8900}
8901impl serde::Serialize for ListFragmentDistributionRequest {
8902 #[allow(deprecated)]
8903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8904 where
8905 S: serde::Serializer,
8906 {
8907 use serde::ser::SerializeStruct;
8908 let len = 0;
8909 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
8910 struct_ser.end()
8911 }
8912}
8913impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
8914 #[allow(deprecated)]
8915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8916 where
8917 D: serde::Deserializer<'de>,
8918 {
8919 const FIELDS: &[&str] = &[
8920 ];
8921
8922 #[allow(clippy::enum_variant_names)]
8923 enum GeneratedField {
8924 }
8925 impl<'de> serde::Deserialize<'de> for GeneratedField {
8926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8927 where
8928 D: serde::Deserializer<'de>,
8929 {
8930 struct GeneratedVisitor;
8931
8932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8933 type Value = GeneratedField;
8934
8935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8936 write!(formatter, "expected one of: {:?}", &FIELDS)
8937 }
8938
8939 #[allow(unused_variables)]
8940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8941 where
8942 E: serde::de::Error,
8943 {
8944 Err(serde::de::Error::unknown_field(value, FIELDS))
8945 }
8946 }
8947 deserializer.deserialize_identifier(GeneratedVisitor)
8948 }
8949 }
8950 struct GeneratedVisitor;
8951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8952 type Value = ListFragmentDistributionRequest;
8953
8954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8955 formatter.write_str("struct meta.ListFragmentDistributionRequest")
8956 }
8957
8958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
8959 where
8960 V: serde::de::MapAccess<'de>,
8961 {
8962 while map_.next_key::<GeneratedField>()?.is_some() {
8963 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8964 }
8965 Ok(ListFragmentDistributionRequest {
8966 })
8967 }
8968 }
8969 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8970 }
8971}
8972impl serde::Serialize for ListFragmentDistributionResponse {
8973 #[allow(deprecated)]
8974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8975 where
8976 S: serde::Serializer,
8977 {
8978 use serde::ser::SerializeStruct;
8979 let mut len = 0;
8980 if !self.distributions.is_empty() {
8981 len += 1;
8982 }
8983 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
8984 if !self.distributions.is_empty() {
8985 struct_ser.serialize_field("distributions", &self.distributions)?;
8986 }
8987 struct_ser.end()
8988 }
8989}
8990impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
8991 #[allow(deprecated)]
8992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8993 where
8994 D: serde::Deserializer<'de>,
8995 {
8996 const FIELDS: &[&str] = &[
8997 "distributions",
8998 ];
8999
9000 #[allow(clippy::enum_variant_names)]
9001 enum GeneratedField {
9002 Distributions,
9003 }
9004 impl<'de> serde::Deserialize<'de> for GeneratedField {
9005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9006 where
9007 D: serde::Deserializer<'de>,
9008 {
9009 struct GeneratedVisitor;
9010
9011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9012 type Value = GeneratedField;
9013
9014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9015 write!(formatter, "expected one of: {:?}", &FIELDS)
9016 }
9017
9018 #[allow(unused_variables)]
9019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9020 where
9021 E: serde::de::Error,
9022 {
9023 match value {
9024 "distributions" => Ok(GeneratedField::Distributions),
9025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9026 }
9027 }
9028 }
9029 deserializer.deserialize_identifier(GeneratedVisitor)
9030 }
9031 }
9032 struct GeneratedVisitor;
9033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9034 type Value = ListFragmentDistributionResponse;
9035
9036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9037 formatter.write_str("struct meta.ListFragmentDistributionResponse")
9038 }
9039
9040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9041 where
9042 V: serde::de::MapAccess<'de>,
9043 {
9044 let mut distributions__ = None;
9045 while let Some(k) = map_.next_key()? {
9046 match k {
9047 GeneratedField::Distributions => {
9048 if distributions__.is_some() {
9049 return Err(serde::de::Error::duplicate_field("distributions"));
9050 }
9051 distributions__ = Some(map_.next_value()?);
9052 }
9053 }
9054 }
9055 Ok(ListFragmentDistributionResponse {
9056 distributions: distributions__.unwrap_or_default(),
9057 })
9058 }
9059 }
9060 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9061 }
9062}
9063impl serde::Serialize for ListIcebergTablesRequest {
9064 #[allow(deprecated)]
9065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9066 where
9067 S: serde::Serializer,
9068 {
9069 use serde::ser::SerializeStruct;
9070 let len = 0;
9071 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
9072 struct_ser.end()
9073 }
9074}
9075impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
9076 #[allow(deprecated)]
9077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9078 where
9079 D: serde::Deserializer<'de>,
9080 {
9081 const FIELDS: &[&str] = &[
9082 ];
9083
9084 #[allow(clippy::enum_variant_names)]
9085 enum GeneratedField {
9086 }
9087 impl<'de> serde::Deserialize<'de> for GeneratedField {
9088 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9089 where
9090 D: serde::Deserializer<'de>,
9091 {
9092 struct GeneratedVisitor;
9093
9094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9095 type Value = GeneratedField;
9096
9097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9098 write!(formatter, "expected one of: {:?}", &FIELDS)
9099 }
9100
9101 #[allow(unused_variables)]
9102 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9103 where
9104 E: serde::de::Error,
9105 {
9106 Err(serde::de::Error::unknown_field(value, FIELDS))
9107 }
9108 }
9109 deserializer.deserialize_identifier(GeneratedVisitor)
9110 }
9111 }
9112 struct GeneratedVisitor;
9113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9114 type Value = ListIcebergTablesRequest;
9115
9116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9117 formatter.write_str("struct meta.ListIcebergTablesRequest")
9118 }
9119
9120 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
9121 where
9122 V: serde::de::MapAccess<'de>,
9123 {
9124 while map_.next_key::<GeneratedField>()?.is_some() {
9125 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9126 }
9127 Ok(ListIcebergTablesRequest {
9128 })
9129 }
9130 }
9131 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
9132 }
9133}
9134impl serde::Serialize for ListIcebergTablesResponse {
9135 #[allow(deprecated)]
9136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9137 where
9138 S: serde::Serializer,
9139 {
9140 use serde::ser::SerializeStruct;
9141 let mut len = 0;
9142 if !self.iceberg_tables.is_empty() {
9143 len += 1;
9144 }
9145 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
9146 if !self.iceberg_tables.is_empty() {
9147 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
9148 }
9149 struct_ser.end()
9150 }
9151}
9152impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
9153 #[allow(deprecated)]
9154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9155 where
9156 D: serde::Deserializer<'de>,
9157 {
9158 const FIELDS: &[&str] = &[
9159 "iceberg_tables",
9160 "icebergTables",
9161 ];
9162
9163 #[allow(clippy::enum_variant_names)]
9164 enum GeneratedField {
9165 IcebergTables,
9166 }
9167 impl<'de> serde::Deserialize<'de> for GeneratedField {
9168 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9169 where
9170 D: serde::Deserializer<'de>,
9171 {
9172 struct GeneratedVisitor;
9173
9174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9175 type Value = GeneratedField;
9176
9177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9178 write!(formatter, "expected one of: {:?}", &FIELDS)
9179 }
9180
9181 #[allow(unused_variables)]
9182 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9183 where
9184 E: serde::de::Error,
9185 {
9186 match value {
9187 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9188 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9189 }
9190 }
9191 }
9192 deserializer.deserialize_identifier(GeneratedVisitor)
9193 }
9194 }
9195 struct GeneratedVisitor;
9196 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9197 type Value = ListIcebergTablesResponse;
9198
9199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9200 formatter.write_str("struct meta.ListIcebergTablesResponse")
9201 }
9202
9203 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9204 where
9205 V: serde::de::MapAccess<'de>,
9206 {
9207 let mut iceberg_tables__ = None;
9208 while let Some(k) = map_.next_key()? {
9209 match k {
9210 GeneratedField::IcebergTables => {
9211 if iceberg_tables__.is_some() {
9212 return Err(serde::de::Error::duplicate_field("icebergTables"));
9213 }
9214 iceberg_tables__ = Some(map_.next_value()?);
9215 }
9216 }
9217 }
9218 Ok(ListIcebergTablesResponse {
9219 iceberg_tables: iceberg_tables__.unwrap_or_default(),
9220 })
9221 }
9222 }
9223 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9224 }
9225}
9226impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9227 #[allow(deprecated)]
9228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9229 where
9230 S: serde::Serializer,
9231 {
9232 use serde::ser::SerializeStruct;
9233 let mut len = 0;
9234 if !self.catalog_name.is_empty() {
9235 len += 1;
9236 }
9237 if !self.table_namespace.is_empty() {
9238 len += 1;
9239 }
9240 if !self.table_name.is_empty() {
9241 len += 1;
9242 }
9243 if self.metadata_location.is_some() {
9244 len += 1;
9245 }
9246 if self.previous_metadata_location.is_some() {
9247 len += 1;
9248 }
9249 if self.iceberg_type.is_some() {
9250 len += 1;
9251 }
9252 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9253 if !self.catalog_name.is_empty() {
9254 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9255 }
9256 if !self.table_namespace.is_empty() {
9257 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9258 }
9259 if !self.table_name.is_empty() {
9260 struct_ser.serialize_field("tableName", &self.table_name)?;
9261 }
9262 if let Some(v) = self.metadata_location.as_ref() {
9263 struct_ser.serialize_field("metadataLocation", v)?;
9264 }
9265 if let Some(v) = self.previous_metadata_location.as_ref() {
9266 struct_ser.serialize_field("previousMetadataLocation", v)?;
9267 }
9268 if let Some(v) = self.iceberg_type.as_ref() {
9269 struct_ser.serialize_field("icebergType", v)?;
9270 }
9271 struct_ser.end()
9272 }
9273}
9274impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9275 #[allow(deprecated)]
9276 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9277 where
9278 D: serde::Deserializer<'de>,
9279 {
9280 const FIELDS: &[&str] = &[
9281 "catalog_name",
9282 "catalogName",
9283 "table_namespace",
9284 "tableNamespace",
9285 "table_name",
9286 "tableName",
9287 "metadata_location",
9288 "metadataLocation",
9289 "previous_metadata_location",
9290 "previousMetadataLocation",
9291 "iceberg_type",
9292 "icebergType",
9293 ];
9294
9295 #[allow(clippy::enum_variant_names)]
9296 enum GeneratedField {
9297 CatalogName,
9298 TableNamespace,
9299 TableName,
9300 MetadataLocation,
9301 PreviousMetadataLocation,
9302 IcebergType,
9303 }
9304 impl<'de> serde::Deserialize<'de> for GeneratedField {
9305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9306 where
9307 D: serde::Deserializer<'de>,
9308 {
9309 struct GeneratedVisitor;
9310
9311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9312 type Value = GeneratedField;
9313
9314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9315 write!(formatter, "expected one of: {:?}", &FIELDS)
9316 }
9317
9318 #[allow(unused_variables)]
9319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9320 where
9321 E: serde::de::Error,
9322 {
9323 match value {
9324 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9325 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9326 "tableName" | "table_name" => Ok(GeneratedField::TableName),
9327 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9328 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9329 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9330 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9331 }
9332 }
9333 }
9334 deserializer.deserialize_identifier(GeneratedVisitor)
9335 }
9336 }
9337 struct GeneratedVisitor;
9338 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9339 type Value = list_iceberg_tables_response::IcebergTable;
9340
9341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9342 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9343 }
9344
9345 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9346 where
9347 V: serde::de::MapAccess<'de>,
9348 {
9349 let mut catalog_name__ = None;
9350 let mut table_namespace__ = None;
9351 let mut table_name__ = None;
9352 let mut metadata_location__ = None;
9353 let mut previous_metadata_location__ = None;
9354 let mut iceberg_type__ = None;
9355 while let Some(k) = map_.next_key()? {
9356 match k {
9357 GeneratedField::CatalogName => {
9358 if catalog_name__.is_some() {
9359 return Err(serde::de::Error::duplicate_field("catalogName"));
9360 }
9361 catalog_name__ = Some(map_.next_value()?);
9362 }
9363 GeneratedField::TableNamespace => {
9364 if table_namespace__.is_some() {
9365 return Err(serde::de::Error::duplicate_field("tableNamespace"));
9366 }
9367 table_namespace__ = Some(map_.next_value()?);
9368 }
9369 GeneratedField::TableName => {
9370 if table_name__.is_some() {
9371 return Err(serde::de::Error::duplicate_field("tableName"));
9372 }
9373 table_name__ = Some(map_.next_value()?);
9374 }
9375 GeneratedField::MetadataLocation => {
9376 if metadata_location__.is_some() {
9377 return Err(serde::de::Error::duplicate_field("metadataLocation"));
9378 }
9379 metadata_location__ = map_.next_value()?;
9380 }
9381 GeneratedField::PreviousMetadataLocation => {
9382 if previous_metadata_location__.is_some() {
9383 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9384 }
9385 previous_metadata_location__ = map_.next_value()?;
9386 }
9387 GeneratedField::IcebergType => {
9388 if iceberg_type__.is_some() {
9389 return Err(serde::de::Error::duplicate_field("icebergType"));
9390 }
9391 iceberg_type__ = map_.next_value()?;
9392 }
9393 }
9394 }
9395 Ok(list_iceberg_tables_response::IcebergTable {
9396 catalog_name: catalog_name__.unwrap_or_default(),
9397 table_namespace: table_namespace__.unwrap_or_default(),
9398 table_name: table_name__.unwrap_or_default(),
9399 metadata_location: metadata_location__,
9400 previous_metadata_location: previous_metadata_location__,
9401 iceberg_type: iceberg_type__,
9402 })
9403 }
9404 }
9405 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9406 }
9407}
9408impl serde::Serialize for ListObjectDependenciesRequest {
9409 #[allow(deprecated)]
9410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9411 where
9412 S: serde::Serializer,
9413 {
9414 use serde::ser::SerializeStruct;
9415 let len = 0;
9416 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9417 struct_ser.end()
9418 }
9419}
9420impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9421 #[allow(deprecated)]
9422 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9423 where
9424 D: serde::Deserializer<'de>,
9425 {
9426 const FIELDS: &[&str] = &[
9427 ];
9428
9429 #[allow(clippy::enum_variant_names)]
9430 enum GeneratedField {
9431 }
9432 impl<'de> serde::Deserialize<'de> for GeneratedField {
9433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9434 where
9435 D: serde::Deserializer<'de>,
9436 {
9437 struct GeneratedVisitor;
9438
9439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9440 type Value = GeneratedField;
9441
9442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9443 write!(formatter, "expected one of: {:?}", &FIELDS)
9444 }
9445
9446 #[allow(unused_variables)]
9447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9448 where
9449 E: serde::de::Error,
9450 {
9451 Err(serde::de::Error::unknown_field(value, FIELDS))
9452 }
9453 }
9454 deserializer.deserialize_identifier(GeneratedVisitor)
9455 }
9456 }
9457 struct GeneratedVisitor;
9458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9459 type Value = ListObjectDependenciesRequest;
9460
9461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9462 formatter.write_str("struct meta.ListObjectDependenciesRequest")
9463 }
9464
9465 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9466 where
9467 V: serde::de::MapAccess<'de>,
9468 {
9469 while map_.next_key::<GeneratedField>()?.is_some() {
9470 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9471 }
9472 Ok(ListObjectDependenciesRequest {
9473 })
9474 }
9475 }
9476 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9477 }
9478}
9479impl serde::Serialize for ListObjectDependenciesResponse {
9480 #[allow(deprecated)]
9481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9482 where
9483 S: serde::Serializer,
9484 {
9485 use serde::ser::SerializeStruct;
9486 let mut len = 0;
9487 if !self.dependencies.is_empty() {
9488 len += 1;
9489 }
9490 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9491 if !self.dependencies.is_empty() {
9492 struct_ser.serialize_field("dependencies", &self.dependencies)?;
9493 }
9494 struct_ser.end()
9495 }
9496}
9497impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9498 #[allow(deprecated)]
9499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9500 where
9501 D: serde::Deserializer<'de>,
9502 {
9503 const FIELDS: &[&str] = &[
9504 "dependencies",
9505 ];
9506
9507 #[allow(clippy::enum_variant_names)]
9508 enum GeneratedField {
9509 Dependencies,
9510 }
9511 impl<'de> serde::Deserialize<'de> for GeneratedField {
9512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9513 where
9514 D: serde::Deserializer<'de>,
9515 {
9516 struct GeneratedVisitor;
9517
9518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9519 type Value = GeneratedField;
9520
9521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9522 write!(formatter, "expected one of: {:?}", &FIELDS)
9523 }
9524
9525 #[allow(unused_variables)]
9526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9527 where
9528 E: serde::de::Error,
9529 {
9530 match value {
9531 "dependencies" => Ok(GeneratedField::Dependencies),
9532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9533 }
9534 }
9535 }
9536 deserializer.deserialize_identifier(GeneratedVisitor)
9537 }
9538 }
9539 struct GeneratedVisitor;
9540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9541 type Value = ListObjectDependenciesResponse;
9542
9543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9544 formatter.write_str("struct meta.ListObjectDependenciesResponse")
9545 }
9546
9547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
9548 where
9549 V: serde::de::MapAccess<'de>,
9550 {
9551 let mut dependencies__ = None;
9552 while let Some(k) = map_.next_key()? {
9553 match k {
9554 GeneratedField::Dependencies => {
9555 if dependencies__.is_some() {
9556 return Err(serde::de::Error::duplicate_field("dependencies"));
9557 }
9558 dependencies__ = Some(map_.next_value()?);
9559 }
9560 }
9561 }
9562 Ok(ListObjectDependenciesResponse {
9563 dependencies: dependencies__.unwrap_or_default(),
9564 })
9565 }
9566 }
9567 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
9568 }
9569}
9570impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
9571 #[allow(deprecated)]
9572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9573 where
9574 S: serde::Serializer,
9575 {
9576 use serde::ser::SerializeStruct;
9577 let mut len = 0;
9578 if self.object_id != 0 {
9579 len += 1;
9580 }
9581 if self.referenced_object_id != 0 {
9582 len += 1;
9583 }
9584 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
9585 if self.object_id != 0 {
9586 struct_ser.serialize_field("objectId", &self.object_id)?;
9587 }
9588 if self.referenced_object_id != 0 {
9589 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
9590 }
9591 struct_ser.end()
9592 }
9593}
9594impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
9595 #[allow(deprecated)]
9596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9597 where
9598 D: serde::Deserializer<'de>,
9599 {
9600 const FIELDS: &[&str] = &[
9601 "object_id",
9602 "objectId",
9603 "referenced_object_id",
9604 "referencedObjectId",
9605 ];
9606
9607 #[allow(clippy::enum_variant_names)]
9608 enum GeneratedField {
9609 ObjectId,
9610 ReferencedObjectId,
9611 }
9612 impl<'de> serde::Deserialize<'de> for GeneratedField {
9613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9614 where
9615 D: serde::Deserializer<'de>,
9616 {
9617 struct GeneratedVisitor;
9618
9619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9620 type Value = GeneratedField;
9621
9622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9623 write!(formatter, "expected one of: {:?}", &FIELDS)
9624 }
9625
9626 #[allow(unused_variables)]
9627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9628 where
9629 E: serde::de::Error,
9630 {
9631 match value {
9632 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
9633 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
9634 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9635 }
9636 }
9637 }
9638 deserializer.deserialize_identifier(GeneratedVisitor)
9639 }
9640 }
9641 struct GeneratedVisitor;
9642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9643 type Value = list_object_dependencies_response::ObjectDependencies;
9644
9645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9646 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
9647 }
9648
9649 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
9650 where
9651 V: serde::de::MapAccess<'de>,
9652 {
9653 let mut object_id__ = None;
9654 let mut referenced_object_id__ = None;
9655 while let Some(k) = map_.next_key()? {
9656 match k {
9657 GeneratedField::ObjectId => {
9658 if object_id__.is_some() {
9659 return Err(serde::de::Error::duplicate_field("objectId"));
9660 }
9661 object_id__ =
9662 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9663 ;
9664 }
9665 GeneratedField::ReferencedObjectId => {
9666 if referenced_object_id__.is_some() {
9667 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
9668 }
9669 referenced_object_id__ =
9670 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9671 ;
9672 }
9673 }
9674 }
9675 Ok(list_object_dependencies_response::ObjectDependencies {
9676 object_id: object_id__.unwrap_or_default(),
9677 referenced_object_id: referenced_object_id__.unwrap_or_default(),
9678 })
9679 }
9680 }
9681 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
9682 }
9683}
9684impl serde::Serialize for ListRateLimitsRequest {
9685 #[allow(deprecated)]
9686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9687 where
9688 S: serde::Serializer,
9689 {
9690 use serde::ser::SerializeStruct;
9691 let len = 0;
9692 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
9693 struct_ser.end()
9694 }
9695}
9696impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
9697 #[allow(deprecated)]
9698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9699 where
9700 D: serde::Deserializer<'de>,
9701 {
9702 const FIELDS: &[&str] = &[
9703 ];
9704
9705 #[allow(clippy::enum_variant_names)]
9706 enum GeneratedField {
9707 }
9708 impl<'de> serde::Deserialize<'de> for GeneratedField {
9709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9710 where
9711 D: serde::Deserializer<'de>,
9712 {
9713 struct GeneratedVisitor;
9714
9715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9716 type Value = GeneratedField;
9717
9718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9719 write!(formatter, "expected one of: {:?}", &FIELDS)
9720 }
9721
9722 #[allow(unused_variables)]
9723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9724 where
9725 E: serde::de::Error,
9726 {
9727 Err(serde::de::Error::unknown_field(value, FIELDS))
9728 }
9729 }
9730 deserializer.deserialize_identifier(GeneratedVisitor)
9731 }
9732 }
9733 struct GeneratedVisitor;
9734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9735 type Value = ListRateLimitsRequest;
9736
9737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9738 formatter.write_str("struct meta.ListRateLimitsRequest")
9739 }
9740
9741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
9742 where
9743 V: serde::de::MapAccess<'de>,
9744 {
9745 while map_.next_key::<GeneratedField>()?.is_some() {
9746 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9747 }
9748 Ok(ListRateLimitsRequest {
9749 })
9750 }
9751 }
9752 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
9753 }
9754}
9755impl serde::Serialize for ListRateLimitsResponse {
9756 #[allow(deprecated)]
9757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9758 where
9759 S: serde::Serializer,
9760 {
9761 use serde::ser::SerializeStruct;
9762 let mut len = 0;
9763 if !self.rate_limits.is_empty() {
9764 len += 1;
9765 }
9766 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
9767 if !self.rate_limits.is_empty() {
9768 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
9769 }
9770 struct_ser.end()
9771 }
9772}
9773impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
9774 #[allow(deprecated)]
9775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9776 where
9777 D: serde::Deserializer<'de>,
9778 {
9779 const FIELDS: &[&str] = &[
9780 "rate_limits",
9781 "rateLimits",
9782 ];
9783
9784 #[allow(clippy::enum_variant_names)]
9785 enum GeneratedField {
9786 RateLimits,
9787 }
9788 impl<'de> serde::Deserialize<'de> for GeneratedField {
9789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9790 where
9791 D: serde::Deserializer<'de>,
9792 {
9793 struct GeneratedVisitor;
9794
9795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9796 type Value = GeneratedField;
9797
9798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9799 write!(formatter, "expected one of: {:?}", &FIELDS)
9800 }
9801
9802 #[allow(unused_variables)]
9803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9804 where
9805 E: serde::de::Error,
9806 {
9807 match value {
9808 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
9809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9810 }
9811 }
9812 }
9813 deserializer.deserialize_identifier(GeneratedVisitor)
9814 }
9815 }
9816 struct GeneratedVisitor;
9817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9818 type Value = ListRateLimitsResponse;
9819
9820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9821 formatter.write_str("struct meta.ListRateLimitsResponse")
9822 }
9823
9824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
9825 where
9826 V: serde::de::MapAccess<'de>,
9827 {
9828 let mut rate_limits__ = None;
9829 while let Some(k) = map_.next_key()? {
9830 match k {
9831 GeneratedField::RateLimits => {
9832 if rate_limits__.is_some() {
9833 return Err(serde::de::Error::duplicate_field("rateLimits"));
9834 }
9835 rate_limits__ = Some(map_.next_value()?);
9836 }
9837 }
9838 }
9839 Ok(ListRateLimitsResponse {
9840 rate_limits: rate_limits__.unwrap_or_default(),
9841 })
9842 }
9843 }
9844 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
9845 }
9846}
9847impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
9848 #[allow(deprecated)]
9849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9850 where
9851 S: serde::Serializer,
9852 {
9853 use serde::ser::SerializeStruct;
9854 let mut len = 0;
9855 if self.fragment_id != 0 {
9856 len += 1;
9857 }
9858 if self.job_id != 0 {
9859 len += 1;
9860 }
9861 if self.fragment_type_mask != 0 {
9862 len += 1;
9863 }
9864 if self.rate_limit != 0 {
9865 len += 1;
9866 }
9867 if !self.node_name.is_empty() {
9868 len += 1;
9869 }
9870 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
9871 if self.fragment_id != 0 {
9872 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9873 }
9874 if self.job_id != 0 {
9875 struct_ser.serialize_field("jobId", &self.job_id)?;
9876 }
9877 if self.fragment_type_mask != 0 {
9878 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
9879 }
9880 if self.rate_limit != 0 {
9881 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
9882 }
9883 if !self.node_name.is_empty() {
9884 struct_ser.serialize_field("nodeName", &self.node_name)?;
9885 }
9886 struct_ser.end()
9887 }
9888}
9889impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
9890 #[allow(deprecated)]
9891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9892 where
9893 D: serde::Deserializer<'de>,
9894 {
9895 const FIELDS: &[&str] = &[
9896 "fragment_id",
9897 "fragmentId",
9898 "job_id",
9899 "jobId",
9900 "fragment_type_mask",
9901 "fragmentTypeMask",
9902 "rate_limit",
9903 "rateLimit",
9904 "node_name",
9905 "nodeName",
9906 ];
9907
9908 #[allow(clippy::enum_variant_names)]
9909 enum GeneratedField {
9910 FragmentId,
9911 JobId,
9912 FragmentTypeMask,
9913 RateLimit,
9914 NodeName,
9915 }
9916 impl<'de> serde::Deserialize<'de> for GeneratedField {
9917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9918 where
9919 D: serde::Deserializer<'de>,
9920 {
9921 struct GeneratedVisitor;
9922
9923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9924 type Value = GeneratedField;
9925
9926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9927 write!(formatter, "expected one of: {:?}", &FIELDS)
9928 }
9929
9930 #[allow(unused_variables)]
9931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9932 where
9933 E: serde::de::Error,
9934 {
9935 match value {
9936 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9937 "jobId" | "job_id" => Ok(GeneratedField::JobId),
9938 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
9939 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9940 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
9941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9942 }
9943 }
9944 }
9945 deserializer.deserialize_identifier(GeneratedVisitor)
9946 }
9947 }
9948 struct GeneratedVisitor;
9949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9950 type Value = list_rate_limits_response::RateLimitInfo;
9951
9952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9953 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
9954 }
9955
9956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
9957 where
9958 V: serde::de::MapAccess<'de>,
9959 {
9960 let mut fragment_id__ = None;
9961 let mut job_id__ = None;
9962 let mut fragment_type_mask__ = None;
9963 let mut rate_limit__ = None;
9964 let mut node_name__ = None;
9965 while let Some(k) = map_.next_key()? {
9966 match k {
9967 GeneratedField::FragmentId => {
9968 if fragment_id__.is_some() {
9969 return Err(serde::de::Error::duplicate_field("fragmentId"));
9970 }
9971 fragment_id__ =
9972 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9973 ;
9974 }
9975 GeneratedField::JobId => {
9976 if job_id__.is_some() {
9977 return Err(serde::de::Error::duplicate_field("jobId"));
9978 }
9979 job_id__ =
9980 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9981 ;
9982 }
9983 GeneratedField::FragmentTypeMask => {
9984 if fragment_type_mask__.is_some() {
9985 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
9986 }
9987 fragment_type_mask__ =
9988 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9989 ;
9990 }
9991 GeneratedField::RateLimit => {
9992 if rate_limit__.is_some() {
9993 return Err(serde::de::Error::duplicate_field("rateLimit"));
9994 }
9995 rate_limit__ =
9996 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9997 ;
9998 }
9999 GeneratedField::NodeName => {
10000 if node_name__.is_some() {
10001 return Err(serde::de::Error::duplicate_field("nodeName"));
10002 }
10003 node_name__ = Some(map_.next_value()?);
10004 }
10005 }
10006 }
10007 Ok(list_rate_limits_response::RateLimitInfo {
10008 fragment_id: fragment_id__.unwrap_or_default(),
10009 job_id: job_id__.unwrap_or_default(),
10010 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10011 rate_limit: rate_limit__.unwrap_or_default(),
10012 node_name: node_name__.unwrap_or_default(),
10013 })
10014 }
10015 }
10016 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10017 }
10018}
10019impl serde::Serialize for ListStreamingJobStatesRequest {
10020 #[allow(deprecated)]
10021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10022 where
10023 S: serde::Serializer,
10024 {
10025 use serde::ser::SerializeStruct;
10026 let len = 0;
10027 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
10028 struct_ser.end()
10029 }
10030}
10031impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
10032 #[allow(deprecated)]
10033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10034 where
10035 D: serde::Deserializer<'de>,
10036 {
10037 const FIELDS: &[&str] = &[
10038 ];
10039
10040 #[allow(clippy::enum_variant_names)]
10041 enum GeneratedField {
10042 }
10043 impl<'de> serde::Deserialize<'de> for GeneratedField {
10044 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10045 where
10046 D: serde::Deserializer<'de>,
10047 {
10048 struct GeneratedVisitor;
10049
10050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10051 type Value = GeneratedField;
10052
10053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10054 write!(formatter, "expected one of: {:?}", &FIELDS)
10055 }
10056
10057 #[allow(unused_variables)]
10058 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10059 where
10060 E: serde::de::Error,
10061 {
10062 Err(serde::de::Error::unknown_field(value, FIELDS))
10063 }
10064 }
10065 deserializer.deserialize_identifier(GeneratedVisitor)
10066 }
10067 }
10068 struct GeneratedVisitor;
10069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10070 type Value = ListStreamingJobStatesRequest;
10071
10072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10073 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
10074 }
10075
10076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
10077 where
10078 V: serde::de::MapAccess<'de>,
10079 {
10080 while map_.next_key::<GeneratedField>()?.is_some() {
10081 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10082 }
10083 Ok(ListStreamingJobStatesRequest {
10084 })
10085 }
10086 }
10087 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
10088 }
10089}
10090impl serde::Serialize for ListStreamingJobStatesResponse {
10091 #[allow(deprecated)]
10092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10093 where
10094 S: serde::Serializer,
10095 {
10096 use serde::ser::SerializeStruct;
10097 let mut len = 0;
10098 if !self.states.is_empty() {
10099 len += 1;
10100 }
10101 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
10102 if !self.states.is_empty() {
10103 struct_ser.serialize_field("states", &self.states)?;
10104 }
10105 struct_ser.end()
10106 }
10107}
10108impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
10109 #[allow(deprecated)]
10110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10111 where
10112 D: serde::Deserializer<'de>,
10113 {
10114 const FIELDS: &[&str] = &[
10115 "states",
10116 ];
10117
10118 #[allow(clippy::enum_variant_names)]
10119 enum GeneratedField {
10120 States,
10121 }
10122 impl<'de> serde::Deserialize<'de> for GeneratedField {
10123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10124 where
10125 D: serde::Deserializer<'de>,
10126 {
10127 struct GeneratedVisitor;
10128
10129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10130 type Value = GeneratedField;
10131
10132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10133 write!(formatter, "expected one of: {:?}", &FIELDS)
10134 }
10135
10136 #[allow(unused_variables)]
10137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10138 where
10139 E: serde::de::Error,
10140 {
10141 match value {
10142 "states" => Ok(GeneratedField::States),
10143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10144 }
10145 }
10146 }
10147 deserializer.deserialize_identifier(GeneratedVisitor)
10148 }
10149 }
10150 struct GeneratedVisitor;
10151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10152 type Value = ListStreamingJobStatesResponse;
10153
10154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10155 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
10156 }
10157
10158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
10159 where
10160 V: serde::de::MapAccess<'de>,
10161 {
10162 let mut states__ = None;
10163 while let Some(k) = map_.next_key()? {
10164 match k {
10165 GeneratedField::States => {
10166 if states__.is_some() {
10167 return Err(serde::de::Error::duplicate_field("states"));
10168 }
10169 states__ = Some(map_.next_value()?);
10170 }
10171 }
10172 }
10173 Ok(ListStreamingJobStatesResponse {
10174 states: states__.unwrap_or_default(),
10175 })
10176 }
10177 }
10178 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10179 }
10180}
10181impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10182 #[allow(deprecated)]
10183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10184 where
10185 S: serde::Serializer,
10186 {
10187 use serde::ser::SerializeStruct;
10188 let mut len = 0;
10189 if self.table_id != 0 {
10190 len += 1;
10191 }
10192 if self.state != 0 {
10193 len += 1;
10194 }
10195 if self.parallelism.is_some() {
10196 len += 1;
10197 }
10198 if self.max_parallelism != 0 {
10199 len += 1;
10200 }
10201 if !self.name.is_empty() {
10202 len += 1;
10203 }
10204 if !self.resource_group.is_empty() {
10205 len += 1;
10206 }
10207 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10208 if self.table_id != 0 {
10209 struct_ser.serialize_field("tableId", &self.table_id)?;
10210 }
10211 if self.state != 0 {
10212 let v = table_fragments::State::try_from(self.state)
10213 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10214 struct_ser.serialize_field("state", &v)?;
10215 }
10216 if let Some(v) = self.parallelism.as_ref() {
10217 struct_ser.serialize_field("parallelism", v)?;
10218 }
10219 if self.max_parallelism != 0 {
10220 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10221 }
10222 if !self.name.is_empty() {
10223 struct_ser.serialize_field("name", &self.name)?;
10224 }
10225 if !self.resource_group.is_empty() {
10226 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10227 }
10228 struct_ser.end()
10229 }
10230}
10231impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10232 #[allow(deprecated)]
10233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10234 where
10235 D: serde::Deserializer<'de>,
10236 {
10237 const FIELDS: &[&str] = &[
10238 "table_id",
10239 "tableId",
10240 "state",
10241 "parallelism",
10242 "max_parallelism",
10243 "maxParallelism",
10244 "name",
10245 "resource_group",
10246 "resourceGroup",
10247 ];
10248
10249 #[allow(clippy::enum_variant_names)]
10250 enum GeneratedField {
10251 TableId,
10252 State,
10253 Parallelism,
10254 MaxParallelism,
10255 Name,
10256 ResourceGroup,
10257 }
10258 impl<'de> serde::Deserialize<'de> for GeneratedField {
10259 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10260 where
10261 D: serde::Deserializer<'de>,
10262 {
10263 struct GeneratedVisitor;
10264
10265 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10266 type Value = GeneratedField;
10267
10268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10269 write!(formatter, "expected one of: {:?}", &FIELDS)
10270 }
10271
10272 #[allow(unused_variables)]
10273 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10274 where
10275 E: serde::de::Error,
10276 {
10277 match value {
10278 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10279 "state" => Ok(GeneratedField::State),
10280 "parallelism" => Ok(GeneratedField::Parallelism),
10281 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10282 "name" => Ok(GeneratedField::Name),
10283 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10285 }
10286 }
10287 }
10288 deserializer.deserialize_identifier(GeneratedVisitor)
10289 }
10290 }
10291 struct GeneratedVisitor;
10292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10293 type Value = list_streaming_job_states_response::StreamingJobState;
10294
10295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10296 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10297 }
10298
10299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10300 where
10301 V: serde::de::MapAccess<'de>,
10302 {
10303 let mut table_id__ = None;
10304 let mut state__ = None;
10305 let mut parallelism__ = None;
10306 let mut max_parallelism__ = None;
10307 let mut name__ = None;
10308 let mut resource_group__ = None;
10309 while let Some(k) = map_.next_key()? {
10310 match k {
10311 GeneratedField::TableId => {
10312 if table_id__.is_some() {
10313 return Err(serde::de::Error::duplicate_field("tableId"));
10314 }
10315 table_id__ =
10316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10317 ;
10318 }
10319 GeneratedField::State => {
10320 if state__.is_some() {
10321 return Err(serde::de::Error::duplicate_field("state"));
10322 }
10323 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10324 }
10325 GeneratedField::Parallelism => {
10326 if parallelism__.is_some() {
10327 return Err(serde::de::Error::duplicate_field("parallelism"));
10328 }
10329 parallelism__ = map_.next_value()?;
10330 }
10331 GeneratedField::MaxParallelism => {
10332 if max_parallelism__.is_some() {
10333 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10334 }
10335 max_parallelism__ =
10336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10337 ;
10338 }
10339 GeneratedField::Name => {
10340 if name__.is_some() {
10341 return Err(serde::de::Error::duplicate_field("name"));
10342 }
10343 name__ = Some(map_.next_value()?);
10344 }
10345 GeneratedField::ResourceGroup => {
10346 if resource_group__.is_some() {
10347 return Err(serde::de::Error::duplicate_field("resourceGroup"));
10348 }
10349 resource_group__ = Some(map_.next_value()?);
10350 }
10351 }
10352 }
10353 Ok(list_streaming_job_states_response::StreamingJobState {
10354 table_id: table_id__.unwrap_or_default(),
10355 state: state__.unwrap_or_default(),
10356 parallelism: parallelism__,
10357 max_parallelism: max_parallelism__.unwrap_or_default(),
10358 name: name__.unwrap_or_default(),
10359 resource_group: resource_group__.unwrap_or_default(),
10360 })
10361 }
10362 }
10363 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10364 }
10365}
10366impl serde::Serialize for ListTableFragmentsRequest {
10367 #[allow(deprecated)]
10368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10369 where
10370 S: serde::Serializer,
10371 {
10372 use serde::ser::SerializeStruct;
10373 let mut len = 0;
10374 if !self.table_ids.is_empty() {
10375 len += 1;
10376 }
10377 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10378 if !self.table_ids.is_empty() {
10379 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10380 }
10381 struct_ser.end()
10382 }
10383}
10384impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10385 #[allow(deprecated)]
10386 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10387 where
10388 D: serde::Deserializer<'de>,
10389 {
10390 const FIELDS: &[&str] = &[
10391 "table_ids",
10392 "tableIds",
10393 ];
10394
10395 #[allow(clippy::enum_variant_names)]
10396 enum GeneratedField {
10397 TableIds,
10398 }
10399 impl<'de> serde::Deserialize<'de> for GeneratedField {
10400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10401 where
10402 D: serde::Deserializer<'de>,
10403 {
10404 struct GeneratedVisitor;
10405
10406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10407 type Value = GeneratedField;
10408
10409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10410 write!(formatter, "expected one of: {:?}", &FIELDS)
10411 }
10412
10413 #[allow(unused_variables)]
10414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10415 where
10416 E: serde::de::Error,
10417 {
10418 match value {
10419 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10420 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10421 }
10422 }
10423 }
10424 deserializer.deserialize_identifier(GeneratedVisitor)
10425 }
10426 }
10427 struct GeneratedVisitor;
10428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10429 type Value = ListTableFragmentsRequest;
10430
10431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10432 formatter.write_str("struct meta.ListTableFragmentsRequest")
10433 }
10434
10435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10436 where
10437 V: serde::de::MapAccess<'de>,
10438 {
10439 let mut table_ids__ = None;
10440 while let Some(k) = map_.next_key()? {
10441 match k {
10442 GeneratedField::TableIds => {
10443 if table_ids__.is_some() {
10444 return Err(serde::de::Error::duplicate_field("tableIds"));
10445 }
10446 table_ids__ =
10447 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10448 .into_iter().map(|x| x.0).collect())
10449 ;
10450 }
10451 }
10452 }
10453 Ok(ListTableFragmentsRequest {
10454 table_ids: table_ids__.unwrap_or_default(),
10455 })
10456 }
10457 }
10458 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10459 }
10460}
10461impl serde::Serialize for ListTableFragmentsResponse {
10462 #[allow(deprecated)]
10463 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10464 where
10465 S: serde::Serializer,
10466 {
10467 use serde::ser::SerializeStruct;
10468 let mut len = 0;
10469 if !self.table_fragments.is_empty() {
10470 len += 1;
10471 }
10472 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10473 if !self.table_fragments.is_empty() {
10474 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10475 }
10476 struct_ser.end()
10477 }
10478}
10479impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10480 #[allow(deprecated)]
10481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10482 where
10483 D: serde::Deserializer<'de>,
10484 {
10485 const FIELDS: &[&str] = &[
10486 "table_fragments",
10487 "tableFragments",
10488 ];
10489
10490 #[allow(clippy::enum_variant_names)]
10491 enum GeneratedField {
10492 TableFragments,
10493 }
10494 impl<'de> serde::Deserialize<'de> for GeneratedField {
10495 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10496 where
10497 D: serde::Deserializer<'de>,
10498 {
10499 struct GeneratedVisitor;
10500
10501 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10502 type Value = GeneratedField;
10503
10504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10505 write!(formatter, "expected one of: {:?}", &FIELDS)
10506 }
10507
10508 #[allow(unused_variables)]
10509 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10510 where
10511 E: serde::de::Error,
10512 {
10513 match value {
10514 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
10515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10516 }
10517 }
10518 }
10519 deserializer.deserialize_identifier(GeneratedVisitor)
10520 }
10521 }
10522 struct GeneratedVisitor;
10523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10524 type Value = ListTableFragmentsResponse;
10525
10526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10527 formatter.write_str("struct meta.ListTableFragmentsResponse")
10528 }
10529
10530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
10531 where
10532 V: serde::de::MapAccess<'de>,
10533 {
10534 let mut table_fragments__ = None;
10535 while let Some(k) = map_.next_key()? {
10536 match k {
10537 GeneratedField::TableFragments => {
10538 if table_fragments__.is_some() {
10539 return Err(serde::de::Error::duplicate_field("tableFragments"));
10540 }
10541 table_fragments__ = Some(
10542 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10543 .into_iter().map(|(k,v)| (k.0, v)).collect()
10544 );
10545 }
10546 }
10547 }
10548 Ok(ListTableFragmentsResponse {
10549 table_fragments: table_fragments__.unwrap_or_default(),
10550 })
10551 }
10552 }
10553 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
10554 }
10555}
10556impl serde::Serialize for list_table_fragments_response::ActorInfo {
10557 #[allow(deprecated)]
10558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10559 where
10560 S: serde::Serializer,
10561 {
10562 use serde::ser::SerializeStruct;
10563 let mut len = 0;
10564 if self.id != 0 {
10565 len += 1;
10566 }
10567 if self.node.is_some() {
10568 len += 1;
10569 }
10570 if !self.dispatcher.is_empty() {
10571 len += 1;
10572 }
10573 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
10574 if self.id != 0 {
10575 struct_ser.serialize_field("id", &self.id)?;
10576 }
10577 if let Some(v) = self.node.as_ref() {
10578 struct_ser.serialize_field("node", v)?;
10579 }
10580 if !self.dispatcher.is_empty() {
10581 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10582 }
10583 struct_ser.end()
10584 }
10585}
10586impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
10587 #[allow(deprecated)]
10588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10589 where
10590 D: serde::Deserializer<'de>,
10591 {
10592 const FIELDS: &[&str] = &[
10593 "id",
10594 "node",
10595 "dispatcher",
10596 ];
10597
10598 #[allow(clippy::enum_variant_names)]
10599 enum GeneratedField {
10600 Id,
10601 Node,
10602 Dispatcher,
10603 }
10604 impl<'de> serde::Deserialize<'de> for GeneratedField {
10605 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10606 where
10607 D: serde::Deserializer<'de>,
10608 {
10609 struct GeneratedVisitor;
10610
10611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10612 type Value = GeneratedField;
10613
10614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10615 write!(formatter, "expected one of: {:?}", &FIELDS)
10616 }
10617
10618 #[allow(unused_variables)]
10619 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10620 where
10621 E: serde::de::Error,
10622 {
10623 match value {
10624 "id" => Ok(GeneratedField::Id),
10625 "node" => Ok(GeneratedField::Node),
10626 "dispatcher" => Ok(GeneratedField::Dispatcher),
10627 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10628 }
10629 }
10630 }
10631 deserializer.deserialize_identifier(GeneratedVisitor)
10632 }
10633 }
10634 struct GeneratedVisitor;
10635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10636 type Value = list_table_fragments_response::ActorInfo;
10637
10638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10639 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
10640 }
10641
10642 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
10643 where
10644 V: serde::de::MapAccess<'de>,
10645 {
10646 let mut id__ = None;
10647 let mut node__ = None;
10648 let mut dispatcher__ = None;
10649 while let Some(k) = map_.next_key()? {
10650 match k {
10651 GeneratedField::Id => {
10652 if id__.is_some() {
10653 return Err(serde::de::Error::duplicate_field("id"));
10654 }
10655 id__ =
10656 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10657 ;
10658 }
10659 GeneratedField::Node => {
10660 if node__.is_some() {
10661 return Err(serde::de::Error::duplicate_field("node"));
10662 }
10663 node__ = map_.next_value()?;
10664 }
10665 GeneratedField::Dispatcher => {
10666 if dispatcher__.is_some() {
10667 return Err(serde::de::Error::duplicate_field("dispatcher"));
10668 }
10669 dispatcher__ = Some(map_.next_value()?);
10670 }
10671 }
10672 }
10673 Ok(list_table_fragments_response::ActorInfo {
10674 id: id__.unwrap_or_default(),
10675 node: node__,
10676 dispatcher: dispatcher__.unwrap_or_default(),
10677 })
10678 }
10679 }
10680 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
10681 }
10682}
10683impl serde::Serialize for list_table_fragments_response::FragmentInfo {
10684 #[allow(deprecated)]
10685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10686 where
10687 S: serde::Serializer,
10688 {
10689 use serde::ser::SerializeStruct;
10690 let mut len = 0;
10691 if self.id != 0 {
10692 len += 1;
10693 }
10694 if !self.actors.is_empty() {
10695 len += 1;
10696 }
10697 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
10698 if self.id != 0 {
10699 struct_ser.serialize_field("id", &self.id)?;
10700 }
10701 if !self.actors.is_empty() {
10702 struct_ser.serialize_field("actors", &self.actors)?;
10703 }
10704 struct_ser.end()
10705 }
10706}
10707impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
10708 #[allow(deprecated)]
10709 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10710 where
10711 D: serde::Deserializer<'de>,
10712 {
10713 const FIELDS: &[&str] = &[
10714 "id",
10715 "actors",
10716 ];
10717
10718 #[allow(clippy::enum_variant_names)]
10719 enum GeneratedField {
10720 Id,
10721 Actors,
10722 }
10723 impl<'de> serde::Deserialize<'de> for GeneratedField {
10724 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10725 where
10726 D: serde::Deserializer<'de>,
10727 {
10728 struct GeneratedVisitor;
10729
10730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10731 type Value = GeneratedField;
10732
10733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10734 write!(formatter, "expected one of: {:?}", &FIELDS)
10735 }
10736
10737 #[allow(unused_variables)]
10738 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10739 where
10740 E: serde::de::Error,
10741 {
10742 match value {
10743 "id" => Ok(GeneratedField::Id),
10744 "actors" => Ok(GeneratedField::Actors),
10745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10746 }
10747 }
10748 }
10749 deserializer.deserialize_identifier(GeneratedVisitor)
10750 }
10751 }
10752 struct GeneratedVisitor;
10753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10754 type Value = list_table_fragments_response::FragmentInfo;
10755
10756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10757 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
10758 }
10759
10760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
10761 where
10762 V: serde::de::MapAccess<'de>,
10763 {
10764 let mut id__ = None;
10765 let mut actors__ = None;
10766 while let Some(k) = map_.next_key()? {
10767 match k {
10768 GeneratedField::Id => {
10769 if id__.is_some() {
10770 return Err(serde::de::Error::duplicate_field("id"));
10771 }
10772 id__ =
10773 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10774 ;
10775 }
10776 GeneratedField::Actors => {
10777 if actors__.is_some() {
10778 return Err(serde::de::Error::duplicate_field("actors"));
10779 }
10780 actors__ = Some(map_.next_value()?);
10781 }
10782 }
10783 }
10784 Ok(list_table_fragments_response::FragmentInfo {
10785 id: id__.unwrap_or_default(),
10786 actors: actors__.unwrap_or_default(),
10787 })
10788 }
10789 }
10790 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
10791 }
10792}
10793impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
10794 #[allow(deprecated)]
10795 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10796 where
10797 S: serde::Serializer,
10798 {
10799 use serde::ser::SerializeStruct;
10800 let mut len = 0;
10801 if !self.fragments.is_empty() {
10802 len += 1;
10803 }
10804 if self.ctx.is_some() {
10805 len += 1;
10806 }
10807 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
10808 if !self.fragments.is_empty() {
10809 struct_ser.serialize_field("fragments", &self.fragments)?;
10810 }
10811 if let Some(v) = self.ctx.as_ref() {
10812 struct_ser.serialize_field("ctx", v)?;
10813 }
10814 struct_ser.end()
10815 }
10816}
10817impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
10818 #[allow(deprecated)]
10819 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10820 where
10821 D: serde::Deserializer<'de>,
10822 {
10823 const FIELDS: &[&str] = &[
10824 "fragments",
10825 "ctx",
10826 ];
10827
10828 #[allow(clippy::enum_variant_names)]
10829 enum GeneratedField {
10830 Fragments,
10831 Ctx,
10832 }
10833 impl<'de> serde::Deserialize<'de> for GeneratedField {
10834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10835 where
10836 D: serde::Deserializer<'de>,
10837 {
10838 struct GeneratedVisitor;
10839
10840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10841 type Value = GeneratedField;
10842
10843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10844 write!(formatter, "expected one of: {:?}", &FIELDS)
10845 }
10846
10847 #[allow(unused_variables)]
10848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10849 where
10850 E: serde::de::Error,
10851 {
10852 match value {
10853 "fragments" => Ok(GeneratedField::Fragments),
10854 "ctx" => Ok(GeneratedField::Ctx),
10855 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10856 }
10857 }
10858 }
10859 deserializer.deserialize_identifier(GeneratedVisitor)
10860 }
10861 }
10862 struct GeneratedVisitor;
10863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10864 type Value = list_table_fragments_response::TableFragmentInfo;
10865
10866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10867 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
10868 }
10869
10870 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
10871 where
10872 V: serde::de::MapAccess<'de>,
10873 {
10874 let mut fragments__ = None;
10875 let mut ctx__ = None;
10876 while let Some(k) = map_.next_key()? {
10877 match k {
10878 GeneratedField::Fragments => {
10879 if fragments__.is_some() {
10880 return Err(serde::de::Error::duplicate_field("fragments"));
10881 }
10882 fragments__ = Some(map_.next_value()?);
10883 }
10884 GeneratedField::Ctx => {
10885 if ctx__.is_some() {
10886 return Err(serde::de::Error::duplicate_field("ctx"));
10887 }
10888 ctx__ = map_.next_value()?;
10889 }
10890 }
10891 }
10892 Ok(list_table_fragments_response::TableFragmentInfo {
10893 fragments: fragments__.unwrap_or_default(),
10894 ctx: ctx__,
10895 })
10896 }
10897 }
10898 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
10899 }
10900}
10901impl serde::Serialize for MembersRequest {
10902 #[allow(deprecated)]
10903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10904 where
10905 S: serde::Serializer,
10906 {
10907 use serde::ser::SerializeStruct;
10908 let len = 0;
10909 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
10910 struct_ser.end()
10911 }
10912}
10913impl<'de> serde::Deserialize<'de> for MembersRequest {
10914 #[allow(deprecated)]
10915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10916 where
10917 D: serde::Deserializer<'de>,
10918 {
10919 const FIELDS: &[&str] = &[
10920 ];
10921
10922 #[allow(clippy::enum_variant_names)]
10923 enum GeneratedField {
10924 }
10925 impl<'de> serde::Deserialize<'de> for GeneratedField {
10926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10927 where
10928 D: serde::Deserializer<'de>,
10929 {
10930 struct GeneratedVisitor;
10931
10932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10933 type Value = GeneratedField;
10934
10935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10936 write!(formatter, "expected one of: {:?}", &FIELDS)
10937 }
10938
10939 #[allow(unused_variables)]
10940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10941 where
10942 E: serde::de::Error,
10943 {
10944 Err(serde::de::Error::unknown_field(value, FIELDS))
10945 }
10946 }
10947 deserializer.deserialize_identifier(GeneratedVisitor)
10948 }
10949 }
10950 struct GeneratedVisitor;
10951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10952 type Value = MembersRequest;
10953
10954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10955 formatter.write_str("struct meta.MembersRequest")
10956 }
10957
10958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
10959 where
10960 V: serde::de::MapAccess<'de>,
10961 {
10962 while map_.next_key::<GeneratedField>()?.is_some() {
10963 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10964 }
10965 Ok(MembersRequest {
10966 })
10967 }
10968 }
10969 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
10970 }
10971}
10972impl serde::Serialize for MembersResponse {
10973 #[allow(deprecated)]
10974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10975 where
10976 S: serde::Serializer,
10977 {
10978 use serde::ser::SerializeStruct;
10979 let mut len = 0;
10980 if !self.members.is_empty() {
10981 len += 1;
10982 }
10983 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
10984 if !self.members.is_empty() {
10985 struct_ser.serialize_field("members", &self.members)?;
10986 }
10987 struct_ser.end()
10988 }
10989}
10990impl<'de> serde::Deserialize<'de> for MembersResponse {
10991 #[allow(deprecated)]
10992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10993 where
10994 D: serde::Deserializer<'de>,
10995 {
10996 const FIELDS: &[&str] = &[
10997 "members",
10998 ];
10999
11000 #[allow(clippy::enum_variant_names)]
11001 enum GeneratedField {
11002 Members,
11003 }
11004 impl<'de> serde::Deserialize<'de> for GeneratedField {
11005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11006 where
11007 D: serde::Deserializer<'de>,
11008 {
11009 struct GeneratedVisitor;
11010
11011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11012 type Value = GeneratedField;
11013
11014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11015 write!(formatter, "expected one of: {:?}", &FIELDS)
11016 }
11017
11018 #[allow(unused_variables)]
11019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11020 where
11021 E: serde::de::Error,
11022 {
11023 match value {
11024 "members" => Ok(GeneratedField::Members),
11025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11026 }
11027 }
11028 }
11029 deserializer.deserialize_identifier(GeneratedVisitor)
11030 }
11031 }
11032 struct GeneratedVisitor;
11033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11034 type Value = MembersResponse;
11035
11036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11037 formatter.write_str("struct meta.MembersResponse")
11038 }
11039
11040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11041 where
11042 V: serde::de::MapAccess<'de>,
11043 {
11044 let mut members__ = None;
11045 while let Some(k) = map_.next_key()? {
11046 match k {
11047 GeneratedField::Members => {
11048 if members__.is_some() {
11049 return Err(serde::de::Error::duplicate_field("members"));
11050 }
11051 members__ = Some(map_.next_value()?);
11052 }
11053 }
11054 }
11055 Ok(MembersResponse {
11056 members: members__.unwrap_or_default(),
11057 })
11058 }
11059 }
11060 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11061 }
11062}
11063impl serde::Serialize for MetaMember {
11064 #[allow(deprecated)]
11065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11066 where
11067 S: serde::Serializer,
11068 {
11069 use serde::ser::SerializeStruct;
11070 let mut len = 0;
11071 if self.address.is_some() {
11072 len += 1;
11073 }
11074 if self.is_leader {
11075 len += 1;
11076 }
11077 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11078 if let Some(v) = self.address.as_ref() {
11079 struct_ser.serialize_field("address", v)?;
11080 }
11081 if self.is_leader {
11082 struct_ser.serialize_field("isLeader", &self.is_leader)?;
11083 }
11084 struct_ser.end()
11085 }
11086}
11087impl<'de> serde::Deserialize<'de> for MetaMember {
11088 #[allow(deprecated)]
11089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11090 where
11091 D: serde::Deserializer<'de>,
11092 {
11093 const FIELDS: &[&str] = &[
11094 "address",
11095 "is_leader",
11096 "isLeader",
11097 ];
11098
11099 #[allow(clippy::enum_variant_names)]
11100 enum GeneratedField {
11101 Address,
11102 IsLeader,
11103 }
11104 impl<'de> serde::Deserialize<'de> for GeneratedField {
11105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11106 where
11107 D: serde::Deserializer<'de>,
11108 {
11109 struct GeneratedVisitor;
11110
11111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11112 type Value = GeneratedField;
11113
11114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11115 write!(formatter, "expected one of: {:?}", &FIELDS)
11116 }
11117
11118 #[allow(unused_variables)]
11119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11120 where
11121 E: serde::de::Error,
11122 {
11123 match value {
11124 "address" => Ok(GeneratedField::Address),
11125 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11127 }
11128 }
11129 }
11130 deserializer.deserialize_identifier(GeneratedVisitor)
11131 }
11132 }
11133 struct GeneratedVisitor;
11134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11135 type Value = MetaMember;
11136
11137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11138 formatter.write_str("struct meta.MetaMember")
11139 }
11140
11141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11142 where
11143 V: serde::de::MapAccess<'de>,
11144 {
11145 let mut address__ = None;
11146 let mut is_leader__ = None;
11147 while let Some(k) = map_.next_key()? {
11148 match k {
11149 GeneratedField::Address => {
11150 if address__.is_some() {
11151 return Err(serde::de::Error::duplicate_field("address"));
11152 }
11153 address__ = map_.next_value()?;
11154 }
11155 GeneratedField::IsLeader => {
11156 if is_leader__.is_some() {
11157 return Err(serde::de::Error::duplicate_field("isLeader"));
11158 }
11159 is_leader__ = Some(map_.next_value()?);
11160 }
11161 }
11162 }
11163 Ok(MetaMember {
11164 address: address__,
11165 is_leader: is_leader__.unwrap_or_default(),
11166 })
11167 }
11168 }
11169 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11170 }
11171}
11172impl serde::Serialize for MetaSnapshot {
11173 #[allow(deprecated)]
11174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11175 where
11176 S: serde::Serializer,
11177 {
11178 use serde::ser::SerializeStruct;
11179 let mut len = 0;
11180 if !self.databases.is_empty() {
11181 len += 1;
11182 }
11183 if !self.schemas.is_empty() {
11184 len += 1;
11185 }
11186 if !self.sources.is_empty() {
11187 len += 1;
11188 }
11189 if !self.sinks.is_empty() {
11190 len += 1;
11191 }
11192 if !self.tables.is_empty() {
11193 len += 1;
11194 }
11195 if !self.indexes.is_empty() {
11196 len += 1;
11197 }
11198 if !self.views.is_empty() {
11199 len += 1;
11200 }
11201 if !self.functions.is_empty() {
11202 len += 1;
11203 }
11204 if !self.connections.is_empty() {
11205 len += 1;
11206 }
11207 if !self.subscriptions.is_empty() {
11208 len += 1;
11209 }
11210 if !self.users.is_empty() {
11211 len += 1;
11212 }
11213 if self.session_params.is_some() {
11214 len += 1;
11215 }
11216 if !self.secrets.is_empty() {
11217 len += 1;
11218 }
11219 if self.compute_node_total_cpu_count != 0 {
11220 len += 1;
11221 }
11222 if !self.nodes.is_empty() {
11223 len += 1;
11224 }
11225 if self.hummock_version.is_some() {
11226 len += 1;
11227 }
11228 if self.meta_backup_manifest_id.is_some() {
11229 len += 1;
11230 }
11231 if self.hummock_write_limits.is_some() {
11232 len += 1;
11233 }
11234 if !self.streaming_worker_slot_mappings.is_empty() {
11235 len += 1;
11236 }
11237 if !self.serving_worker_slot_mappings.is_empty() {
11238 len += 1;
11239 }
11240 if self.version.is_some() {
11241 len += 1;
11242 }
11243 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11244 if !self.databases.is_empty() {
11245 struct_ser.serialize_field("databases", &self.databases)?;
11246 }
11247 if !self.schemas.is_empty() {
11248 struct_ser.serialize_field("schemas", &self.schemas)?;
11249 }
11250 if !self.sources.is_empty() {
11251 struct_ser.serialize_field("sources", &self.sources)?;
11252 }
11253 if !self.sinks.is_empty() {
11254 struct_ser.serialize_field("sinks", &self.sinks)?;
11255 }
11256 if !self.tables.is_empty() {
11257 struct_ser.serialize_field("tables", &self.tables)?;
11258 }
11259 if !self.indexes.is_empty() {
11260 struct_ser.serialize_field("indexes", &self.indexes)?;
11261 }
11262 if !self.views.is_empty() {
11263 struct_ser.serialize_field("views", &self.views)?;
11264 }
11265 if !self.functions.is_empty() {
11266 struct_ser.serialize_field("functions", &self.functions)?;
11267 }
11268 if !self.connections.is_empty() {
11269 struct_ser.serialize_field("connections", &self.connections)?;
11270 }
11271 if !self.subscriptions.is_empty() {
11272 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11273 }
11274 if !self.users.is_empty() {
11275 struct_ser.serialize_field("users", &self.users)?;
11276 }
11277 if let Some(v) = self.session_params.as_ref() {
11278 struct_ser.serialize_field("sessionParams", v)?;
11279 }
11280 if !self.secrets.is_empty() {
11281 struct_ser.serialize_field("secrets", &self.secrets)?;
11282 }
11283 if self.compute_node_total_cpu_count != 0 {
11284 #[allow(clippy::needless_borrow)]
11285 #[allow(clippy::needless_borrows_for_generic_args)]
11286 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11287 }
11288 if !self.nodes.is_empty() {
11289 struct_ser.serialize_field("nodes", &self.nodes)?;
11290 }
11291 if let Some(v) = self.hummock_version.as_ref() {
11292 struct_ser.serialize_field("hummockVersion", v)?;
11293 }
11294 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11295 struct_ser.serialize_field("metaBackupManifestId", v)?;
11296 }
11297 if let Some(v) = self.hummock_write_limits.as_ref() {
11298 struct_ser.serialize_field("hummockWriteLimits", v)?;
11299 }
11300 if !self.streaming_worker_slot_mappings.is_empty() {
11301 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11302 }
11303 if !self.serving_worker_slot_mappings.is_empty() {
11304 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11305 }
11306 if let Some(v) = self.version.as_ref() {
11307 struct_ser.serialize_field("version", v)?;
11308 }
11309 struct_ser.end()
11310 }
11311}
11312impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11313 #[allow(deprecated)]
11314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11315 where
11316 D: serde::Deserializer<'de>,
11317 {
11318 const FIELDS: &[&str] = &[
11319 "databases",
11320 "schemas",
11321 "sources",
11322 "sinks",
11323 "tables",
11324 "indexes",
11325 "views",
11326 "functions",
11327 "connections",
11328 "subscriptions",
11329 "users",
11330 "session_params",
11331 "sessionParams",
11332 "secrets",
11333 "compute_node_total_cpu_count",
11334 "computeNodeTotalCpuCount",
11335 "nodes",
11336 "hummock_version",
11337 "hummockVersion",
11338 "meta_backup_manifest_id",
11339 "metaBackupManifestId",
11340 "hummock_write_limits",
11341 "hummockWriteLimits",
11342 "streaming_worker_slot_mappings",
11343 "streamingWorkerSlotMappings",
11344 "serving_worker_slot_mappings",
11345 "servingWorkerSlotMappings",
11346 "version",
11347 ];
11348
11349 #[allow(clippy::enum_variant_names)]
11350 enum GeneratedField {
11351 Databases,
11352 Schemas,
11353 Sources,
11354 Sinks,
11355 Tables,
11356 Indexes,
11357 Views,
11358 Functions,
11359 Connections,
11360 Subscriptions,
11361 Users,
11362 SessionParams,
11363 Secrets,
11364 ComputeNodeTotalCpuCount,
11365 Nodes,
11366 HummockVersion,
11367 MetaBackupManifestId,
11368 HummockWriteLimits,
11369 StreamingWorkerSlotMappings,
11370 ServingWorkerSlotMappings,
11371 Version,
11372 }
11373 impl<'de> serde::Deserialize<'de> for GeneratedField {
11374 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11375 where
11376 D: serde::Deserializer<'de>,
11377 {
11378 struct GeneratedVisitor;
11379
11380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11381 type Value = GeneratedField;
11382
11383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11384 write!(formatter, "expected one of: {:?}", &FIELDS)
11385 }
11386
11387 #[allow(unused_variables)]
11388 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11389 where
11390 E: serde::de::Error,
11391 {
11392 match value {
11393 "databases" => Ok(GeneratedField::Databases),
11394 "schemas" => Ok(GeneratedField::Schemas),
11395 "sources" => Ok(GeneratedField::Sources),
11396 "sinks" => Ok(GeneratedField::Sinks),
11397 "tables" => Ok(GeneratedField::Tables),
11398 "indexes" => Ok(GeneratedField::Indexes),
11399 "views" => Ok(GeneratedField::Views),
11400 "functions" => Ok(GeneratedField::Functions),
11401 "connections" => Ok(GeneratedField::Connections),
11402 "subscriptions" => Ok(GeneratedField::Subscriptions),
11403 "users" => Ok(GeneratedField::Users),
11404 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11405 "secrets" => Ok(GeneratedField::Secrets),
11406 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11407 "nodes" => Ok(GeneratedField::Nodes),
11408 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11409 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11410 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11411 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11412 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11413 "version" => Ok(GeneratedField::Version),
11414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11415 }
11416 }
11417 }
11418 deserializer.deserialize_identifier(GeneratedVisitor)
11419 }
11420 }
11421 struct GeneratedVisitor;
11422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11423 type Value = MetaSnapshot;
11424
11425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11426 formatter.write_str("struct meta.MetaSnapshot")
11427 }
11428
11429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11430 where
11431 V: serde::de::MapAccess<'de>,
11432 {
11433 let mut databases__ = None;
11434 let mut schemas__ = None;
11435 let mut sources__ = None;
11436 let mut sinks__ = None;
11437 let mut tables__ = None;
11438 let mut indexes__ = None;
11439 let mut views__ = None;
11440 let mut functions__ = None;
11441 let mut connections__ = None;
11442 let mut subscriptions__ = None;
11443 let mut users__ = None;
11444 let mut session_params__ = None;
11445 let mut secrets__ = None;
11446 let mut compute_node_total_cpu_count__ = None;
11447 let mut nodes__ = None;
11448 let mut hummock_version__ = None;
11449 let mut meta_backup_manifest_id__ = None;
11450 let mut hummock_write_limits__ = None;
11451 let mut streaming_worker_slot_mappings__ = None;
11452 let mut serving_worker_slot_mappings__ = None;
11453 let mut version__ = None;
11454 while let Some(k) = map_.next_key()? {
11455 match k {
11456 GeneratedField::Databases => {
11457 if databases__.is_some() {
11458 return Err(serde::de::Error::duplicate_field("databases"));
11459 }
11460 databases__ = Some(map_.next_value()?);
11461 }
11462 GeneratedField::Schemas => {
11463 if schemas__.is_some() {
11464 return Err(serde::de::Error::duplicate_field("schemas"));
11465 }
11466 schemas__ = Some(map_.next_value()?);
11467 }
11468 GeneratedField::Sources => {
11469 if sources__.is_some() {
11470 return Err(serde::de::Error::duplicate_field("sources"));
11471 }
11472 sources__ = Some(map_.next_value()?);
11473 }
11474 GeneratedField::Sinks => {
11475 if sinks__.is_some() {
11476 return Err(serde::de::Error::duplicate_field("sinks"));
11477 }
11478 sinks__ = Some(map_.next_value()?);
11479 }
11480 GeneratedField::Tables => {
11481 if tables__.is_some() {
11482 return Err(serde::de::Error::duplicate_field("tables"));
11483 }
11484 tables__ = Some(map_.next_value()?);
11485 }
11486 GeneratedField::Indexes => {
11487 if indexes__.is_some() {
11488 return Err(serde::de::Error::duplicate_field("indexes"));
11489 }
11490 indexes__ = Some(map_.next_value()?);
11491 }
11492 GeneratedField::Views => {
11493 if views__.is_some() {
11494 return Err(serde::de::Error::duplicate_field("views"));
11495 }
11496 views__ = Some(map_.next_value()?);
11497 }
11498 GeneratedField::Functions => {
11499 if functions__.is_some() {
11500 return Err(serde::de::Error::duplicate_field("functions"));
11501 }
11502 functions__ = Some(map_.next_value()?);
11503 }
11504 GeneratedField::Connections => {
11505 if connections__.is_some() {
11506 return Err(serde::de::Error::duplicate_field("connections"));
11507 }
11508 connections__ = Some(map_.next_value()?);
11509 }
11510 GeneratedField::Subscriptions => {
11511 if subscriptions__.is_some() {
11512 return Err(serde::de::Error::duplicate_field("subscriptions"));
11513 }
11514 subscriptions__ = Some(map_.next_value()?);
11515 }
11516 GeneratedField::Users => {
11517 if users__.is_some() {
11518 return Err(serde::de::Error::duplicate_field("users"));
11519 }
11520 users__ = Some(map_.next_value()?);
11521 }
11522 GeneratedField::SessionParams => {
11523 if session_params__.is_some() {
11524 return Err(serde::de::Error::duplicate_field("sessionParams"));
11525 }
11526 session_params__ = map_.next_value()?;
11527 }
11528 GeneratedField::Secrets => {
11529 if secrets__.is_some() {
11530 return Err(serde::de::Error::duplicate_field("secrets"));
11531 }
11532 secrets__ = Some(map_.next_value()?);
11533 }
11534 GeneratedField::ComputeNodeTotalCpuCount => {
11535 if compute_node_total_cpu_count__.is_some() {
11536 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
11537 }
11538 compute_node_total_cpu_count__ =
11539 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11540 ;
11541 }
11542 GeneratedField::Nodes => {
11543 if nodes__.is_some() {
11544 return Err(serde::de::Error::duplicate_field("nodes"));
11545 }
11546 nodes__ = Some(map_.next_value()?);
11547 }
11548 GeneratedField::HummockVersion => {
11549 if hummock_version__.is_some() {
11550 return Err(serde::de::Error::duplicate_field("hummockVersion"));
11551 }
11552 hummock_version__ = map_.next_value()?;
11553 }
11554 GeneratedField::MetaBackupManifestId => {
11555 if meta_backup_manifest_id__.is_some() {
11556 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
11557 }
11558 meta_backup_manifest_id__ = map_.next_value()?;
11559 }
11560 GeneratedField::HummockWriteLimits => {
11561 if hummock_write_limits__.is_some() {
11562 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
11563 }
11564 hummock_write_limits__ = map_.next_value()?;
11565 }
11566 GeneratedField::StreamingWorkerSlotMappings => {
11567 if streaming_worker_slot_mappings__.is_some() {
11568 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
11569 }
11570 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
11571 }
11572 GeneratedField::ServingWorkerSlotMappings => {
11573 if serving_worker_slot_mappings__.is_some() {
11574 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
11575 }
11576 serving_worker_slot_mappings__ = Some(map_.next_value()?);
11577 }
11578 GeneratedField::Version => {
11579 if version__.is_some() {
11580 return Err(serde::de::Error::duplicate_field("version"));
11581 }
11582 version__ = map_.next_value()?;
11583 }
11584 }
11585 }
11586 Ok(MetaSnapshot {
11587 databases: databases__.unwrap_or_default(),
11588 schemas: schemas__.unwrap_or_default(),
11589 sources: sources__.unwrap_or_default(),
11590 sinks: sinks__.unwrap_or_default(),
11591 tables: tables__.unwrap_or_default(),
11592 indexes: indexes__.unwrap_or_default(),
11593 views: views__.unwrap_or_default(),
11594 functions: functions__.unwrap_or_default(),
11595 connections: connections__.unwrap_or_default(),
11596 subscriptions: subscriptions__.unwrap_or_default(),
11597 users: users__.unwrap_or_default(),
11598 session_params: session_params__,
11599 secrets: secrets__.unwrap_or_default(),
11600 compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
11601 nodes: nodes__.unwrap_or_default(),
11602 hummock_version: hummock_version__,
11603 meta_backup_manifest_id: meta_backup_manifest_id__,
11604 hummock_write_limits: hummock_write_limits__,
11605 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
11606 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
11607 version: version__,
11608 })
11609 }
11610 }
11611 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
11612 }
11613}
11614impl serde::Serialize for meta_snapshot::SnapshotVersion {
11615 #[allow(deprecated)]
11616 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11617 where
11618 S: serde::Serializer,
11619 {
11620 use serde::ser::SerializeStruct;
11621 let mut len = 0;
11622 if self.catalog_version != 0 {
11623 len += 1;
11624 }
11625 if self.worker_node_version != 0 {
11626 len += 1;
11627 }
11628 if self.streaming_worker_slot_mapping_version != 0 {
11629 len += 1;
11630 }
11631 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
11632 if self.catalog_version != 0 {
11633 #[allow(clippy::needless_borrow)]
11634 #[allow(clippy::needless_borrows_for_generic_args)]
11635 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11636 }
11637 if self.worker_node_version != 0 {
11638 #[allow(clippy::needless_borrow)]
11639 #[allow(clippy::needless_borrows_for_generic_args)]
11640 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
11641 }
11642 if self.streaming_worker_slot_mapping_version != 0 {
11643 #[allow(clippy::needless_borrow)]
11644 #[allow(clippy::needless_borrows_for_generic_args)]
11645 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
11646 }
11647 struct_ser.end()
11648 }
11649}
11650impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
11651 #[allow(deprecated)]
11652 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11653 where
11654 D: serde::Deserializer<'de>,
11655 {
11656 const FIELDS: &[&str] = &[
11657 "catalog_version",
11658 "catalogVersion",
11659 "worker_node_version",
11660 "workerNodeVersion",
11661 "streaming_worker_slot_mapping_version",
11662 "streamingWorkerSlotMappingVersion",
11663 ];
11664
11665 #[allow(clippy::enum_variant_names)]
11666 enum GeneratedField {
11667 CatalogVersion,
11668 WorkerNodeVersion,
11669 StreamingWorkerSlotMappingVersion,
11670 }
11671 impl<'de> serde::Deserialize<'de> for GeneratedField {
11672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11673 where
11674 D: serde::Deserializer<'de>,
11675 {
11676 struct GeneratedVisitor;
11677
11678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11679 type Value = GeneratedField;
11680
11681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11682 write!(formatter, "expected one of: {:?}", &FIELDS)
11683 }
11684
11685 #[allow(unused_variables)]
11686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11687 where
11688 E: serde::de::Error,
11689 {
11690 match value {
11691 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
11692 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
11693 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
11694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11695 }
11696 }
11697 }
11698 deserializer.deserialize_identifier(GeneratedVisitor)
11699 }
11700 }
11701 struct GeneratedVisitor;
11702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11703 type Value = meta_snapshot::SnapshotVersion;
11704
11705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11706 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
11707 }
11708
11709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
11710 where
11711 V: serde::de::MapAccess<'de>,
11712 {
11713 let mut catalog_version__ = None;
11714 let mut worker_node_version__ = None;
11715 let mut streaming_worker_slot_mapping_version__ = None;
11716 while let Some(k) = map_.next_key()? {
11717 match k {
11718 GeneratedField::CatalogVersion => {
11719 if catalog_version__.is_some() {
11720 return Err(serde::de::Error::duplicate_field("catalogVersion"));
11721 }
11722 catalog_version__ =
11723 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11724 ;
11725 }
11726 GeneratedField::WorkerNodeVersion => {
11727 if worker_node_version__.is_some() {
11728 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
11729 }
11730 worker_node_version__ =
11731 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11732 ;
11733 }
11734 GeneratedField::StreamingWorkerSlotMappingVersion => {
11735 if streaming_worker_slot_mapping_version__.is_some() {
11736 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
11737 }
11738 streaming_worker_slot_mapping_version__ =
11739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11740 ;
11741 }
11742 }
11743 }
11744 Ok(meta_snapshot::SnapshotVersion {
11745 catalog_version: catalog_version__.unwrap_or_default(),
11746 worker_node_version: worker_node_version__.unwrap_or_default(),
11747 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
11748 })
11749 }
11750 }
11751 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
11752 }
11753}
11754impl serde::Serialize for MigrationPlan {
11755 #[allow(deprecated)]
11756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11757 where
11758 S: serde::Serializer,
11759 {
11760 use serde::ser::SerializeStruct;
11761 let mut len = 0;
11762 if !self.worker_slot_migration_plan.is_empty() {
11763 len += 1;
11764 }
11765 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
11766 if !self.worker_slot_migration_plan.is_empty() {
11767 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
11768 .map(|(k, v)| (k, v.to_string())).collect();
11769 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
11770 }
11771 struct_ser.end()
11772 }
11773}
11774impl<'de> serde::Deserialize<'de> for MigrationPlan {
11775 #[allow(deprecated)]
11776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11777 where
11778 D: serde::Deserializer<'de>,
11779 {
11780 const FIELDS: &[&str] = &[
11781 "worker_slot_migration_plan",
11782 "workerSlotMigrationPlan",
11783 ];
11784
11785 #[allow(clippy::enum_variant_names)]
11786 enum GeneratedField {
11787 WorkerSlotMigrationPlan,
11788 }
11789 impl<'de> serde::Deserialize<'de> for GeneratedField {
11790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11791 where
11792 D: serde::Deserializer<'de>,
11793 {
11794 struct GeneratedVisitor;
11795
11796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11797 type Value = GeneratedField;
11798
11799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11800 write!(formatter, "expected one of: {:?}", &FIELDS)
11801 }
11802
11803 #[allow(unused_variables)]
11804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11805 where
11806 E: serde::de::Error,
11807 {
11808 match value {
11809 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
11810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11811 }
11812 }
11813 }
11814 deserializer.deserialize_identifier(GeneratedVisitor)
11815 }
11816 }
11817 struct GeneratedVisitor;
11818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11819 type Value = MigrationPlan;
11820
11821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11822 formatter.write_str("struct meta.MigrationPlan")
11823 }
11824
11825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
11826 where
11827 V: serde::de::MapAccess<'de>,
11828 {
11829 let mut worker_slot_migration_plan__ = None;
11830 while let Some(k) = map_.next_key()? {
11831 match k {
11832 GeneratedField::WorkerSlotMigrationPlan => {
11833 if worker_slot_migration_plan__.is_some() {
11834 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
11835 }
11836 worker_slot_migration_plan__ = Some(
11837 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11838 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
11839 );
11840 }
11841 }
11842 }
11843 Ok(MigrationPlan {
11844 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
11845 })
11846 }
11847 }
11848 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
11849 }
11850}
11851impl serde::Serialize for Object {
11852 #[allow(deprecated)]
11853 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11854 where
11855 S: serde::Serializer,
11856 {
11857 use serde::ser::SerializeStruct;
11858 let mut len = 0;
11859 if self.object_info.is_some() {
11860 len += 1;
11861 }
11862 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
11863 if let Some(v) = self.object_info.as_ref() {
11864 match v {
11865 object::ObjectInfo::Database(v) => {
11866 struct_ser.serialize_field("database", v)?;
11867 }
11868 object::ObjectInfo::Schema(v) => {
11869 struct_ser.serialize_field("schema", v)?;
11870 }
11871 object::ObjectInfo::Table(v) => {
11872 struct_ser.serialize_field("table", v)?;
11873 }
11874 object::ObjectInfo::Index(v) => {
11875 struct_ser.serialize_field("index", v)?;
11876 }
11877 object::ObjectInfo::Source(v) => {
11878 struct_ser.serialize_field("source", v)?;
11879 }
11880 object::ObjectInfo::Sink(v) => {
11881 struct_ser.serialize_field("sink", v)?;
11882 }
11883 object::ObjectInfo::View(v) => {
11884 struct_ser.serialize_field("view", v)?;
11885 }
11886 object::ObjectInfo::Function(v) => {
11887 struct_ser.serialize_field("function", v)?;
11888 }
11889 object::ObjectInfo::Connection(v) => {
11890 struct_ser.serialize_field("connection", v)?;
11891 }
11892 object::ObjectInfo::Subscription(v) => {
11893 struct_ser.serialize_field("subscription", v)?;
11894 }
11895 object::ObjectInfo::Secret(v) => {
11896 struct_ser.serialize_field("secret", v)?;
11897 }
11898 }
11899 }
11900 struct_ser.end()
11901 }
11902}
11903impl<'de> serde::Deserialize<'de> for Object {
11904 #[allow(deprecated)]
11905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11906 where
11907 D: serde::Deserializer<'de>,
11908 {
11909 const FIELDS: &[&str] = &[
11910 "database",
11911 "schema",
11912 "table",
11913 "index",
11914 "source",
11915 "sink",
11916 "view",
11917 "function",
11918 "connection",
11919 "subscription",
11920 "secret",
11921 ];
11922
11923 #[allow(clippy::enum_variant_names)]
11924 enum GeneratedField {
11925 Database,
11926 Schema,
11927 Table,
11928 Index,
11929 Source,
11930 Sink,
11931 View,
11932 Function,
11933 Connection,
11934 Subscription,
11935 Secret,
11936 }
11937 impl<'de> serde::Deserialize<'de> for GeneratedField {
11938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11939 where
11940 D: serde::Deserializer<'de>,
11941 {
11942 struct GeneratedVisitor;
11943
11944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11945 type Value = GeneratedField;
11946
11947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11948 write!(formatter, "expected one of: {:?}", &FIELDS)
11949 }
11950
11951 #[allow(unused_variables)]
11952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11953 where
11954 E: serde::de::Error,
11955 {
11956 match value {
11957 "database" => Ok(GeneratedField::Database),
11958 "schema" => Ok(GeneratedField::Schema),
11959 "table" => Ok(GeneratedField::Table),
11960 "index" => Ok(GeneratedField::Index),
11961 "source" => Ok(GeneratedField::Source),
11962 "sink" => Ok(GeneratedField::Sink),
11963 "view" => Ok(GeneratedField::View),
11964 "function" => Ok(GeneratedField::Function),
11965 "connection" => Ok(GeneratedField::Connection),
11966 "subscription" => Ok(GeneratedField::Subscription),
11967 "secret" => Ok(GeneratedField::Secret),
11968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11969 }
11970 }
11971 }
11972 deserializer.deserialize_identifier(GeneratedVisitor)
11973 }
11974 }
11975 struct GeneratedVisitor;
11976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11977 type Value = Object;
11978
11979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11980 formatter.write_str("struct meta.Object")
11981 }
11982
11983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
11984 where
11985 V: serde::de::MapAccess<'de>,
11986 {
11987 let mut object_info__ = None;
11988 while let Some(k) = map_.next_key()? {
11989 match k {
11990 GeneratedField::Database => {
11991 if object_info__.is_some() {
11992 return Err(serde::de::Error::duplicate_field("database"));
11993 }
11994 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
11995;
11996 }
11997 GeneratedField::Schema => {
11998 if object_info__.is_some() {
11999 return Err(serde::de::Error::duplicate_field("schema"));
12000 }
12001 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12002;
12003 }
12004 GeneratedField::Table => {
12005 if object_info__.is_some() {
12006 return Err(serde::de::Error::duplicate_field("table"));
12007 }
12008 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12009;
12010 }
12011 GeneratedField::Index => {
12012 if object_info__.is_some() {
12013 return Err(serde::de::Error::duplicate_field("index"));
12014 }
12015 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12016;
12017 }
12018 GeneratedField::Source => {
12019 if object_info__.is_some() {
12020 return Err(serde::de::Error::duplicate_field("source"));
12021 }
12022 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12023;
12024 }
12025 GeneratedField::Sink => {
12026 if object_info__.is_some() {
12027 return Err(serde::de::Error::duplicate_field("sink"));
12028 }
12029 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12030;
12031 }
12032 GeneratedField::View => {
12033 if object_info__.is_some() {
12034 return Err(serde::de::Error::duplicate_field("view"));
12035 }
12036 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12037;
12038 }
12039 GeneratedField::Function => {
12040 if object_info__.is_some() {
12041 return Err(serde::de::Error::duplicate_field("function"));
12042 }
12043 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12044;
12045 }
12046 GeneratedField::Connection => {
12047 if object_info__.is_some() {
12048 return Err(serde::de::Error::duplicate_field("connection"));
12049 }
12050 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12051;
12052 }
12053 GeneratedField::Subscription => {
12054 if object_info__.is_some() {
12055 return Err(serde::de::Error::duplicate_field("subscription"));
12056 }
12057 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12058;
12059 }
12060 GeneratedField::Secret => {
12061 if object_info__.is_some() {
12062 return Err(serde::de::Error::duplicate_field("secret"));
12063 }
12064 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12065;
12066 }
12067 }
12068 }
12069 Ok(Object {
12070 object_info: object_info__,
12071 })
12072 }
12073 }
12074 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12075 }
12076}
12077impl serde::Serialize for ObjectGroup {
12078 #[allow(deprecated)]
12079 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12080 where
12081 S: serde::Serializer,
12082 {
12083 use serde::ser::SerializeStruct;
12084 let mut len = 0;
12085 if !self.objects.is_empty() {
12086 len += 1;
12087 }
12088 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12089 if !self.objects.is_empty() {
12090 struct_ser.serialize_field("objects", &self.objects)?;
12091 }
12092 struct_ser.end()
12093 }
12094}
12095impl<'de> serde::Deserialize<'de> for ObjectGroup {
12096 #[allow(deprecated)]
12097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12098 where
12099 D: serde::Deserializer<'de>,
12100 {
12101 const FIELDS: &[&str] = &[
12102 "objects",
12103 ];
12104
12105 #[allow(clippy::enum_variant_names)]
12106 enum GeneratedField {
12107 Objects,
12108 }
12109 impl<'de> serde::Deserialize<'de> for GeneratedField {
12110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12111 where
12112 D: serde::Deserializer<'de>,
12113 {
12114 struct GeneratedVisitor;
12115
12116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12117 type Value = GeneratedField;
12118
12119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12120 write!(formatter, "expected one of: {:?}", &FIELDS)
12121 }
12122
12123 #[allow(unused_variables)]
12124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12125 where
12126 E: serde::de::Error,
12127 {
12128 match value {
12129 "objects" => Ok(GeneratedField::Objects),
12130 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12131 }
12132 }
12133 }
12134 deserializer.deserialize_identifier(GeneratedVisitor)
12135 }
12136 }
12137 struct GeneratedVisitor;
12138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12139 type Value = ObjectGroup;
12140
12141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12142 formatter.write_str("struct meta.ObjectGroup")
12143 }
12144
12145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12146 where
12147 V: serde::de::MapAccess<'de>,
12148 {
12149 let mut objects__ = None;
12150 while let Some(k) = map_.next_key()? {
12151 match k {
12152 GeneratedField::Objects => {
12153 if objects__.is_some() {
12154 return Err(serde::de::Error::duplicate_field("objects"));
12155 }
12156 objects__ = Some(map_.next_value()?);
12157 }
12158 }
12159 }
12160 Ok(ObjectGroup {
12161 objects: objects__.unwrap_or_default(),
12162 })
12163 }
12164 }
12165 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12166 }
12167}
12168impl serde::Serialize for PauseRequest {
12169 #[allow(deprecated)]
12170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12171 where
12172 S: serde::Serializer,
12173 {
12174 use serde::ser::SerializeStruct;
12175 let len = 0;
12176 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12177 struct_ser.end()
12178 }
12179}
12180impl<'de> serde::Deserialize<'de> for PauseRequest {
12181 #[allow(deprecated)]
12182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12183 where
12184 D: serde::Deserializer<'de>,
12185 {
12186 const FIELDS: &[&str] = &[
12187 ];
12188
12189 #[allow(clippy::enum_variant_names)]
12190 enum GeneratedField {
12191 }
12192 impl<'de> serde::Deserialize<'de> for GeneratedField {
12193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12194 where
12195 D: serde::Deserializer<'de>,
12196 {
12197 struct GeneratedVisitor;
12198
12199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12200 type Value = GeneratedField;
12201
12202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12203 write!(formatter, "expected one of: {:?}", &FIELDS)
12204 }
12205
12206 #[allow(unused_variables)]
12207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12208 where
12209 E: serde::de::Error,
12210 {
12211 Err(serde::de::Error::unknown_field(value, FIELDS))
12212 }
12213 }
12214 deserializer.deserialize_identifier(GeneratedVisitor)
12215 }
12216 }
12217 struct GeneratedVisitor;
12218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12219 type Value = PauseRequest;
12220
12221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12222 formatter.write_str("struct meta.PauseRequest")
12223 }
12224
12225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12226 where
12227 V: serde::de::MapAccess<'de>,
12228 {
12229 while map_.next_key::<GeneratedField>()?.is_some() {
12230 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12231 }
12232 Ok(PauseRequest {
12233 })
12234 }
12235 }
12236 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12237 }
12238}
12239impl serde::Serialize for PauseResponse {
12240 #[allow(deprecated)]
12241 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12242 where
12243 S: serde::Serializer,
12244 {
12245 use serde::ser::SerializeStruct;
12246 let len = 0;
12247 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12248 struct_ser.end()
12249 }
12250}
12251impl<'de> serde::Deserialize<'de> for PauseResponse {
12252 #[allow(deprecated)]
12253 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12254 where
12255 D: serde::Deserializer<'de>,
12256 {
12257 const FIELDS: &[&str] = &[
12258 ];
12259
12260 #[allow(clippy::enum_variant_names)]
12261 enum GeneratedField {
12262 }
12263 impl<'de> serde::Deserialize<'de> for GeneratedField {
12264 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12265 where
12266 D: serde::Deserializer<'de>,
12267 {
12268 struct GeneratedVisitor;
12269
12270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12271 type Value = GeneratedField;
12272
12273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12274 write!(formatter, "expected one of: {:?}", &FIELDS)
12275 }
12276
12277 #[allow(unused_variables)]
12278 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12279 where
12280 E: serde::de::Error,
12281 {
12282 Err(serde::de::Error::unknown_field(value, FIELDS))
12283 }
12284 }
12285 deserializer.deserialize_identifier(GeneratedVisitor)
12286 }
12287 }
12288 struct GeneratedVisitor;
12289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12290 type Value = PauseResponse;
12291
12292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12293 formatter.write_str("struct meta.PauseResponse")
12294 }
12295
12296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12297 where
12298 V: serde::de::MapAccess<'de>,
12299 {
12300 while map_.next_key::<GeneratedField>()?.is_some() {
12301 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12302 }
12303 Ok(PauseResponse {
12304 })
12305 }
12306 }
12307 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12308 }
12309}
12310impl serde::Serialize for RecoverRequest {
12311 #[allow(deprecated)]
12312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12313 where
12314 S: serde::Serializer,
12315 {
12316 use serde::ser::SerializeStruct;
12317 let len = 0;
12318 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12319 struct_ser.end()
12320 }
12321}
12322impl<'de> serde::Deserialize<'de> for RecoverRequest {
12323 #[allow(deprecated)]
12324 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12325 where
12326 D: serde::Deserializer<'de>,
12327 {
12328 const FIELDS: &[&str] = &[
12329 ];
12330
12331 #[allow(clippy::enum_variant_names)]
12332 enum GeneratedField {
12333 }
12334 impl<'de> serde::Deserialize<'de> for GeneratedField {
12335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12336 where
12337 D: serde::Deserializer<'de>,
12338 {
12339 struct GeneratedVisitor;
12340
12341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12342 type Value = GeneratedField;
12343
12344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12345 write!(formatter, "expected one of: {:?}", &FIELDS)
12346 }
12347
12348 #[allow(unused_variables)]
12349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12350 where
12351 E: serde::de::Error,
12352 {
12353 Err(serde::de::Error::unknown_field(value, FIELDS))
12354 }
12355 }
12356 deserializer.deserialize_identifier(GeneratedVisitor)
12357 }
12358 }
12359 struct GeneratedVisitor;
12360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12361 type Value = RecoverRequest;
12362
12363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12364 formatter.write_str("struct meta.RecoverRequest")
12365 }
12366
12367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12368 where
12369 V: serde::de::MapAccess<'de>,
12370 {
12371 while map_.next_key::<GeneratedField>()?.is_some() {
12372 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12373 }
12374 Ok(RecoverRequest {
12375 })
12376 }
12377 }
12378 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12379 }
12380}
12381impl serde::Serialize for RecoverResponse {
12382 #[allow(deprecated)]
12383 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12384 where
12385 S: serde::Serializer,
12386 {
12387 use serde::ser::SerializeStruct;
12388 let len = 0;
12389 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12390 struct_ser.end()
12391 }
12392}
12393impl<'de> serde::Deserialize<'de> for RecoverResponse {
12394 #[allow(deprecated)]
12395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12396 where
12397 D: serde::Deserializer<'de>,
12398 {
12399 const FIELDS: &[&str] = &[
12400 ];
12401
12402 #[allow(clippy::enum_variant_names)]
12403 enum GeneratedField {
12404 }
12405 impl<'de> serde::Deserialize<'de> for GeneratedField {
12406 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12407 where
12408 D: serde::Deserializer<'de>,
12409 {
12410 struct GeneratedVisitor;
12411
12412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12413 type Value = GeneratedField;
12414
12415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12416 write!(formatter, "expected one of: {:?}", &FIELDS)
12417 }
12418
12419 #[allow(unused_variables)]
12420 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12421 where
12422 E: serde::de::Error,
12423 {
12424 Err(serde::de::Error::unknown_field(value, FIELDS))
12425 }
12426 }
12427 deserializer.deserialize_identifier(GeneratedVisitor)
12428 }
12429 }
12430 struct GeneratedVisitor;
12431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12432 type Value = RecoverResponse;
12433
12434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12435 formatter.write_str("struct meta.RecoverResponse")
12436 }
12437
12438 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12439 where
12440 V: serde::de::MapAccess<'de>,
12441 {
12442 while map_.next_key::<GeneratedField>()?.is_some() {
12443 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12444 }
12445 Ok(RecoverResponse {
12446 })
12447 }
12448 }
12449 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12450 }
12451}
12452impl serde::Serialize for Recovery {
12453 #[allow(deprecated)]
12454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12455 where
12456 S: serde::Serializer,
12457 {
12458 use serde::ser::SerializeStruct;
12459 let len = 0;
12460 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12461 struct_ser.end()
12462 }
12463}
12464impl<'de> serde::Deserialize<'de> for Recovery {
12465 #[allow(deprecated)]
12466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12467 where
12468 D: serde::Deserializer<'de>,
12469 {
12470 const FIELDS: &[&str] = &[
12471 ];
12472
12473 #[allow(clippy::enum_variant_names)]
12474 enum GeneratedField {
12475 }
12476 impl<'de> serde::Deserialize<'de> for GeneratedField {
12477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12478 where
12479 D: serde::Deserializer<'de>,
12480 {
12481 struct GeneratedVisitor;
12482
12483 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12484 type Value = GeneratedField;
12485
12486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12487 write!(formatter, "expected one of: {:?}", &FIELDS)
12488 }
12489
12490 #[allow(unused_variables)]
12491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12492 where
12493 E: serde::de::Error,
12494 {
12495 Err(serde::de::Error::unknown_field(value, FIELDS))
12496 }
12497 }
12498 deserializer.deserialize_identifier(GeneratedVisitor)
12499 }
12500 }
12501 struct GeneratedVisitor;
12502 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12503 type Value = Recovery;
12504
12505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12506 formatter.write_str("struct meta.Recovery")
12507 }
12508
12509 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
12510 where
12511 V: serde::de::MapAccess<'de>,
12512 {
12513 while map_.next_key::<GeneratedField>()?.is_some() {
12514 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12515 }
12516 Ok(Recovery {
12517 })
12518 }
12519 }
12520 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
12521 }
12522}
12523impl serde::Serialize for RecoveryStatus {
12524 #[allow(deprecated)]
12525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12526 where
12527 S: serde::Serializer,
12528 {
12529 let variant = match self {
12530 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
12531 Self::StatusStarting => "STATUS_STARTING",
12532 Self::StatusRecovering => "STATUS_RECOVERING",
12533 Self::StatusRunning => "STATUS_RUNNING",
12534 };
12535 serializer.serialize_str(variant)
12536 }
12537}
12538impl<'de> serde::Deserialize<'de> for RecoveryStatus {
12539 #[allow(deprecated)]
12540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12541 where
12542 D: serde::Deserializer<'de>,
12543 {
12544 const FIELDS: &[&str] = &[
12545 "STATUS_UNSPECIFIED",
12546 "STATUS_STARTING",
12547 "STATUS_RECOVERING",
12548 "STATUS_RUNNING",
12549 ];
12550
12551 struct GeneratedVisitor;
12552
12553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12554 type Value = RecoveryStatus;
12555
12556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12557 write!(formatter, "expected one of: {:?}", &FIELDS)
12558 }
12559
12560 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12561 where
12562 E: serde::de::Error,
12563 {
12564 i32::try_from(v)
12565 .ok()
12566 .and_then(|x| x.try_into().ok())
12567 .ok_or_else(|| {
12568 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12569 })
12570 }
12571
12572 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12573 where
12574 E: serde::de::Error,
12575 {
12576 i32::try_from(v)
12577 .ok()
12578 .and_then(|x| x.try_into().ok())
12579 .ok_or_else(|| {
12580 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12581 })
12582 }
12583
12584 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12585 where
12586 E: serde::de::Error,
12587 {
12588 match value {
12589 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
12590 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
12591 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
12592 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
12593 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12594 }
12595 }
12596 }
12597 deserializer.deserialize_any(GeneratedVisitor)
12598 }
12599}
12600impl serde::Serialize for RelationIdInfos {
12601 #[allow(deprecated)]
12602 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12603 where
12604 S: serde::Serializer,
12605 {
12606 use serde::ser::SerializeStruct;
12607 let mut len = 0;
12608 if !self.map.is_empty() {
12609 len += 1;
12610 }
12611 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
12612 if !self.map.is_empty() {
12613 struct_ser.serialize_field("map", &self.map)?;
12614 }
12615 struct_ser.end()
12616 }
12617}
12618impl<'de> serde::Deserialize<'de> for RelationIdInfos {
12619 #[allow(deprecated)]
12620 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12621 where
12622 D: serde::Deserializer<'de>,
12623 {
12624 const FIELDS: &[&str] = &[
12625 "map",
12626 ];
12627
12628 #[allow(clippy::enum_variant_names)]
12629 enum GeneratedField {
12630 Map,
12631 }
12632 impl<'de> serde::Deserialize<'de> for GeneratedField {
12633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12634 where
12635 D: serde::Deserializer<'de>,
12636 {
12637 struct GeneratedVisitor;
12638
12639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12640 type Value = GeneratedField;
12641
12642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12643 write!(formatter, "expected one of: {:?}", &FIELDS)
12644 }
12645
12646 #[allow(unused_variables)]
12647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12648 where
12649 E: serde::de::Error,
12650 {
12651 match value {
12652 "map" => Ok(GeneratedField::Map),
12653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12654 }
12655 }
12656 }
12657 deserializer.deserialize_identifier(GeneratedVisitor)
12658 }
12659 }
12660 struct GeneratedVisitor;
12661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12662 type Value = RelationIdInfos;
12663
12664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12665 formatter.write_str("struct meta.RelationIdInfos")
12666 }
12667
12668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
12669 where
12670 V: serde::de::MapAccess<'de>,
12671 {
12672 let mut map__ = None;
12673 while let Some(k) = map_.next_key()? {
12674 match k {
12675 GeneratedField::Map => {
12676 if map__.is_some() {
12677 return Err(serde::de::Error::duplicate_field("map"));
12678 }
12679 map__ = Some(
12680 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12681 .into_iter().map(|(k,v)| (k.0, v)).collect()
12682 );
12683 }
12684 }
12685 }
12686 Ok(RelationIdInfos {
12687 map: map__.unwrap_or_default(),
12688 })
12689 }
12690 }
12691 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
12692 }
12693}
12694impl serde::Serialize for RescheduleRequest {
12695 #[allow(deprecated)]
12696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12697 where
12698 S: serde::Serializer,
12699 {
12700 use serde::ser::SerializeStruct;
12701 let mut len = 0;
12702 if self.revision != 0 {
12703 len += 1;
12704 }
12705 if self.resolve_no_shuffle_upstream {
12706 len += 1;
12707 }
12708 if !self.worker_reschedules.is_empty() {
12709 len += 1;
12710 }
12711 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
12712 if self.revision != 0 {
12713 #[allow(clippy::needless_borrow)]
12714 #[allow(clippy::needless_borrows_for_generic_args)]
12715 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
12716 }
12717 if self.resolve_no_shuffle_upstream {
12718 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
12719 }
12720 if !self.worker_reschedules.is_empty() {
12721 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
12722 }
12723 struct_ser.end()
12724 }
12725}
12726impl<'de> serde::Deserialize<'de> for RescheduleRequest {
12727 #[allow(deprecated)]
12728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12729 where
12730 D: serde::Deserializer<'de>,
12731 {
12732 const FIELDS: &[&str] = &[
12733 "revision",
12734 "resolve_no_shuffle_upstream",
12735 "resolveNoShuffleUpstream",
12736 "worker_reschedules",
12737 "workerReschedules",
12738 ];
12739
12740 #[allow(clippy::enum_variant_names)]
12741 enum GeneratedField {
12742 Revision,
12743 ResolveNoShuffleUpstream,
12744 WorkerReschedules,
12745 }
12746 impl<'de> serde::Deserialize<'de> for GeneratedField {
12747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12748 where
12749 D: serde::Deserializer<'de>,
12750 {
12751 struct GeneratedVisitor;
12752
12753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12754 type Value = GeneratedField;
12755
12756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12757 write!(formatter, "expected one of: {:?}", &FIELDS)
12758 }
12759
12760 #[allow(unused_variables)]
12761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12762 where
12763 E: serde::de::Error,
12764 {
12765 match value {
12766 "revision" => Ok(GeneratedField::Revision),
12767 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
12768 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
12769 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12770 }
12771 }
12772 }
12773 deserializer.deserialize_identifier(GeneratedVisitor)
12774 }
12775 }
12776 struct GeneratedVisitor;
12777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12778 type Value = RescheduleRequest;
12779
12780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12781 formatter.write_str("struct meta.RescheduleRequest")
12782 }
12783
12784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
12785 where
12786 V: serde::de::MapAccess<'de>,
12787 {
12788 let mut revision__ = None;
12789 let mut resolve_no_shuffle_upstream__ = None;
12790 let mut worker_reschedules__ = None;
12791 while let Some(k) = map_.next_key()? {
12792 match k {
12793 GeneratedField::Revision => {
12794 if revision__.is_some() {
12795 return Err(serde::de::Error::duplicate_field("revision"));
12796 }
12797 revision__ =
12798 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12799 ;
12800 }
12801 GeneratedField::ResolveNoShuffleUpstream => {
12802 if resolve_no_shuffle_upstream__.is_some() {
12803 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
12804 }
12805 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
12806 }
12807 GeneratedField::WorkerReschedules => {
12808 if worker_reschedules__.is_some() {
12809 return Err(serde::de::Error::duplicate_field("workerReschedules"));
12810 }
12811 worker_reschedules__ = Some(
12812 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12813 .into_iter().map(|(k,v)| (k.0, v)).collect()
12814 );
12815 }
12816 }
12817 }
12818 Ok(RescheduleRequest {
12819 revision: revision__.unwrap_or_default(),
12820 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
12821 worker_reschedules: worker_reschedules__.unwrap_or_default(),
12822 })
12823 }
12824 }
12825 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
12826 }
12827}
12828impl serde::Serialize for RescheduleResponse {
12829 #[allow(deprecated)]
12830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12831 where
12832 S: serde::Serializer,
12833 {
12834 use serde::ser::SerializeStruct;
12835 let mut len = 0;
12836 if self.success {
12837 len += 1;
12838 }
12839 if self.revision != 0 {
12840 len += 1;
12841 }
12842 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
12843 if self.success {
12844 struct_ser.serialize_field("success", &self.success)?;
12845 }
12846 if self.revision != 0 {
12847 #[allow(clippy::needless_borrow)]
12848 #[allow(clippy::needless_borrows_for_generic_args)]
12849 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
12850 }
12851 struct_ser.end()
12852 }
12853}
12854impl<'de> serde::Deserialize<'de> for RescheduleResponse {
12855 #[allow(deprecated)]
12856 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12857 where
12858 D: serde::Deserializer<'de>,
12859 {
12860 const FIELDS: &[&str] = &[
12861 "success",
12862 "revision",
12863 ];
12864
12865 #[allow(clippy::enum_variant_names)]
12866 enum GeneratedField {
12867 Success,
12868 Revision,
12869 }
12870 impl<'de> serde::Deserialize<'de> for GeneratedField {
12871 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12872 where
12873 D: serde::Deserializer<'de>,
12874 {
12875 struct GeneratedVisitor;
12876
12877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12878 type Value = GeneratedField;
12879
12880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12881 write!(formatter, "expected one of: {:?}", &FIELDS)
12882 }
12883
12884 #[allow(unused_variables)]
12885 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12886 where
12887 E: serde::de::Error,
12888 {
12889 match value {
12890 "success" => Ok(GeneratedField::Success),
12891 "revision" => Ok(GeneratedField::Revision),
12892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12893 }
12894 }
12895 }
12896 deserializer.deserialize_identifier(GeneratedVisitor)
12897 }
12898 }
12899 struct GeneratedVisitor;
12900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12901 type Value = RescheduleResponse;
12902
12903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12904 formatter.write_str("struct meta.RescheduleResponse")
12905 }
12906
12907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
12908 where
12909 V: serde::de::MapAccess<'de>,
12910 {
12911 let mut success__ = None;
12912 let mut revision__ = None;
12913 while let Some(k) = map_.next_key()? {
12914 match k {
12915 GeneratedField::Success => {
12916 if success__.is_some() {
12917 return Err(serde::de::Error::duplicate_field("success"));
12918 }
12919 success__ = Some(map_.next_value()?);
12920 }
12921 GeneratedField::Revision => {
12922 if revision__.is_some() {
12923 return Err(serde::de::Error::duplicate_field("revision"));
12924 }
12925 revision__ =
12926 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12927 ;
12928 }
12929 }
12930 }
12931 Ok(RescheduleResponse {
12932 success: success__.unwrap_or_default(),
12933 revision: revision__.unwrap_or_default(),
12934 })
12935 }
12936 }
12937 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
12938 }
12939}
12940impl serde::Serialize for ResumeRequest {
12941 #[allow(deprecated)]
12942 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12943 where
12944 S: serde::Serializer,
12945 {
12946 use serde::ser::SerializeStruct;
12947 let len = 0;
12948 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
12949 struct_ser.end()
12950 }
12951}
12952impl<'de> serde::Deserialize<'de> for ResumeRequest {
12953 #[allow(deprecated)]
12954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12955 where
12956 D: serde::Deserializer<'de>,
12957 {
12958 const FIELDS: &[&str] = &[
12959 ];
12960
12961 #[allow(clippy::enum_variant_names)]
12962 enum GeneratedField {
12963 }
12964 impl<'de> serde::Deserialize<'de> for GeneratedField {
12965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12966 where
12967 D: serde::Deserializer<'de>,
12968 {
12969 struct GeneratedVisitor;
12970
12971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12972 type Value = GeneratedField;
12973
12974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12975 write!(formatter, "expected one of: {:?}", &FIELDS)
12976 }
12977
12978 #[allow(unused_variables)]
12979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12980 where
12981 E: serde::de::Error,
12982 {
12983 Err(serde::de::Error::unknown_field(value, FIELDS))
12984 }
12985 }
12986 deserializer.deserialize_identifier(GeneratedVisitor)
12987 }
12988 }
12989 struct GeneratedVisitor;
12990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12991 type Value = ResumeRequest;
12992
12993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12994 formatter.write_str("struct meta.ResumeRequest")
12995 }
12996
12997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
12998 where
12999 V: serde::de::MapAccess<'de>,
13000 {
13001 while map_.next_key::<GeneratedField>()?.is_some() {
13002 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13003 }
13004 Ok(ResumeRequest {
13005 })
13006 }
13007 }
13008 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13009 }
13010}
13011impl serde::Serialize for ResumeResponse {
13012 #[allow(deprecated)]
13013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13014 where
13015 S: serde::Serializer,
13016 {
13017 use serde::ser::SerializeStruct;
13018 let len = 0;
13019 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13020 struct_ser.end()
13021 }
13022}
13023impl<'de> serde::Deserialize<'de> for ResumeResponse {
13024 #[allow(deprecated)]
13025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13026 where
13027 D: serde::Deserializer<'de>,
13028 {
13029 const FIELDS: &[&str] = &[
13030 ];
13031
13032 #[allow(clippy::enum_variant_names)]
13033 enum GeneratedField {
13034 }
13035 impl<'de> serde::Deserialize<'de> for GeneratedField {
13036 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13037 where
13038 D: serde::Deserializer<'de>,
13039 {
13040 struct GeneratedVisitor;
13041
13042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13043 type Value = GeneratedField;
13044
13045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13046 write!(formatter, "expected one of: {:?}", &FIELDS)
13047 }
13048
13049 #[allow(unused_variables)]
13050 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13051 where
13052 E: serde::de::Error,
13053 {
13054 Err(serde::de::Error::unknown_field(value, FIELDS))
13055 }
13056 }
13057 deserializer.deserialize_identifier(GeneratedVisitor)
13058 }
13059 }
13060 struct GeneratedVisitor;
13061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13062 type Value = ResumeResponse;
13063
13064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13065 formatter.write_str("struct meta.ResumeResponse")
13066 }
13067
13068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13069 where
13070 V: serde::de::MapAccess<'de>,
13071 {
13072 while map_.next_key::<GeneratedField>()?.is_some() {
13073 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13074 }
13075 Ok(ResumeResponse {
13076 })
13077 }
13078 }
13079 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13080 }
13081}
13082impl serde::Serialize for SetSessionParamRequest {
13083 #[allow(deprecated)]
13084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13085 where
13086 S: serde::Serializer,
13087 {
13088 use serde::ser::SerializeStruct;
13089 let mut len = 0;
13090 if !self.param.is_empty() {
13091 len += 1;
13092 }
13093 if self.value.is_some() {
13094 len += 1;
13095 }
13096 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13097 if !self.param.is_empty() {
13098 struct_ser.serialize_field("param", &self.param)?;
13099 }
13100 if let Some(v) = self.value.as_ref() {
13101 struct_ser.serialize_field("value", v)?;
13102 }
13103 struct_ser.end()
13104 }
13105}
13106impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13107 #[allow(deprecated)]
13108 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13109 where
13110 D: serde::Deserializer<'de>,
13111 {
13112 const FIELDS: &[&str] = &[
13113 "param",
13114 "value",
13115 ];
13116
13117 #[allow(clippy::enum_variant_names)]
13118 enum GeneratedField {
13119 Param,
13120 Value,
13121 }
13122 impl<'de> serde::Deserialize<'de> for GeneratedField {
13123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13124 where
13125 D: serde::Deserializer<'de>,
13126 {
13127 struct GeneratedVisitor;
13128
13129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13130 type Value = GeneratedField;
13131
13132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13133 write!(formatter, "expected one of: {:?}", &FIELDS)
13134 }
13135
13136 #[allow(unused_variables)]
13137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13138 where
13139 E: serde::de::Error,
13140 {
13141 match value {
13142 "param" => Ok(GeneratedField::Param),
13143 "value" => Ok(GeneratedField::Value),
13144 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13145 }
13146 }
13147 }
13148 deserializer.deserialize_identifier(GeneratedVisitor)
13149 }
13150 }
13151 struct GeneratedVisitor;
13152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13153 type Value = SetSessionParamRequest;
13154
13155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13156 formatter.write_str("struct meta.SetSessionParamRequest")
13157 }
13158
13159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13160 where
13161 V: serde::de::MapAccess<'de>,
13162 {
13163 let mut param__ = None;
13164 let mut value__ = None;
13165 while let Some(k) = map_.next_key()? {
13166 match k {
13167 GeneratedField::Param => {
13168 if param__.is_some() {
13169 return Err(serde::de::Error::duplicate_field("param"));
13170 }
13171 param__ = Some(map_.next_value()?);
13172 }
13173 GeneratedField::Value => {
13174 if value__.is_some() {
13175 return Err(serde::de::Error::duplicate_field("value"));
13176 }
13177 value__ = map_.next_value()?;
13178 }
13179 }
13180 }
13181 Ok(SetSessionParamRequest {
13182 param: param__.unwrap_or_default(),
13183 value: value__,
13184 })
13185 }
13186 }
13187 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13188 }
13189}
13190impl serde::Serialize for SetSessionParamResponse {
13191 #[allow(deprecated)]
13192 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13193 where
13194 S: serde::Serializer,
13195 {
13196 use serde::ser::SerializeStruct;
13197 let mut len = 0;
13198 if !self.param.is_empty() {
13199 len += 1;
13200 }
13201 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13202 if !self.param.is_empty() {
13203 struct_ser.serialize_field("param", &self.param)?;
13204 }
13205 struct_ser.end()
13206 }
13207}
13208impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13209 #[allow(deprecated)]
13210 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13211 where
13212 D: serde::Deserializer<'de>,
13213 {
13214 const FIELDS: &[&str] = &[
13215 "param",
13216 ];
13217
13218 #[allow(clippy::enum_variant_names)]
13219 enum GeneratedField {
13220 Param,
13221 }
13222 impl<'de> serde::Deserialize<'de> for GeneratedField {
13223 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13224 where
13225 D: serde::Deserializer<'de>,
13226 {
13227 struct GeneratedVisitor;
13228
13229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13230 type Value = GeneratedField;
13231
13232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13233 write!(formatter, "expected one of: {:?}", &FIELDS)
13234 }
13235
13236 #[allow(unused_variables)]
13237 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13238 where
13239 E: serde::de::Error,
13240 {
13241 match value {
13242 "param" => Ok(GeneratedField::Param),
13243 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13244 }
13245 }
13246 }
13247 deserializer.deserialize_identifier(GeneratedVisitor)
13248 }
13249 }
13250 struct GeneratedVisitor;
13251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13252 type Value = SetSessionParamResponse;
13253
13254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13255 formatter.write_str("struct meta.SetSessionParamResponse")
13256 }
13257
13258 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13259 where
13260 V: serde::de::MapAccess<'de>,
13261 {
13262 let mut param__ = None;
13263 while let Some(k) = map_.next_key()? {
13264 match k {
13265 GeneratedField::Param => {
13266 if param__.is_some() {
13267 return Err(serde::de::Error::duplicate_field("param"));
13268 }
13269 param__ = Some(map_.next_value()?);
13270 }
13271 }
13272 }
13273 Ok(SetSessionParamResponse {
13274 param: param__.unwrap_or_default(),
13275 })
13276 }
13277 }
13278 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13279 }
13280}
13281impl serde::Serialize for SetSystemParamRequest {
13282 #[allow(deprecated)]
13283 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13284 where
13285 S: serde::Serializer,
13286 {
13287 use serde::ser::SerializeStruct;
13288 let mut len = 0;
13289 if !self.param.is_empty() {
13290 len += 1;
13291 }
13292 if self.value.is_some() {
13293 len += 1;
13294 }
13295 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
13296 if !self.param.is_empty() {
13297 struct_ser.serialize_field("param", &self.param)?;
13298 }
13299 if let Some(v) = self.value.as_ref() {
13300 struct_ser.serialize_field("value", v)?;
13301 }
13302 struct_ser.end()
13303 }
13304}
13305impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
13306 #[allow(deprecated)]
13307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13308 where
13309 D: serde::Deserializer<'de>,
13310 {
13311 const FIELDS: &[&str] = &[
13312 "param",
13313 "value",
13314 ];
13315
13316 #[allow(clippy::enum_variant_names)]
13317 enum GeneratedField {
13318 Param,
13319 Value,
13320 }
13321 impl<'de> serde::Deserialize<'de> for GeneratedField {
13322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13323 where
13324 D: serde::Deserializer<'de>,
13325 {
13326 struct GeneratedVisitor;
13327
13328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13329 type Value = GeneratedField;
13330
13331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13332 write!(formatter, "expected one of: {:?}", &FIELDS)
13333 }
13334
13335 #[allow(unused_variables)]
13336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13337 where
13338 E: serde::de::Error,
13339 {
13340 match value {
13341 "param" => Ok(GeneratedField::Param),
13342 "value" => Ok(GeneratedField::Value),
13343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13344 }
13345 }
13346 }
13347 deserializer.deserialize_identifier(GeneratedVisitor)
13348 }
13349 }
13350 struct GeneratedVisitor;
13351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13352 type Value = SetSystemParamRequest;
13353
13354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13355 formatter.write_str("struct meta.SetSystemParamRequest")
13356 }
13357
13358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
13359 where
13360 V: serde::de::MapAccess<'de>,
13361 {
13362 let mut param__ = None;
13363 let mut value__ = None;
13364 while let Some(k) = map_.next_key()? {
13365 match k {
13366 GeneratedField::Param => {
13367 if param__.is_some() {
13368 return Err(serde::de::Error::duplicate_field("param"));
13369 }
13370 param__ = Some(map_.next_value()?);
13371 }
13372 GeneratedField::Value => {
13373 if value__.is_some() {
13374 return Err(serde::de::Error::duplicate_field("value"));
13375 }
13376 value__ = map_.next_value()?;
13377 }
13378 }
13379 }
13380 Ok(SetSystemParamRequest {
13381 param: param__.unwrap_or_default(),
13382 value: value__,
13383 })
13384 }
13385 }
13386 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
13387 }
13388}
13389impl serde::Serialize for SetSystemParamResponse {
13390 #[allow(deprecated)]
13391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13392 where
13393 S: serde::Serializer,
13394 {
13395 use serde::ser::SerializeStruct;
13396 let mut len = 0;
13397 if self.params.is_some() {
13398 len += 1;
13399 }
13400 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
13401 if let Some(v) = self.params.as_ref() {
13402 struct_ser.serialize_field("params", v)?;
13403 }
13404 struct_ser.end()
13405 }
13406}
13407impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
13408 #[allow(deprecated)]
13409 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13410 where
13411 D: serde::Deserializer<'de>,
13412 {
13413 const FIELDS: &[&str] = &[
13414 "params",
13415 ];
13416
13417 #[allow(clippy::enum_variant_names)]
13418 enum GeneratedField {
13419 Params,
13420 }
13421 impl<'de> serde::Deserialize<'de> for GeneratedField {
13422 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13423 where
13424 D: serde::Deserializer<'de>,
13425 {
13426 struct GeneratedVisitor;
13427
13428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13429 type Value = GeneratedField;
13430
13431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13432 write!(formatter, "expected one of: {:?}", &FIELDS)
13433 }
13434
13435 #[allow(unused_variables)]
13436 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13437 where
13438 E: serde::de::Error,
13439 {
13440 match value {
13441 "params" => Ok(GeneratedField::Params),
13442 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13443 }
13444 }
13445 }
13446 deserializer.deserialize_identifier(GeneratedVisitor)
13447 }
13448 }
13449 struct GeneratedVisitor;
13450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13451 type Value = SetSystemParamResponse;
13452
13453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13454 formatter.write_str("struct meta.SetSystemParamResponse")
13455 }
13456
13457 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
13458 where
13459 V: serde::de::MapAccess<'de>,
13460 {
13461 let mut params__ = None;
13462 while let Some(k) = map_.next_key()? {
13463 match k {
13464 GeneratedField::Params => {
13465 if params__.is_some() {
13466 return Err(serde::de::Error::duplicate_field("params"));
13467 }
13468 params__ = map_.next_value()?;
13469 }
13470 }
13471 }
13472 Ok(SetSystemParamResponse {
13473 params: params__,
13474 })
13475 }
13476 }
13477 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
13478 }
13479}
13480impl serde::Serialize for SubscribeRequest {
13481 #[allow(deprecated)]
13482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13483 where
13484 S: serde::Serializer,
13485 {
13486 use serde::ser::SerializeStruct;
13487 let mut len = 0;
13488 if self.subscribe_type != 0 {
13489 len += 1;
13490 }
13491 if self.host.is_some() {
13492 len += 1;
13493 }
13494 if self.worker_id != 0 {
13495 len += 1;
13496 }
13497 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
13498 if self.subscribe_type != 0 {
13499 let v = SubscribeType::try_from(self.subscribe_type)
13500 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
13501 struct_ser.serialize_field("subscribeType", &v)?;
13502 }
13503 if let Some(v) = self.host.as_ref() {
13504 struct_ser.serialize_field("host", v)?;
13505 }
13506 if self.worker_id != 0 {
13507 struct_ser.serialize_field("workerId", &self.worker_id)?;
13508 }
13509 struct_ser.end()
13510 }
13511}
13512impl<'de> serde::Deserialize<'de> for SubscribeRequest {
13513 #[allow(deprecated)]
13514 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13515 where
13516 D: serde::Deserializer<'de>,
13517 {
13518 const FIELDS: &[&str] = &[
13519 "subscribe_type",
13520 "subscribeType",
13521 "host",
13522 "worker_id",
13523 "workerId",
13524 ];
13525
13526 #[allow(clippy::enum_variant_names)]
13527 enum GeneratedField {
13528 SubscribeType,
13529 Host,
13530 WorkerId,
13531 }
13532 impl<'de> serde::Deserialize<'de> for GeneratedField {
13533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13534 where
13535 D: serde::Deserializer<'de>,
13536 {
13537 struct GeneratedVisitor;
13538
13539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13540 type Value = GeneratedField;
13541
13542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13543 write!(formatter, "expected one of: {:?}", &FIELDS)
13544 }
13545
13546 #[allow(unused_variables)]
13547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13548 where
13549 E: serde::de::Error,
13550 {
13551 match value {
13552 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
13553 "host" => Ok(GeneratedField::Host),
13554 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
13555 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13556 }
13557 }
13558 }
13559 deserializer.deserialize_identifier(GeneratedVisitor)
13560 }
13561 }
13562 struct GeneratedVisitor;
13563 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13564 type Value = SubscribeRequest;
13565
13566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13567 formatter.write_str("struct meta.SubscribeRequest")
13568 }
13569
13570 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
13571 where
13572 V: serde::de::MapAccess<'de>,
13573 {
13574 let mut subscribe_type__ = None;
13575 let mut host__ = None;
13576 let mut worker_id__ = None;
13577 while let Some(k) = map_.next_key()? {
13578 match k {
13579 GeneratedField::SubscribeType => {
13580 if subscribe_type__.is_some() {
13581 return Err(serde::de::Error::duplicate_field("subscribeType"));
13582 }
13583 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
13584 }
13585 GeneratedField::Host => {
13586 if host__.is_some() {
13587 return Err(serde::de::Error::duplicate_field("host"));
13588 }
13589 host__ = map_.next_value()?;
13590 }
13591 GeneratedField::WorkerId => {
13592 if worker_id__.is_some() {
13593 return Err(serde::de::Error::duplicate_field("workerId"));
13594 }
13595 worker_id__ =
13596 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13597 ;
13598 }
13599 }
13600 }
13601 Ok(SubscribeRequest {
13602 subscribe_type: subscribe_type__.unwrap_or_default(),
13603 host: host__,
13604 worker_id: worker_id__.unwrap_or_default(),
13605 })
13606 }
13607 }
13608 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
13609 }
13610}
13611impl serde::Serialize for SubscribeResponse {
13612 #[allow(deprecated)]
13613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13614 where
13615 S: serde::Serializer,
13616 {
13617 use serde::ser::SerializeStruct;
13618 let mut len = 0;
13619 if self.status.is_some() {
13620 len += 1;
13621 }
13622 if self.operation != 0 {
13623 len += 1;
13624 }
13625 if self.version != 0 {
13626 len += 1;
13627 }
13628 if self.info.is_some() {
13629 len += 1;
13630 }
13631 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
13632 if let Some(v) = self.status.as_ref() {
13633 struct_ser.serialize_field("status", v)?;
13634 }
13635 if self.operation != 0 {
13636 let v = subscribe_response::Operation::try_from(self.operation)
13637 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
13638 struct_ser.serialize_field("operation", &v)?;
13639 }
13640 if self.version != 0 {
13641 #[allow(clippy::needless_borrow)]
13642 #[allow(clippy::needless_borrows_for_generic_args)]
13643 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
13644 }
13645 if let Some(v) = self.info.as_ref() {
13646 match v {
13647 subscribe_response::Info::Database(v) => {
13648 struct_ser.serialize_field("database", v)?;
13649 }
13650 subscribe_response::Info::Schema(v) => {
13651 struct_ser.serialize_field("schema", v)?;
13652 }
13653 subscribe_response::Info::Function(v) => {
13654 struct_ser.serialize_field("function", v)?;
13655 }
13656 subscribe_response::Info::User(v) => {
13657 struct_ser.serialize_field("user", v)?;
13658 }
13659 subscribe_response::Info::SessionParam(v) => {
13660 struct_ser.serialize_field("sessionParam", v)?;
13661 }
13662 subscribe_response::Info::Node(v) => {
13663 struct_ser.serialize_field("node", v)?;
13664 }
13665 subscribe_response::Info::HummockVersionDeltas(v) => {
13666 struct_ser.serialize_field("hummockVersionDeltas", v)?;
13667 }
13668 subscribe_response::Info::Snapshot(v) => {
13669 struct_ser.serialize_field("snapshot", v)?;
13670 }
13671 subscribe_response::Info::MetaBackupManifestId(v) => {
13672 struct_ser.serialize_field("metaBackupManifestId", v)?;
13673 }
13674 subscribe_response::Info::SystemParams(v) => {
13675 struct_ser.serialize_field("systemParams", v)?;
13676 }
13677 subscribe_response::Info::HummockWriteLimits(v) => {
13678 struct_ser.serialize_field("hummockWriteLimits", v)?;
13679 }
13680 subscribe_response::Info::ObjectGroup(v) => {
13681 struct_ser.serialize_field("objectGroup", v)?;
13682 }
13683 subscribe_response::Info::Connection(v) => {
13684 struct_ser.serialize_field("connection", v)?;
13685 }
13686 subscribe_response::Info::HummockStats(v) => {
13687 struct_ser.serialize_field("hummockStats", v)?;
13688 }
13689 subscribe_response::Info::Recovery(v) => {
13690 struct_ser.serialize_field("recovery", v)?;
13691 }
13692 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
13693 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
13694 }
13695 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
13696 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
13697 }
13698 subscribe_response::Info::Secret(v) => {
13699 struct_ser.serialize_field("secret", v)?;
13700 }
13701 subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
13702 #[allow(clippy::needless_borrow)]
13703 #[allow(clippy::needless_borrows_for_generic_args)]
13704 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
13705 }
13706 }
13707 }
13708 struct_ser.end()
13709 }
13710}
13711impl<'de> serde::Deserialize<'de> for SubscribeResponse {
13712 #[allow(deprecated)]
13713 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13714 where
13715 D: serde::Deserializer<'de>,
13716 {
13717 const FIELDS: &[&str] = &[
13718 "status",
13719 "operation",
13720 "version",
13721 "database",
13722 "schema",
13723 "function",
13724 "user",
13725 "session_param",
13726 "sessionParam",
13727 "node",
13728 "hummock_version_deltas",
13729 "hummockVersionDeltas",
13730 "snapshot",
13731 "meta_backup_manifest_id",
13732 "metaBackupManifestId",
13733 "system_params",
13734 "systemParams",
13735 "hummock_write_limits",
13736 "hummockWriteLimits",
13737 "object_group",
13738 "objectGroup",
13739 "connection",
13740 "hummock_stats",
13741 "hummockStats",
13742 "recovery",
13743 "streaming_worker_slot_mapping",
13744 "streamingWorkerSlotMapping",
13745 "serving_worker_slot_mappings",
13746 "servingWorkerSlotMappings",
13747 "secret",
13748 "compute_node_total_cpu_count",
13749 "computeNodeTotalCpuCount",
13750 ];
13751
13752 #[allow(clippy::enum_variant_names)]
13753 enum GeneratedField {
13754 Status,
13755 Operation,
13756 Version,
13757 Database,
13758 Schema,
13759 Function,
13760 User,
13761 SessionParam,
13762 Node,
13763 HummockVersionDeltas,
13764 Snapshot,
13765 MetaBackupManifestId,
13766 SystemParams,
13767 HummockWriteLimits,
13768 ObjectGroup,
13769 Connection,
13770 HummockStats,
13771 Recovery,
13772 StreamingWorkerSlotMapping,
13773 ServingWorkerSlotMappings,
13774 Secret,
13775 ComputeNodeTotalCpuCount,
13776 }
13777 impl<'de> serde::Deserialize<'de> for GeneratedField {
13778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13779 where
13780 D: serde::Deserializer<'de>,
13781 {
13782 struct GeneratedVisitor;
13783
13784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13785 type Value = GeneratedField;
13786
13787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13788 write!(formatter, "expected one of: {:?}", &FIELDS)
13789 }
13790
13791 #[allow(unused_variables)]
13792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13793 where
13794 E: serde::de::Error,
13795 {
13796 match value {
13797 "status" => Ok(GeneratedField::Status),
13798 "operation" => Ok(GeneratedField::Operation),
13799 "version" => Ok(GeneratedField::Version),
13800 "database" => Ok(GeneratedField::Database),
13801 "schema" => Ok(GeneratedField::Schema),
13802 "function" => Ok(GeneratedField::Function),
13803 "user" => Ok(GeneratedField::User),
13804 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
13805 "node" => Ok(GeneratedField::Node),
13806 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
13807 "snapshot" => Ok(GeneratedField::Snapshot),
13808 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
13809 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
13810 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
13811 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
13812 "connection" => Ok(GeneratedField::Connection),
13813 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
13814 "recovery" => Ok(GeneratedField::Recovery),
13815 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
13816 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
13817 "secret" => Ok(GeneratedField::Secret),
13818 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
13819 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13820 }
13821 }
13822 }
13823 deserializer.deserialize_identifier(GeneratedVisitor)
13824 }
13825 }
13826 struct GeneratedVisitor;
13827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13828 type Value = SubscribeResponse;
13829
13830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13831 formatter.write_str("struct meta.SubscribeResponse")
13832 }
13833
13834 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
13835 where
13836 V: serde::de::MapAccess<'de>,
13837 {
13838 let mut status__ = None;
13839 let mut operation__ = None;
13840 let mut version__ = None;
13841 let mut info__ = None;
13842 while let Some(k) = map_.next_key()? {
13843 match k {
13844 GeneratedField::Status => {
13845 if status__.is_some() {
13846 return Err(serde::de::Error::duplicate_field("status"));
13847 }
13848 status__ = map_.next_value()?;
13849 }
13850 GeneratedField::Operation => {
13851 if operation__.is_some() {
13852 return Err(serde::de::Error::duplicate_field("operation"));
13853 }
13854 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
13855 }
13856 GeneratedField::Version => {
13857 if version__.is_some() {
13858 return Err(serde::de::Error::duplicate_field("version"));
13859 }
13860 version__ =
13861 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13862 ;
13863 }
13864 GeneratedField::Database => {
13865 if info__.is_some() {
13866 return Err(serde::de::Error::duplicate_field("database"));
13867 }
13868 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
13869;
13870 }
13871 GeneratedField::Schema => {
13872 if info__.is_some() {
13873 return Err(serde::de::Error::duplicate_field("schema"));
13874 }
13875 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
13876;
13877 }
13878 GeneratedField::Function => {
13879 if info__.is_some() {
13880 return Err(serde::de::Error::duplicate_field("function"));
13881 }
13882 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
13883;
13884 }
13885 GeneratedField::User => {
13886 if info__.is_some() {
13887 return Err(serde::de::Error::duplicate_field("user"));
13888 }
13889 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
13890;
13891 }
13892 GeneratedField::SessionParam => {
13893 if info__.is_some() {
13894 return Err(serde::de::Error::duplicate_field("sessionParam"));
13895 }
13896 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
13897;
13898 }
13899 GeneratedField::Node => {
13900 if info__.is_some() {
13901 return Err(serde::de::Error::duplicate_field("node"));
13902 }
13903 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
13904;
13905 }
13906 GeneratedField::HummockVersionDeltas => {
13907 if info__.is_some() {
13908 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
13909 }
13910 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
13911;
13912 }
13913 GeneratedField::Snapshot => {
13914 if info__.is_some() {
13915 return Err(serde::de::Error::duplicate_field("snapshot"));
13916 }
13917 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
13918;
13919 }
13920 GeneratedField::MetaBackupManifestId => {
13921 if info__.is_some() {
13922 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
13923 }
13924 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
13925;
13926 }
13927 GeneratedField::SystemParams => {
13928 if info__.is_some() {
13929 return Err(serde::de::Error::duplicate_field("systemParams"));
13930 }
13931 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
13932;
13933 }
13934 GeneratedField::HummockWriteLimits => {
13935 if info__.is_some() {
13936 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
13937 }
13938 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
13939;
13940 }
13941 GeneratedField::ObjectGroup => {
13942 if info__.is_some() {
13943 return Err(serde::de::Error::duplicate_field("objectGroup"));
13944 }
13945 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
13946;
13947 }
13948 GeneratedField::Connection => {
13949 if info__.is_some() {
13950 return Err(serde::de::Error::duplicate_field("connection"));
13951 }
13952 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
13953;
13954 }
13955 GeneratedField::HummockStats => {
13956 if info__.is_some() {
13957 return Err(serde::de::Error::duplicate_field("hummockStats"));
13958 }
13959 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
13960;
13961 }
13962 GeneratedField::Recovery => {
13963 if info__.is_some() {
13964 return Err(serde::de::Error::duplicate_field("recovery"));
13965 }
13966 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
13967;
13968 }
13969 GeneratedField::StreamingWorkerSlotMapping => {
13970 if info__.is_some() {
13971 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
13972 }
13973 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
13974;
13975 }
13976 GeneratedField::ServingWorkerSlotMappings => {
13977 if info__.is_some() {
13978 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
13979 }
13980 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
13981;
13982 }
13983 GeneratedField::Secret => {
13984 if info__.is_some() {
13985 return Err(serde::de::Error::duplicate_field("secret"));
13986 }
13987 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
13988;
13989 }
13990 GeneratedField::ComputeNodeTotalCpuCount => {
13991 if info__.is_some() {
13992 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
13993 }
13994 info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
13995 }
13996 }
13997 }
13998 Ok(SubscribeResponse {
13999 status: status__,
14000 operation: operation__.unwrap_or_default(),
14001 version: version__.unwrap_or_default(),
14002 info: info__,
14003 })
14004 }
14005 }
14006 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14007 }
14008}
14009impl serde::Serialize for subscribe_response::Operation {
14010 #[allow(deprecated)]
14011 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14012 where
14013 S: serde::Serializer,
14014 {
14015 let variant = match self {
14016 Self::Unspecified => "UNSPECIFIED",
14017 Self::Add => "ADD",
14018 Self::Delete => "DELETE",
14019 Self::Update => "UPDATE",
14020 Self::Snapshot => "SNAPSHOT",
14021 };
14022 serializer.serialize_str(variant)
14023 }
14024}
14025impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14026 #[allow(deprecated)]
14027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14028 where
14029 D: serde::Deserializer<'de>,
14030 {
14031 const FIELDS: &[&str] = &[
14032 "UNSPECIFIED",
14033 "ADD",
14034 "DELETE",
14035 "UPDATE",
14036 "SNAPSHOT",
14037 ];
14038
14039 struct GeneratedVisitor;
14040
14041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14042 type Value = subscribe_response::Operation;
14043
14044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14045 write!(formatter, "expected one of: {:?}", &FIELDS)
14046 }
14047
14048 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14049 where
14050 E: serde::de::Error,
14051 {
14052 i32::try_from(v)
14053 .ok()
14054 .and_then(|x| x.try_into().ok())
14055 .ok_or_else(|| {
14056 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14057 })
14058 }
14059
14060 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14061 where
14062 E: serde::de::Error,
14063 {
14064 i32::try_from(v)
14065 .ok()
14066 .and_then(|x| x.try_into().ok())
14067 .ok_or_else(|| {
14068 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14069 })
14070 }
14071
14072 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14073 where
14074 E: serde::de::Error,
14075 {
14076 match value {
14077 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14078 "ADD" => Ok(subscribe_response::Operation::Add),
14079 "DELETE" => Ok(subscribe_response::Operation::Delete),
14080 "UPDATE" => Ok(subscribe_response::Operation::Update),
14081 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14082 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14083 }
14084 }
14085 }
14086 deserializer.deserialize_any(GeneratedVisitor)
14087 }
14088}
14089impl serde::Serialize for SubscribeType {
14090 #[allow(deprecated)]
14091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14092 where
14093 S: serde::Serializer,
14094 {
14095 let variant = match self {
14096 Self::Unspecified => "UNSPECIFIED",
14097 Self::Frontend => "FRONTEND",
14098 Self::Hummock => "HUMMOCK",
14099 Self::Compactor => "COMPACTOR",
14100 Self::Compute => "COMPUTE",
14101 };
14102 serializer.serialize_str(variant)
14103 }
14104}
14105impl<'de> serde::Deserialize<'de> for SubscribeType {
14106 #[allow(deprecated)]
14107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14108 where
14109 D: serde::Deserializer<'de>,
14110 {
14111 const FIELDS: &[&str] = &[
14112 "UNSPECIFIED",
14113 "FRONTEND",
14114 "HUMMOCK",
14115 "COMPACTOR",
14116 "COMPUTE",
14117 ];
14118
14119 struct GeneratedVisitor;
14120
14121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14122 type Value = SubscribeType;
14123
14124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14125 write!(formatter, "expected one of: {:?}", &FIELDS)
14126 }
14127
14128 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14129 where
14130 E: serde::de::Error,
14131 {
14132 i32::try_from(v)
14133 .ok()
14134 .and_then(|x| x.try_into().ok())
14135 .ok_or_else(|| {
14136 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14137 })
14138 }
14139
14140 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14141 where
14142 E: serde::de::Error,
14143 {
14144 i32::try_from(v)
14145 .ok()
14146 .and_then(|x| x.try_into().ok())
14147 .ok_or_else(|| {
14148 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14149 })
14150 }
14151
14152 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14153 where
14154 E: serde::de::Error,
14155 {
14156 match value {
14157 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
14158 "FRONTEND" => Ok(SubscribeType::Frontend),
14159 "HUMMOCK" => Ok(SubscribeType::Hummock),
14160 "COMPACTOR" => Ok(SubscribeType::Compactor),
14161 "COMPUTE" => Ok(SubscribeType::Compute),
14162 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14163 }
14164 }
14165 }
14166 deserializer.deserialize_any(GeneratedVisitor)
14167 }
14168}
14169impl serde::Serialize for SystemParams {
14170 #[allow(deprecated)]
14171 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14172 where
14173 S: serde::Serializer,
14174 {
14175 use serde::ser::SerializeStruct;
14176 let mut len = 0;
14177 if self.barrier_interval_ms.is_some() {
14178 len += 1;
14179 }
14180 if self.checkpoint_frequency.is_some() {
14181 len += 1;
14182 }
14183 if self.sstable_size_mb.is_some() {
14184 len += 1;
14185 }
14186 if self.block_size_kb.is_some() {
14187 len += 1;
14188 }
14189 if self.bloom_false_positive.is_some() {
14190 len += 1;
14191 }
14192 if self.state_store.is_some() {
14193 len += 1;
14194 }
14195 if self.data_directory.is_some() {
14196 len += 1;
14197 }
14198 if self.backup_storage_url.is_some() {
14199 len += 1;
14200 }
14201 if self.backup_storage_directory.is_some() {
14202 len += 1;
14203 }
14204 if self.telemetry_enabled.is_some() {
14205 len += 1;
14206 }
14207 if self.parallel_compact_size_mb.is_some() {
14208 len += 1;
14209 }
14210 if self.max_concurrent_creating_streaming_jobs.is_some() {
14211 len += 1;
14212 }
14213 if self.pause_on_next_bootstrap.is_some() {
14214 len += 1;
14215 }
14216 if self.wasm_storage_url.is_some() {
14217 len += 1;
14218 }
14219 if self.enable_tracing.is_some() {
14220 len += 1;
14221 }
14222 if self.use_new_object_prefix_strategy.is_some() {
14223 len += 1;
14224 }
14225 if self.license_key.is_some() {
14226 len += 1;
14227 }
14228 if self.time_travel_retention_ms.is_some() {
14229 len += 1;
14230 }
14231 if self.adaptive_parallelism_strategy.is_some() {
14232 len += 1;
14233 }
14234 if self.per_database_isolation.is_some() {
14235 len += 1;
14236 }
14237 if self.enforce_secret.is_some() {
14238 len += 1;
14239 }
14240 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
14241 if let Some(v) = self.barrier_interval_ms.as_ref() {
14242 struct_ser.serialize_field("barrierIntervalMs", v)?;
14243 }
14244 if let Some(v) = self.checkpoint_frequency.as_ref() {
14245 #[allow(clippy::needless_borrow)]
14246 #[allow(clippy::needless_borrows_for_generic_args)]
14247 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
14248 }
14249 if let Some(v) = self.sstable_size_mb.as_ref() {
14250 struct_ser.serialize_field("sstableSizeMb", v)?;
14251 }
14252 if let Some(v) = self.block_size_kb.as_ref() {
14253 struct_ser.serialize_field("blockSizeKb", v)?;
14254 }
14255 if let Some(v) = self.bloom_false_positive.as_ref() {
14256 struct_ser.serialize_field("bloomFalsePositive", v)?;
14257 }
14258 if let Some(v) = self.state_store.as_ref() {
14259 struct_ser.serialize_field("stateStore", v)?;
14260 }
14261 if let Some(v) = self.data_directory.as_ref() {
14262 struct_ser.serialize_field("dataDirectory", v)?;
14263 }
14264 if let Some(v) = self.backup_storage_url.as_ref() {
14265 struct_ser.serialize_field("backupStorageUrl", v)?;
14266 }
14267 if let Some(v) = self.backup_storage_directory.as_ref() {
14268 struct_ser.serialize_field("backupStorageDirectory", v)?;
14269 }
14270 if let Some(v) = self.telemetry_enabled.as_ref() {
14271 struct_ser.serialize_field("telemetryEnabled", v)?;
14272 }
14273 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
14274 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
14275 }
14276 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
14277 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
14278 }
14279 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
14280 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
14281 }
14282 if let Some(v) = self.wasm_storage_url.as_ref() {
14283 struct_ser.serialize_field("wasmStorageUrl", v)?;
14284 }
14285 if let Some(v) = self.enable_tracing.as_ref() {
14286 struct_ser.serialize_field("enableTracing", v)?;
14287 }
14288 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
14289 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
14290 }
14291 if let Some(v) = self.license_key.as_ref() {
14292 struct_ser.serialize_field("licenseKey", v)?;
14293 }
14294 if let Some(v) = self.time_travel_retention_ms.as_ref() {
14295 #[allow(clippy::needless_borrow)]
14296 #[allow(clippy::needless_borrows_for_generic_args)]
14297 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
14298 }
14299 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
14300 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
14301 }
14302 if let Some(v) = self.per_database_isolation.as_ref() {
14303 struct_ser.serialize_field("perDatabaseIsolation", v)?;
14304 }
14305 if let Some(v) = self.enforce_secret.as_ref() {
14306 struct_ser.serialize_field("enforceSecret", v)?;
14307 }
14308 struct_ser.end()
14309 }
14310}
14311impl<'de> serde::Deserialize<'de> for SystemParams {
14312 #[allow(deprecated)]
14313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14314 where
14315 D: serde::Deserializer<'de>,
14316 {
14317 const FIELDS: &[&str] = &[
14318 "barrier_interval_ms",
14319 "barrierIntervalMs",
14320 "checkpoint_frequency",
14321 "checkpointFrequency",
14322 "sstable_size_mb",
14323 "sstableSizeMb",
14324 "block_size_kb",
14325 "blockSizeKb",
14326 "bloom_false_positive",
14327 "bloomFalsePositive",
14328 "state_store",
14329 "stateStore",
14330 "data_directory",
14331 "dataDirectory",
14332 "backup_storage_url",
14333 "backupStorageUrl",
14334 "backup_storage_directory",
14335 "backupStorageDirectory",
14336 "telemetry_enabled",
14337 "telemetryEnabled",
14338 "parallel_compact_size_mb",
14339 "parallelCompactSizeMb",
14340 "max_concurrent_creating_streaming_jobs",
14341 "maxConcurrentCreatingStreamingJobs",
14342 "pause_on_next_bootstrap",
14343 "pauseOnNextBootstrap",
14344 "wasm_storage_url",
14345 "wasmStorageUrl",
14346 "enable_tracing",
14347 "enableTracing",
14348 "use_new_object_prefix_strategy",
14349 "useNewObjectPrefixStrategy",
14350 "license_key",
14351 "licenseKey",
14352 "time_travel_retention_ms",
14353 "timeTravelRetentionMs",
14354 "adaptive_parallelism_strategy",
14355 "adaptiveParallelismStrategy",
14356 "per_database_isolation",
14357 "perDatabaseIsolation",
14358 "enforce_secret",
14359 "enforceSecret",
14360 ];
14361
14362 #[allow(clippy::enum_variant_names)]
14363 enum GeneratedField {
14364 BarrierIntervalMs,
14365 CheckpointFrequency,
14366 SstableSizeMb,
14367 BlockSizeKb,
14368 BloomFalsePositive,
14369 StateStore,
14370 DataDirectory,
14371 BackupStorageUrl,
14372 BackupStorageDirectory,
14373 TelemetryEnabled,
14374 ParallelCompactSizeMb,
14375 MaxConcurrentCreatingStreamingJobs,
14376 PauseOnNextBootstrap,
14377 WasmStorageUrl,
14378 EnableTracing,
14379 UseNewObjectPrefixStrategy,
14380 LicenseKey,
14381 TimeTravelRetentionMs,
14382 AdaptiveParallelismStrategy,
14383 PerDatabaseIsolation,
14384 EnforceSecret,
14385 }
14386 impl<'de> serde::Deserialize<'de> for GeneratedField {
14387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14388 where
14389 D: serde::Deserializer<'de>,
14390 {
14391 struct GeneratedVisitor;
14392
14393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14394 type Value = GeneratedField;
14395
14396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14397 write!(formatter, "expected one of: {:?}", &FIELDS)
14398 }
14399
14400 #[allow(unused_variables)]
14401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14402 where
14403 E: serde::de::Error,
14404 {
14405 match value {
14406 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
14407 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
14408 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
14409 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
14410 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
14411 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
14412 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
14413 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
14414 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
14415 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
14416 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
14417 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
14418 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
14419 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
14420 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
14421 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
14422 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
14423 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
14424 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
14425 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
14426 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
14427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14428 }
14429 }
14430 }
14431 deserializer.deserialize_identifier(GeneratedVisitor)
14432 }
14433 }
14434 struct GeneratedVisitor;
14435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14436 type Value = SystemParams;
14437
14438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14439 formatter.write_str("struct meta.SystemParams")
14440 }
14441
14442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
14443 where
14444 V: serde::de::MapAccess<'de>,
14445 {
14446 let mut barrier_interval_ms__ = None;
14447 let mut checkpoint_frequency__ = None;
14448 let mut sstable_size_mb__ = None;
14449 let mut block_size_kb__ = None;
14450 let mut bloom_false_positive__ = None;
14451 let mut state_store__ = None;
14452 let mut data_directory__ = None;
14453 let mut backup_storage_url__ = None;
14454 let mut backup_storage_directory__ = None;
14455 let mut telemetry_enabled__ = None;
14456 let mut parallel_compact_size_mb__ = None;
14457 let mut max_concurrent_creating_streaming_jobs__ = None;
14458 let mut pause_on_next_bootstrap__ = None;
14459 let mut wasm_storage_url__ = None;
14460 let mut enable_tracing__ = None;
14461 let mut use_new_object_prefix_strategy__ = None;
14462 let mut license_key__ = None;
14463 let mut time_travel_retention_ms__ = None;
14464 let mut adaptive_parallelism_strategy__ = None;
14465 let mut per_database_isolation__ = None;
14466 let mut enforce_secret__ = None;
14467 while let Some(k) = map_.next_key()? {
14468 match k {
14469 GeneratedField::BarrierIntervalMs => {
14470 if barrier_interval_ms__.is_some() {
14471 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
14472 }
14473 barrier_interval_ms__ =
14474 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14475 ;
14476 }
14477 GeneratedField::CheckpointFrequency => {
14478 if checkpoint_frequency__.is_some() {
14479 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
14480 }
14481 checkpoint_frequency__ =
14482 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14483 ;
14484 }
14485 GeneratedField::SstableSizeMb => {
14486 if sstable_size_mb__.is_some() {
14487 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
14488 }
14489 sstable_size_mb__ =
14490 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14491 ;
14492 }
14493 GeneratedField::BlockSizeKb => {
14494 if block_size_kb__.is_some() {
14495 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
14496 }
14497 block_size_kb__ =
14498 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14499 ;
14500 }
14501 GeneratedField::BloomFalsePositive => {
14502 if bloom_false_positive__.is_some() {
14503 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
14504 }
14505 bloom_false_positive__ =
14506 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14507 ;
14508 }
14509 GeneratedField::StateStore => {
14510 if state_store__.is_some() {
14511 return Err(serde::de::Error::duplicate_field("stateStore"));
14512 }
14513 state_store__ = map_.next_value()?;
14514 }
14515 GeneratedField::DataDirectory => {
14516 if data_directory__.is_some() {
14517 return Err(serde::de::Error::duplicate_field("dataDirectory"));
14518 }
14519 data_directory__ = map_.next_value()?;
14520 }
14521 GeneratedField::BackupStorageUrl => {
14522 if backup_storage_url__.is_some() {
14523 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
14524 }
14525 backup_storage_url__ = map_.next_value()?;
14526 }
14527 GeneratedField::BackupStorageDirectory => {
14528 if backup_storage_directory__.is_some() {
14529 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
14530 }
14531 backup_storage_directory__ = map_.next_value()?;
14532 }
14533 GeneratedField::TelemetryEnabled => {
14534 if telemetry_enabled__.is_some() {
14535 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
14536 }
14537 telemetry_enabled__ = map_.next_value()?;
14538 }
14539 GeneratedField::ParallelCompactSizeMb => {
14540 if parallel_compact_size_mb__.is_some() {
14541 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
14542 }
14543 parallel_compact_size_mb__ =
14544 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14545 ;
14546 }
14547 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
14548 if max_concurrent_creating_streaming_jobs__.is_some() {
14549 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
14550 }
14551 max_concurrent_creating_streaming_jobs__ =
14552 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14553 ;
14554 }
14555 GeneratedField::PauseOnNextBootstrap => {
14556 if pause_on_next_bootstrap__.is_some() {
14557 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
14558 }
14559 pause_on_next_bootstrap__ = map_.next_value()?;
14560 }
14561 GeneratedField::WasmStorageUrl => {
14562 if wasm_storage_url__.is_some() {
14563 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
14564 }
14565 wasm_storage_url__ = map_.next_value()?;
14566 }
14567 GeneratedField::EnableTracing => {
14568 if enable_tracing__.is_some() {
14569 return Err(serde::de::Error::duplicate_field("enableTracing"));
14570 }
14571 enable_tracing__ = map_.next_value()?;
14572 }
14573 GeneratedField::UseNewObjectPrefixStrategy => {
14574 if use_new_object_prefix_strategy__.is_some() {
14575 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
14576 }
14577 use_new_object_prefix_strategy__ = map_.next_value()?;
14578 }
14579 GeneratedField::LicenseKey => {
14580 if license_key__.is_some() {
14581 return Err(serde::de::Error::duplicate_field("licenseKey"));
14582 }
14583 license_key__ = map_.next_value()?;
14584 }
14585 GeneratedField::TimeTravelRetentionMs => {
14586 if time_travel_retention_ms__.is_some() {
14587 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
14588 }
14589 time_travel_retention_ms__ =
14590 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14591 ;
14592 }
14593 GeneratedField::AdaptiveParallelismStrategy => {
14594 if adaptive_parallelism_strategy__.is_some() {
14595 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
14596 }
14597 adaptive_parallelism_strategy__ = map_.next_value()?;
14598 }
14599 GeneratedField::PerDatabaseIsolation => {
14600 if per_database_isolation__.is_some() {
14601 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
14602 }
14603 per_database_isolation__ = map_.next_value()?;
14604 }
14605 GeneratedField::EnforceSecret => {
14606 if enforce_secret__.is_some() {
14607 return Err(serde::de::Error::duplicate_field("enforceSecret"));
14608 }
14609 enforce_secret__ = map_.next_value()?;
14610 }
14611 }
14612 }
14613 Ok(SystemParams {
14614 barrier_interval_ms: barrier_interval_ms__,
14615 checkpoint_frequency: checkpoint_frequency__,
14616 sstable_size_mb: sstable_size_mb__,
14617 block_size_kb: block_size_kb__,
14618 bloom_false_positive: bloom_false_positive__,
14619 state_store: state_store__,
14620 data_directory: data_directory__,
14621 backup_storage_url: backup_storage_url__,
14622 backup_storage_directory: backup_storage_directory__,
14623 telemetry_enabled: telemetry_enabled__,
14624 parallel_compact_size_mb: parallel_compact_size_mb__,
14625 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
14626 pause_on_next_bootstrap: pause_on_next_bootstrap__,
14627 wasm_storage_url: wasm_storage_url__,
14628 enable_tracing: enable_tracing__,
14629 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
14630 license_key: license_key__,
14631 time_travel_retention_ms: time_travel_retention_ms__,
14632 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
14633 per_database_isolation: per_database_isolation__,
14634 enforce_secret: enforce_secret__,
14635 })
14636 }
14637 }
14638 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
14639 }
14640}
14641impl serde::Serialize for TableFragments {
14642 #[allow(deprecated)]
14643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14644 where
14645 S: serde::Serializer,
14646 {
14647 use serde::ser::SerializeStruct;
14648 let mut len = 0;
14649 if self.table_id != 0 {
14650 len += 1;
14651 }
14652 if self.state != 0 {
14653 len += 1;
14654 }
14655 if !self.fragments.is_empty() {
14656 len += 1;
14657 }
14658 if !self.actor_status.is_empty() {
14659 len += 1;
14660 }
14661 if !self.actor_splits.is_empty() {
14662 len += 1;
14663 }
14664 if self.ctx.is_some() {
14665 len += 1;
14666 }
14667 if self.parallelism.is_some() {
14668 len += 1;
14669 }
14670 if self.max_parallelism.is_some() {
14671 len += 1;
14672 }
14673 if !self.node_label.is_empty() {
14674 len += 1;
14675 }
14676 if self.backfill_done {
14677 len += 1;
14678 }
14679 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
14680 if self.table_id != 0 {
14681 struct_ser.serialize_field("tableId", &self.table_id)?;
14682 }
14683 if self.state != 0 {
14684 let v = table_fragments::State::try_from(self.state)
14685 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
14686 struct_ser.serialize_field("state", &v)?;
14687 }
14688 if !self.fragments.is_empty() {
14689 struct_ser.serialize_field("fragments", &self.fragments)?;
14690 }
14691 if !self.actor_status.is_empty() {
14692 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
14693 }
14694 if !self.actor_splits.is_empty() {
14695 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14696 }
14697 if let Some(v) = self.ctx.as_ref() {
14698 struct_ser.serialize_field("ctx", v)?;
14699 }
14700 if let Some(v) = self.parallelism.as_ref() {
14701 struct_ser.serialize_field("parallelism", v)?;
14702 }
14703 if let Some(v) = self.max_parallelism.as_ref() {
14704 struct_ser.serialize_field("maxParallelism", v)?;
14705 }
14706 if !self.node_label.is_empty() {
14707 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
14708 }
14709 if self.backfill_done {
14710 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
14711 }
14712 struct_ser.end()
14713 }
14714}
14715impl<'de> serde::Deserialize<'de> for TableFragments {
14716 #[allow(deprecated)]
14717 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14718 where
14719 D: serde::Deserializer<'de>,
14720 {
14721 const FIELDS: &[&str] = &[
14722 "table_id",
14723 "tableId",
14724 "state",
14725 "fragments",
14726 "actor_status",
14727 "actorStatus",
14728 "actor_splits",
14729 "actorSplits",
14730 "ctx",
14731 "parallelism",
14732 "max_parallelism",
14733 "maxParallelism",
14734 "node_label",
14735 "nodeLabel",
14736 "backfill_done",
14737 "backfillDone",
14738 ];
14739
14740 #[allow(clippy::enum_variant_names)]
14741 enum GeneratedField {
14742 TableId,
14743 State,
14744 Fragments,
14745 ActorStatus,
14746 ActorSplits,
14747 Ctx,
14748 Parallelism,
14749 MaxParallelism,
14750 NodeLabel,
14751 BackfillDone,
14752 }
14753 impl<'de> serde::Deserialize<'de> for GeneratedField {
14754 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14755 where
14756 D: serde::Deserializer<'de>,
14757 {
14758 struct GeneratedVisitor;
14759
14760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14761 type Value = GeneratedField;
14762
14763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14764 write!(formatter, "expected one of: {:?}", &FIELDS)
14765 }
14766
14767 #[allow(unused_variables)]
14768 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14769 where
14770 E: serde::de::Error,
14771 {
14772 match value {
14773 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14774 "state" => Ok(GeneratedField::State),
14775 "fragments" => Ok(GeneratedField::Fragments),
14776 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
14777 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14778 "ctx" => Ok(GeneratedField::Ctx),
14779 "parallelism" => Ok(GeneratedField::Parallelism),
14780 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
14781 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
14782 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
14783 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14784 }
14785 }
14786 }
14787 deserializer.deserialize_identifier(GeneratedVisitor)
14788 }
14789 }
14790 struct GeneratedVisitor;
14791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14792 type Value = TableFragments;
14793
14794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14795 formatter.write_str("struct meta.TableFragments")
14796 }
14797
14798 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
14799 where
14800 V: serde::de::MapAccess<'de>,
14801 {
14802 let mut table_id__ = None;
14803 let mut state__ = None;
14804 let mut fragments__ = None;
14805 let mut actor_status__ = None;
14806 let mut actor_splits__ = None;
14807 let mut ctx__ = None;
14808 let mut parallelism__ = None;
14809 let mut max_parallelism__ = None;
14810 let mut node_label__ = None;
14811 let mut backfill_done__ = None;
14812 while let Some(k) = map_.next_key()? {
14813 match k {
14814 GeneratedField::TableId => {
14815 if table_id__.is_some() {
14816 return Err(serde::de::Error::duplicate_field("tableId"));
14817 }
14818 table_id__ =
14819 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14820 ;
14821 }
14822 GeneratedField::State => {
14823 if state__.is_some() {
14824 return Err(serde::de::Error::duplicate_field("state"));
14825 }
14826 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
14827 }
14828 GeneratedField::Fragments => {
14829 if fragments__.is_some() {
14830 return Err(serde::de::Error::duplicate_field("fragments"));
14831 }
14832 fragments__ = Some(
14833 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14834 .into_iter().map(|(k,v)| (k.0, v)).collect()
14835 );
14836 }
14837 GeneratedField::ActorStatus => {
14838 if actor_status__.is_some() {
14839 return Err(serde::de::Error::duplicate_field("actorStatus"));
14840 }
14841 actor_status__ = Some(
14842 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14843 .into_iter().map(|(k,v)| (k.0, v)).collect()
14844 );
14845 }
14846 GeneratedField::ActorSplits => {
14847 if actor_splits__.is_some() {
14848 return Err(serde::de::Error::duplicate_field("actorSplits"));
14849 }
14850 actor_splits__ = Some(
14851 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14852 .into_iter().map(|(k,v)| (k.0, v)).collect()
14853 );
14854 }
14855 GeneratedField::Ctx => {
14856 if ctx__.is_some() {
14857 return Err(serde::de::Error::duplicate_field("ctx"));
14858 }
14859 ctx__ = map_.next_value()?;
14860 }
14861 GeneratedField::Parallelism => {
14862 if parallelism__.is_some() {
14863 return Err(serde::de::Error::duplicate_field("parallelism"));
14864 }
14865 parallelism__ = map_.next_value()?;
14866 }
14867 GeneratedField::MaxParallelism => {
14868 if max_parallelism__.is_some() {
14869 return Err(serde::de::Error::duplicate_field("maxParallelism"));
14870 }
14871 max_parallelism__ =
14872 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14873 ;
14874 }
14875 GeneratedField::NodeLabel => {
14876 if node_label__.is_some() {
14877 return Err(serde::de::Error::duplicate_field("nodeLabel"));
14878 }
14879 node_label__ = Some(map_.next_value()?);
14880 }
14881 GeneratedField::BackfillDone => {
14882 if backfill_done__.is_some() {
14883 return Err(serde::de::Error::duplicate_field("backfillDone"));
14884 }
14885 backfill_done__ = Some(map_.next_value()?);
14886 }
14887 }
14888 }
14889 Ok(TableFragments {
14890 table_id: table_id__.unwrap_or_default(),
14891 state: state__.unwrap_or_default(),
14892 fragments: fragments__.unwrap_or_default(),
14893 actor_status: actor_status__.unwrap_or_default(),
14894 actor_splits: actor_splits__.unwrap_or_default(),
14895 ctx: ctx__,
14896 parallelism: parallelism__,
14897 max_parallelism: max_parallelism__,
14898 node_label: node_label__.unwrap_or_default(),
14899 backfill_done: backfill_done__.unwrap_or_default(),
14900 })
14901 }
14902 }
14903 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
14904 }
14905}
14906impl serde::Serialize for table_fragments::ActorStatus {
14907 #[allow(deprecated)]
14908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14909 where
14910 S: serde::Serializer,
14911 {
14912 use serde::ser::SerializeStruct;
14913 let mut len = 0;
14914 if self.location.is_some() {
14915 len += 1;
14916 }
14917 if self.state != 0 {
14918 len += 1;
14919 }
14920 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
14921 if let Some(v) = self.location.as_ref() {
14922 struct_ser.serialize_field("location", v)?;
14923 }
14924 if self.state != 0 {
14925 let v = table_fragments::actor_status::ActorState::try_from(self.state)
14926 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
14927 struct_ser.serialize_field("state", &v)?;
14928 }
14929 struct_ser.end()
14930 }
14931}
14932impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
14933 #[allow(deprecated)]
14934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14935 where
14936 D: serde::Deserializer<'de>,
14937 {
14938 const FIELDS: &[&str] = &[
14939 "location",
14940 "state",
14941 ];
14942
14943 #[allow(clippy::enum_variant_names)]
14944 enum GeneratedField {
14945 Location,
14946 State,
14947 }
14948 impl<'de> serde::Deserialize<'de> for GeneratedField {
14949 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14950 where
14951 D: serde::Deserializer<'de>,
14952 {
14953 struct GeneratedVisitor;
14954
14955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14956 type Value = GeneratedField;
14957
14958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14959 write!(formatter, "expected one of: {:?}", &FIELDS)
14960 }
14961
14962 #[allow(unused_variables)]
14963 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14964 where
14965 E: serde::de::Error,
14966 {
14967 match value {
14968 "location" => Ok(GeneratedField::Location),
14969 "state" => Ok(GeneratedField::State),
14970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14971 }
14972 }
14973 }
14974 deserializer.deserialize_identifier(GeneratedVisitor)
14975 }
14976 }
14977 struct GeneratedVisitor;
14978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14979 type Value = table_fragments::ActorStatus;
14980
14981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14982 formatter.write_str("struct meta.TableFragments.ActorStatus")
14983 }
14984
14985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
14986 where
14987 V: serde::de::MapAccess<'de>,
14988 {
14989 let mut location__ = None;
14990 let mut state__ = None;
14991 while let Some(k) = map_.next_key()? {
14992 match k {
14993 GeneratedField::Location => {
14994 if location__.is_some() {
14995 return Err(serde::de::Error::duplicate_field("location"));
14996 }
14997 location__ = map_.next_value()?;
14998 }
14999 GeneratedField::State => {
15000 if state__.is_some() {
15001 return Err(serde::de::Error::duplicate_field("state"));
15002 }
15003 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15004 }
15005 }
15006 }
15007 Ok(table_fragments::ActorStatus {
15008 location: location__,
15009 state: state__.unwrap_or_default(),
15010 })
15011 }
15012 }
15013 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15014 }
15015}
15016impl serde::Serialize for table_fragments::actor_status::ActorState {
15017 #[allow(deprecated)]
15018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15019 where
15020 S: serde::Serializer,
15021 {
15022 let variant = match self {
15023 Self::Unspecified => "UNSPECIFIED",
15024 Self::Inactive => "INACTIVE",
15025 Self::Running => "RUNNING",
15026 };
15027 serializer.serialize_str(variant)
15028 }
15029}
15030impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15031 #[allow(deprecated)]
15032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15033 where
15034 D: serde::Deserializer<'de>,
15035 {
15036 const FIELDS: &[&str] = &[
15037 "UNSPECIFIED",
15038 "INACTIVE",
15039 "RUNNING",
15040 ];
15041
15042 struct GeneratedVisitor;
15043
15044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15045 type Value = table_fragments::actor_status::ActorState;
15046
15047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15048 write!(formatter, "expected one of: {:?}", &FIELDS)
15049 }
15050
15051 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15052 where
15053 E: serde::de::Error,
15054 {
15055 i32::try_from(v)
15056 .ok()
15057 .and_then(|x| x.try_into().ok())
15058 .ok_or_else(|| {
15059 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15060 })
15061 }
15062
15063 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15064 where
15065 E: serde::de::Error,
15066 {
15067 i32::try_from(v)
15068 .ok()
15069 .and_then(|x| x.try_into().ok())
15070 .ok_or_else(|| {
15071 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15072 })
15073 }
15074
15075 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15076 where
15077 E: serde::de::Error,
15078 {
15079 match value {
15080 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15081 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15082 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15083 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15084 }
15085 }
15086 }
15087 deserializer.deserialize_any(GeneratedVisitor)
15088 }
15089}
15090impl serde::Serialize for table_fragments::Fragment {
15091 #[allow(deprecated)]
15092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15093 where
15094 S: serde::Serializer,
15095 {
15096 use serde::ser::SerializeStruct;
15097 let mut len = 0;
15098 if self.fragment_id != 0 {
15099 len += 1;
15100 }
15101 if self.fragment_type_mask != 0 {
15102 len += 1;
15103 }
15104 if self.distribution_type != 0 {
15105 len += 1;
15106 }
15107 if !self.actors.is_empty() {
15108 len += 1;
15109 }
15110 if !self.state_table_ids.is_empty() {
15111 len += 1;
15112 }
15113 if !self.upstream_fragment_ids.is_empty() {
15114 len += 1;
15115 }
15116 if self.maybe_vnode_count.is_some() {
15117 len += 1;
15118 }
15119 if self.nodes.is_some() {
15120 len += 1;
15121 }
15122 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15123 if self.fragment_id != 0 {
15124 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15125 }
15126 if self.fragment_type_mask != 0 {
15127 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15128 }
15129 if self.distribution_type != 0 {
15130 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15131 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15132 struct_ser.serialize_field("distributionType", &v)?;
15133 }
15134 if !self.actors.is_empty() {
15135 struct_ser.serialize_field("actors", &self.actors)?;
15136 }
15137 if !self.state_table_ids.is_empty() {
15138 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
15139 }
15140 if !self.upstream_fragment_ids.is_empty() {
15141 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
15142 }
15143 if let Some(v) = self.maybe_vnode_count.as_ref() {
15144 struct_ser.serialize_field("maybeVnodeCount", v)?;
15145 }
15146 if let Some(v) = self.nodes.as_ref() {
15147 struct_ser.serialize_field("nodes", v)?;
15148 }
15149 struct_ser.end()
15150 }
15151}
15152impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
15153 #[allow(deprecated)]
15154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15155 where
15156 D: serde::Deserializer<'de>,
15157 {
15158 const FIELDS: &[&str] = &[
15159 "fragment_id",
15160 "fragmentId",
15161 "fragment_type_mask",
15162 "fragmentTypeMask",
15163 "distribution_type",
15164 "distributionType",
15165 "actors",
15166 "state_table_ids",
15167 "stateTableIds",
15168 "upstream_fragment_ids",
15169 "upstreamFragmentIds",
15170 "maybe_vnode_count",
15171 "maybeVnodeCount",
15172 "nodes",
15173 ];
15174
15175 #[allow(clippy::enum_variant_names)]
15176 enum GeneratedField {
15177 FragmentId,
15178 FragmentTypeMask,
15179 DistributionType,
15180 Actors,
15181 StateTableIds,
15182 UpstreamFragmentIds,
15183 MaybeVnodeCount,
15184 Nodes,
15185 }
15186 impl<'de> serde::Deserialize<'de> for GeneratedField {
15187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15188 where
15189 D: serde::Deserializer<'de>,
15190 {
15191 struct GeneratedVisitor;
15192
15193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15194 type Value = GeneratedField;
15195
15196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15197 write!(formatter, "expected one of: {:?}", &FIELDS)
15198 }
15199
15200 #[allow(unused_variables)]
15201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15202 where
15203 E: serde::de::Error,
15204 {
15205 match value {
15206 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15207 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15208 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
15209 "actors" => Ok(GeneratedField::Actors),
15210 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
15211 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
15212 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
15213 "nodes" => Ok(GeneratedField::Nodes),
15214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15215 }
15216 }
15217 }
15218 deserializer.deserialize_identifier(GeneratedVisitor)
15219 }
15220 }
15221 struct GeneratedVisitor;
15222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15223 type Value = table_fragments::Fragment;
15224
15225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15226 formatter.write_str("struct meta.TableFragments.Fragment")
15227 }
15228
15229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
15230 where
15231 V: serde::de::MapAccess<'de>,
15232 {
15233 let mut fragment_id__ = None;
15234 let mut fragment_type_mask__ = None;
15235 let mut distribution_type__ = None;
15236 let mut actors__ = None;
15237 let mut state_table_ids__ = None;
15238 let mut upstream_fragment_ids__ = None;
15239 let mut maybe_vnode_count__ = None;
15240 let mut nodes__ = None;
15241 while let Some(k) = map_.next_key()? {
15242 match k {
15243 GeneratedField::FragmentId => {
15244 if fragment_id__.is_some() {
15245 return Err(serde::de::Error::duplicate_field("fragmentId"));
15246 }
15247 fragment_id__ =
15248 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15249 ;
15250 }
15251 GeneratedField::FragmentTypeMask => {
15252 if fragment_type_mask__.is_some() {
15253 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
15254 }
15255 fragment_type_mask__ =
15256 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15257 ;
15258 }
15259 GeneratedField::DistributionType => {
15260 if distribution_type__.is_some() {
15261 return Err(serde::de::Error::duplicate_field("distributionType"));
15262 }
15263 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
15264 }
15265 GeneratedField::Actors => {
15266 if actors__.is_some() {
15267 return Err(serde::de::Error::duplicate_field("actors"));
15268 }
15269 actors__ = Some(map_.next_value()?);
15270 }
15271 GeneratedField::StateTableIds => {
15272 if state_table_ids__.is_some() {
15273 return Err(serde::de::Error::duplicate_field("stateTableIds"));
15274 }
15275 state_table_ids__ =
15276 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15277 .into_iter().map(|x| x.0).collect())
15278 ;
15279 }
15280 GeneratedField::UpstreamFragmentIds => {
15281 if upstream_fragment_ids__.is_some() {
15282 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
15283 }
15284 upstream_fragment_ids__ =
15285 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15286 .into_iter().map(|x| x.0).collect())
15287 ;
15288 }
15289 GeneratedField::MaybeVnodeCount => {
15290 if maybe_vnode_count__.is_some() {
15291 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
15292 }
15293 maybe_vnode_count__ =
15294 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15295 ;
15296 }
15297 GeneratedField::Nodes => {
15298 if nodes__.is_some() {
15299 return Err(serde::de::Error::duplicate_field("nodes"));
15300 }
15301 nodes__ = map_.next_value()?;
15302 }
15303 }
15304 }
15305 Ok(table_fragments::Fragment {
15306 fragment_id: fragment_id__.unwrap_or_default(),
15307 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
15308 distribution_type: distribution_type__.unwrap_or_default(),
15309 actors: actors__.unwrap_or_default(),
15310 state_table_ids: state_table_ids__.unwrap_or_default(),
15311 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
15312 maybe_vnode_count: maybe_vnode_count__,
15313 nodes: nodes__,
15314 })
15315 }
15316 }
15317 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
15318 }
15319}
15320impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
15321 #[allow(deprecated)]
15322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15323 where
15324 S: serde::Serializer,
15325 {
15326 let variant = match self {
15327 Self::Unspecified => "UNSPECIFIED",
15328 Self::Single => "SINGLE",
15329 Self::Hash => "HASH",
15330 };
15331 serializer.serialize_str(variant)
15332 }
15333}
15334impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
15335 #[allow(deprecated)]
15336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15337 where
15338 D: serde::Deserializer<'de>,
15339 {
15340 const FIELDS: &[&str] = &[
15341 "UNSPECIFIED",
15342 "SINGLE",
15343 "HASH",
15344 ];
15345
15346 struct GeneratedVisitor;
15347
15348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15349 type Value = table_fragments::fragment::FragmentDistributionType;
15350
15351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15352 write!(formatter, "expected one of: {:?}", &FIELDS)
15353 }
15354
15355 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15356 where
15357 E: serde::de::Error,
15358 {
15359 i32::try_from(v)
15360 .ok()
15361 .and_then(|x| x.try_into().ok())
15362 .ok_or_else(|| {
15363 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15364 })
15365 }
15366
15367 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15368 where
15369 E: serde::de::Error,
15370 {
15371 i32::try_from(v)
15372 .ok()
15373 .and_then(|x| x.try_into().ok())
15374 .ok_or_else(|| {
15375 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15376 })
15377 }
15378
15379 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15380 where
15381 E: serde::de::Error,
15382 {
15383 match value {
15384 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
15385 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
15386 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
15387 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15388 }
15389 }
15390 }
15391 deserializer.deserialize_any(GeneratedVisitor)
15392 }
15393}
15394impl serde::Serialize for table_fragments::State {
15395 #[allow(deprecated)]
15396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15397 where
15398 S: serde::Serializer,
15399 {
15400 let variant = match self {
15401 Self::Unspecified => "UNSPECIFIED",
15402 Self::Initial => "INITIAL",
15403 Self::Creating => "CREATING",
15404 Self::Created => "CREATED",
15405 };
15406 serializer.serialize_str(variant)
15407 }
15408}
15409impl<'de> serde::Deserialize<'de> for table_fragments::State {
15410 #[allow(deprecated)]
15411 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15412 where
15413 D: serde::Deserializer<'de>,
15414 {
15415 const FIELDS: &[&str] = &[
15416 "UNSPECIFIED",
15417 "INITIAL",
15418 "CREATING",
15419 "CREATED",
15420 ];
15421
15422 struct GeneratedVisitor;
15423
15424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15425 type Value = table_fragments::State;
15426
15427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15428 write!(formatter, "expected one of: {:?}", &FIELDS)
15429 }
15430
15431 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15432 where
15433 E: serde::de::Error,
15434 {
15435 i32::try_from(v)
15436 .ok()
15437 .and_then(|x| x.try_into().ok())
15438 .ok_or_else(|| {
15439 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15440 })
15441 }
15442
15443 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15444 where
15445 E: serde::de::Error,
15446 {
15447 i32::try_from(v)
15448 .ok()
15449 .and_then(|x| x.try_into().ok())
15450 .ok_or_else(|| {
15451 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15452 })
15453 }
15454
15455 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15456 where
15457 E: serde::de::Error,
15458 {
15459 match value {
15460 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
15461 "INITIAL" => Ok(table_fragments::State::Initial),
15462 "CREATING" => Ok(table_fragments::State::Creating),
15463 "CREATED" => Ok(table_fragments::State::Created),
15464 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15465 }
15466 }
15467 }
15468 deserializer.deserialize_any(GeneratedVisitor)
15469 }
15470}
15471impl serde::Serialize for TableParallelism {
15472 #[allow(deprecated)]
15473 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15474 where
15475 S: serde::Serializer,
15476 {
15477 use serde::ser::SerializeStruct;
15478 let mut len = 0;
15479 if self.parallelism.is_some() {
15480 len += 1;
15481 }
15482 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
15483 if let Some(v) = self.parallelism.as_ref() {
15484 match v {
15485 table_parallelism::Parallelism::Fixed(v) => {
15486 struct_ser.serialize_field("fixed", v)?;
15487 }
15488 table_parallelism::Parallelism::Auto(v) => {
15489 struct_ser.serialize_field("auto", v)?;
15490 }
15491 table_parallelism::Parallelism::Custom(v) => {
15492 struct_ser.serialize_field("custom", v)?;
15493 }
15494 table_parallelism::Parallelism::Adaptive(v) => {
15495 struct_ser.serialize_field("adaptive", v)?;
15496 }
15497 }
15498 }
15499 struct_ser.end()
15500 }
15501}
15502impl<'de> serde::Deserialize<'de> for TableParallelism {
15503 #[allow(deprecated)]
15504 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15505 where
15506 D: serde::Deserializer<'de>,
15507 {
15508 const FIELDS: &[&str] = &[
15509 "fixed",
15510 "auto",
15511 "custom",
15512 "adaptive",
15513 ];
15514
15515 #[allow(clippy::enum_variant_names)]
15516 enum GeneratedField {
15517 Fixed,
15518 Auto,
15519 Custom,
15520 Adaptive,
15521 }
15522 impl<'de> serde::Deserialize<'de> for GeneratedField {
15523 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15524 where
15525 D: serde::Deserializer<'de>,
15526 {
15527 struct GeneratedVisitor;
15528
15529 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15530 type Value = GeneratedField;
15531
15532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15533 write!(formatter, "expected one of: {:?}", &FIELDS)
15534 }
15535
15536 #[allow(unused_variables)]
15537 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15538 where
15539 E: serde::de::Error,
15540 {
15541 match value {
15542 "fixed" => Ok(GeneratedField::Fixed),
15543 "auto" => Ok(GeneratedField::Auto),
15544 "custom" => Ok(GeneratedField::Custom),
15545 "adaptive" => Ok(GeneratedField::Adaptive),
15546 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15547 }
15548 }
15549 }
15550 deserializer.deserialize_identifier(GeneratedVisitor)
15551 }
15552 }
15553 struct GeneratedVisitor;
15554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15555 type Value = TableParallelism;
15556
15557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15558 formatter.write_str("struct meta.TableParallelism")
15559 }
15560
15561 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
15562 where
15563 V: serde::de::MapAccess<'de>,
15564 {
15565 let mut parallelism__ = None;
15566 while let Some(k) = map_.next_key()? {
15567 match k {
15568 GeneratedField::Fixed => {
15569 if parallelism__.is_some() {
15570 return Err(serde::de::Error::duplicate_field("fixed"));
15571 }
15572 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
15573;
15574 }
15575 GeneratedField::Auto => {
15576 if parallelism__.is_some() {
15577 return Err(serde::de::Error::duplicate_field("auto"));
15578 }
15579 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
15580;
15581 }
15582 GeneratedField::Custom => {
15583 if parallelism__.is_some() {
15584 return Err(serde::de::Error::duplicate_field("custom"));
15585 }
15586 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
15587;
15588 }
15589 GeneratedField::Adaptive => {
15590 if parallelism__.is_some() {
15591 return Err(serde::de::Error::duplicate_field("adaptive"));
15592 }
15593 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
15594;
15595 }
15596 }
15597 }
15598 Ok(TableParallelism {
15599 parallelism: parallelism__,
15600 })
15601 }
15602 }
15603 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
15604 }
15605}
15606impl serde::Serialize for table_parallelism::AdaptiveParallelism {
15607 #[allow(deprecated)]
15608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15609 where
15610 S: serde::Serializer,
15611 {
15612 use serde::ser::SerializeStruct;
15613 let len = 0;
15614 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
15615 struct_ser.end()
15616 }
15617}
15618impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
15619 #[allow(deprecated)]
15620 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15621 where
15622 D: serde::Deserializer<'de>,
15623 {
15624 const FIELDS: &[&str] = &[
15625 ];
15626
15627 #[allow(clippy::enum_variant_names)]
15628 enum GeneratedField {
15629 }
15630 impl<'de> serde::Deserialize<'de> for GeneratedField {
15631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15632 where
15633 D: serde::Deserializer<'de>,
15634 {
15635 struct GeneratedVisitor;
15636
15637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15638 type Value = GeneratedField;
15639
15640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15641 write!(formatter, "expected one of: {:?}", &FIELDS)
15642 }
15643
15644 #[allow(unused_variables)]
15645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15646 where
15647 E: serde::de::Error,
15648 {
15649 Err(serde::de::Error::unknown_field(value, FIELDS))
15650 }
15651 }
15652 deserializer.deserialize_identifier(GeneratedVisitor)
15653 }
15654 }
15655 struct GeneratedVisitor;
15656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15657 type Value = table_parallelism::AdaptiveParallelism;
15658
15659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15660 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
15661 }
15662
15663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
15664 where
15665 V: serde::de::MapAccess<'de>,
15666 {
15667 while map_.next_key::<GeneratedField>()?.is_some() {
15668 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15669 }
15670 Ok(table_parallelism::AdaptiveParallelism {
15671 })
15672 }
15673 }
15674 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
15675 }
15676}
15677impl serde::Serialize for table_parallelism::AutoParallelism {
15678 #[allow(deprecated)]
15679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15680 where
15681 S: serde::Serializer,
15682 {
15683 use serde::ser::SerializeStruct;
15684 let len = 0;
15685 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
15686 struct_ser.end()
15687 }
15688}
15689impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
15690 #[allow(deprecated)]
15691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15692 where
15693 D: serde::Deserializer<'de>,
15694 {
15695 const FIELDS: &[&str] = &[
15696 ];
15697
15698 #[allow(clippy::enum_variant_names)]
15699 enum GeneratedField {
15700 }
15701 impl<'de> serde::Deserialize<'de> for GeneratedField {
15702 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15703 where
15704 D: serde::Deserializer<'de>,
15705 {
15706 struct GeneratedVisitor;
15707
15708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15709 type Value = GeneratedField;
15710
15711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15712 write!(formatter, "expected one of: {:?}", &FIELDS)
15713 }
15714
15715 #[allow(unused_variables)]
15716 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15717 where
15718 E: serde::de::Error,
15719 {
15720 Err(serde::de::Error::unknown_field(value, FIELDS))
15721 }
15722 }
15723 deserializer.deserialize_identifier(GeneratedVisitor)
15724 }
15725 }
15726 struct GeneratedVisitor;
15727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15728 type Value = table_parallelism::AutoParallelism;
15729
15730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15731 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
15732 }
15733
15734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
15735 where
15736 V: serde::de::MapAccess<'de>,
15737 {
15738 while map_.next_key::<GeneratedField>()?.is_some() {
15739 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15740 }
15741 Ok(table_parallelism::AutoParallelism {
15742 })
15743 }
15744 }
15745 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
15746 }
15747}
15748impl serde::Serialize for table_parallelism::CustomParallelism {
15749 #[allow(deprecated)]
15750 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15751 where
15752 S: serde::Serializer,
15753 {
15754 use serde::ser::SerializeStruct;
15755 let len = 0;
15756 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
15757 struct_ser.end()
15758 }
15759}
15760impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
15761 #[allow(deprecated)]
15762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15763 where
15764 D: serde::Deserializer<'de>,
15765 {
15766 const FIELDS: &[&str] = &[
15767 ];
15768
15769 #[allow(clippy::enum_variant_names)]
15770 enum GeneratedField {
15771 }
15772 impl<'de> serde::Deserialize<'de> for GeneratedField {
15773 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15774 where
15775 D: serde::Deserializer<'de>,
15776 {
15777 struct GeneratedVisitor;
15778
15779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15780 type Value = GeneratedField;
15781
15782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15783 write!(formatter, "expected one of: {:?}", &FIELDS)
15784 }
15785
15786 #[allow(unused_variables)]
15787 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15788 where
15789 E: serde::de::Error,
15790 {
15791 Err(serde::de::Error::unknown_field(value, FIELDS))
15792 }
15793 }
15794 deserializer.deserialize_identifier(GeneratedVisitor)
15795 }
15796 }
15797 struct GeneratedVisitor;
15798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15799 type Value = table_parallelism::CustomParallelism;
15800
15801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15802 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
15803 }
15804
15805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
15806 where
15807 V: serde::de::MapAccess<'de>,
15808 {
15809 while map_.next_key::<GeneratedField>()?.is_some() {
15810 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15811 }
15812 Ok(table_parallelism::CustomParallelism {
15813 })
15814 }
15815 }
15816 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
15817 }
15818}
15819impl serde::Serialize for table_parallelism::FixedParallelism {
15820 #[allow(deprecated)]
15821 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15822 where
15823 S: serde::Serializer,
15824 {
15825 use serde::ser::SerializeStruct;
15826 let mut len = 0;
15827 if self.parallelism != 0 {
15828 len += 1;
15829 }
15830 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
15831 if self.parallelism != 0 {
15832 struct_ser.serialize_field("parallelism", &self.parallelism)?;
15833 }
15834 struct_ser.end()
15835 }
15836}
15837impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
15838 #[allow(deprecated)]
15839 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15840 where
15841 D: serde::Deserializer<'de>,
15842 {
15843 const FIELDS: &[&str] = &[
15844 "parallelism",
15845 ];
15846
15847 #[allow(clippy::enum_variant_names)]
15848 enum GeneratedField {
15849 Parallelism,
15850 }
15851 impl<'de> serde::Deserialize<'de> for GeneratedField {
15852 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15853 where
15854 D: serde::Deserializer<'de>,
15855 {
15856 struct GeneratedVisitor;
15857
15858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15859 type Value = GeneratedField;
15860
15861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15862 write!(formatter, "expected one of: {:?}", &FIELDS)
15863 }
15864
15865 #[allow(unused_variables)]
15866 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15867 where
15868 E: serde::de::Error,
15869 {
15870 match value {
15871 "parallelism" => Ok(GeneratedField::Parallelism),
15872 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15873 }
15874 }
15875 }
15876 deserializer.deserialize_identifier(GeneratedVisitor)
15877 }
15878 }
15879 struct GeneratedVisitor;
15880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15881 type Value = table_parallelism::FixedParallelism;
15882
15883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15884 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
15885 }
15886
15887 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
15888 where
15889 V: serde::de::MapAccess<'de>,
15890 {
15891 let mut parallelism__ = None;
15892 while let Some(k) = map_.next_key()? {
15893 match k {
15894 GeneratedField::Parallelism => {
15895 if parallelism__.is_some() {
15896 return Err(serde::de::Error::duplicate_field("parallelism"));
15897 }
15898 parallelism__ =
15899 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15900 ;
15901 }
15902 }
15903 }
15904 Ok(table_parallelism::FixedParallelism {
15905 parallelism: parallelism__.unwrap_or_default(),
15906 })
15907 }
15908 }
15909 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
15910 }
15911}
15912impl serde::Serialize for TelemetryInfoResponse {
15913 #[allow(deprecated)]
15914 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15915 where
15916 S: serde::Serializer,
15917 {
15918 use serde::ser::SerializeStruct;
15919 let mut len = 0;
15920 if self.tracking_id.is_some() {
15921 len += 1;
15922 }
15923 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
15924 if let Some(v) = self.tracking_id.as_ref() {
15925 struct_ser.serialize_field("trackingId", v)?;
15926 }
15927 struct_ser.end()
15928 }
15929}
15930impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
15931 #[allow(deprecated)]
15932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15933 where
15934 D: serde::Deserializer<'de>,
15935 {
15936 const FIELDS: &[&str] = &[
15937 "tracking_id",
15938 "trackingId",
15939 ];
15940
15941 #[allow(clippy::enum_variant_names)]
15942 enum GeneratedField {
15943 TrackingId,
15944 }
15945 impl<'de> serde::Deserialize<'de> for GeneratedField {
15946 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15947 where
15948 D: serde::Deserializer<'de>,
15949 {
15950 struct GeneratedVisitor;
15951
15952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15953 type Value = GeneratedField;
15954
15955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15956 write!(formatter, "expected one of: {:?}", &FIELDS)
15957 }
15958
15959 #[allow(unused_variables)]
15960 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15961 where
15962 E: serde::de::Error,
15963 {
15964 match value {
15965 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
15966 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15967 }
15968 }
15969 }
15970 deserializer.deserialize_identifier(GeneratedVisitor)
15971 }
15972 }
15973 struct GeneratedVisitor;
15974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15975 type Value = TelemetryInfoResponse;
15976
15977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15978 formatter.write_str("struct meta.TelemetryInfoResponse")
15979 }
15980
15981 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
15982 where
15983 V: serde::de::MapAccess<'de>,
15984 {
15985 let mut tracking_id__ = None;
15986 while let Some(k) = map_.next_key()? {
15987 match k {
15988 GeneratedField::TrackingId => {
15989 if tracking_id__.is_some() {
15990 return Err(serde::de::Error::duplicate_field("trackingId"));
15991 }
15992 tracking_id__ = map_.next_value()?;
15993 }
15994 }
15995 }
15996 Ok(TelemetryInfoResponse {
15997 tracking_id: tracking_id__,
15998 })
15999 }
16000 }
16001 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16002 }
16003}
16004impl serde::Serialize for ThrottleTarget {
16005 #[allow(deprecated)]
16006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16007 where
16008 S: serde::Serializer,
16009 {
16010 let variant = match self {
16011 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16012 Self::Source => "SOURCE",
16013 Self::Mv => "MV",
16014 Self::TableWithSource => "TABLE_WITH_SOURCE",
16015 Self::CdcTable => "CDC_TABLE",
16016 Self::TableDml => "TABLE_DML",
16017 Self::Sink => "SINK",
16018 Self::Fragment => "FRAGMENT",
16019 };
16020 serializer.serialize_str(variant)
16021 }
16022}
16023impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16024 #[allow(deprecated)]
16025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16026 where
16027 D: serde::Deserializer<'de>,
16028 {
16029 const FIELDS: &[&str] = &[
16030 "THROTTLE_TARGET_UNSPECIFIED",
16031 "SOURCE",
16032 "MV",
16033 "TABLE_WITH_SOURCE",
16034 "CDC_TABLE",
16035 "TABLE_DML",
16036 "SINK",
16037 "FRAGMENT",
16038 ];
16039
16040 struct GeneratedVisitor;
16041
16042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16043 type Value = ThrottleTarget;
16044
16045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16046 write!(formatter, "expected one of: {:?}", &FIELDS)
16047 }
16048
16049 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16050 where
16051 E: serde::de::Error,
16052 {
16053 i32::try_from(v)
16054 .ok()
16055 .and_then(|x| x.try_into().ok())
16056 .ok_or_else(|| {
16057 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16058 })
16059 }
16060
16061 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16062 where
16063 E: serde::de::Error,
16064 {
16065 i32::try_from(v)
16066 .ok()
16067 .and_then(|x| x.try_into().ok())
16068 .ok_or_else(|| {
16069 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16070 })
16071 }
16072
16073 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16074 where
16075 E: serde::de::Error,
16076 {
16077 match value {
16078 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16079 "SOURCE" => Ok(ThrottleTarget::Source),
16080 "MV" => Ok(ThrottleTarget::Mv),
16081 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16082 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16083 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16084 "SINK" => Ok(ThrottleTarget::Sink),
16085 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16086 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16087 }
16088 }
16089 }
16090 deserializer.deserialize_any(GeneratedVisitor)
16091 }
16092}
16093impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16094 #[allow(deprecated)]
16095 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16096 where
16097 S: serde::Serializer,
16098 {
16099 use serde::ser::SerializeStruct;
16100 let mut len = 0;
16101 if self.id != 0 {
16102 len += 1;
16103 }
16104 if !self.node_label.is_empty() {
16105 len += 1;
16106 }
16107 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16108 if self.id != 0 {
16109 struct_ser.serialize_field("id", &self.id)?;
16110 }
16111 if !self.node_label.is_empty() {
16112 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16113 }
16114 struct_ser.end()
16115 }
16116}
16117impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16118 #[allow(deprecated)]
16119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16120 where
16121 D: serde::Deserializer<'de>,
16122 {
16123 const FIELDS: &[&str] = &[
16124 "id",
16125 "node_label",
16126 "nodeLabel",
16127 ];
16128
16129 #[allow(clippy::enum_variant_names)]
16130 enum GeneratedField {
16131 Id,
16132 NodeLabel,
16133 }
16134 impl<'de> serde::Deserialize<'de> for GeneratedField {
16135 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16136 where
16137 D: serde::Deserializer<'de>,
16138 {
16139 struct GeneratedVisitor;
16140
16141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16142 type Value = GeneratedField;
16143
16144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16145 write!(formatter, "expected one of: {:?}", &FIELDS)
16146 }
16147
16148 #[allow(unused_variables)]
16149 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16150 where
16151 E: serde::de::Error,
16152 {
16153 match value {
16154 "id" => Ok(GeneratedField::Id),
16155 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16157 }
16158 }
16159 }
16160 deserializer.deserialize_identifier(GeneratedVisitor)
16161 }
16162 }
16163 struct GeneratedVisitor;
16164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16165 type Value = UpdateStreamingJobNodeLabelsRequest;
16166
16167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16168 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
16169 }
16170
16171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
16172 where
16173 V: serde::de::MapAccess<'de>,
16174 {
16175 let mut id__ = None;
16176 let mut node_label__ = None;
16177 while let Some(k) = map_.next_key()? {
16178 match k {
16179 GeneratedField::Id => {
16180 if id__.is_some() {
16181 return Err(serde::de::Error::duplicate_field("id"));
16182 }
16183 id__ =
16184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16185 ;
16186 }
16187 GeneratedField::NodeLabel => {
16188 if node_label__.is_some() {
16189 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16190 }
16191 node_label__ = Some(map_.next_value()?);
16192 }
16193 }
16194 }
16195 Ok(UpdateStreamingJobNodeLabelsRequest {
16196 id: id__.unwrap_or_default(),
16197 node_label: node_label__.unwrap_or_default(),
16198 })
16199 }
16200 }
16201 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
16202 }
16203}
16204impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
16205 #[allow(deprecated)]
16206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16207 where
16208 S: serde::Serializer,
16209 {
16210 use serde::ser::SerializeStruct;
16211 let len = 0;
16212 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
16213 struct_ser.end()
16214 }
16215}
16216impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
16217 #[allow(deprecated)]
16218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16219 where
16220 D: serde::Deserializer<'de>,
16221 {
16222 const FIELDS: &[&str] = &[
16223 ];
16224
16225 #[allow(clippy::enum_variant_names)]
16226 enum GeneratedField {
16227 }
16228 impl<'de> serde::Deserialize<'de> for GeneratedField {
16229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16230 where
16231 D: serde::Deserializer<'de>,
16232 {
16233 struct GeneratedVisitor;
16234
16235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16236 type Value = GeneratedField;
16237
16238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16239 write!(formatter, "expected one of: {:?}", &FIELDS)
16240 }
16241
16242 #[allow(unused_variables)]
16243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16244 where
16245 E: serde::de::Error,
16246 {
16247 Err(serde::de::Error::unknown_field(value, FIELDS))
16248 }
16249 }
16250 deserializer.deserialize_identifier(GeneratedVisitor)
16251 }
16252 }
16253 struct GeneratedVisitor;
16254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16255 type Value = UpdateStreamingJobNodeLabelsResponse;
16256
16257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16258 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
16259 }
16260
16261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
16262 where
16263 V: serde::de::MapAccess<'de>,
16264 {
16265 while map_.next_key::<GeneratedField>()?.is_some() {
16266 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16267 }
16268 Ok(UpdateStreamingJobNodeLabelsResponse {
16269 })
16270 }
16271 }
16272 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
16273 }
16274}
16275impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
16276 #[allow(deprecated)]
16277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16278 where
16279 S: serde::Serializer,
16280 {
16281 use serde::ser::SerializeStruct;
16282 let mut len = 0;
16283 if !self.worker_ids.is_empty() {
16284 len += 1;
16285 }
16286 if self.schedulability != 0 {
16287 len += 1;
16288 }
16289 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
16290 if !self.worker_ids.is_empty() {
16291 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
16292 }
16293 if self.schedulability != 0 {
16294 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
16295 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
16296 struct_ser.serialize_field("schedulability", &v)?;
16297 }
16298 struct_ser.end()
16299 }
16300}
16301impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
16302 #[allow(deprecated)]
16303 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16304 where
16305 D: serde::Deserializer<'de>,
16306 {
16307 const FIELDS: &[&str] = &[
16308 "worker_ids",
16309 "workerIds",
16310 "schedulability",
16311 ];
16312
16313 #[allow(clippy::enum_variant_names)]
16314 enum GeneratedField {
16315 WorkerIds,
16316 Schedulability,
16317 }
16318 impl<'de> serde::Deserialize<'de> for GeneratedField {
16319 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16320 where
16321 D: serde::Deserializer<'de>,
16322 {
16323 struct GeneratedVisitor;
16324
16325 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16326 type Value = GeneratedField;
16327
16328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16329 write!(formatter, "expected one of: {:?}", &FIELDS)
16330 }
16331
16332 #[allow(unused_variables)]
16333 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16334 where
16335 E: serde::de::Error,
16336 {
16337 match value {
16338 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
16339 "schedulability" => Ok(GeneratedField::Schedulability),
16340 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16341 }
16342 }
16343 }
16344 deserializer.deserialize_identifier(GeneratedVisitor)
16345 }
16346 }
16347 struct GeneratedVisitor;
16348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16349 type Value = UpdateWorkerNodeSchedulabilityRequest;
16350
16351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16352 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
16353 }
16354
16355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
16356 where
16357 V: serde::de::MapAccess<'de>,
16358 {
16359 let mut worker_ids__ = None;
16360 let mut schedulability__ = None;
16361 while let Some(k) = map_.next_key()? {
16362 match k {
16363 GeneratedField::WorkerIds => {
16364 if worker_ids__.is_some() {
16365 return Err(serde::de::Error::duplicate_field("workerIds"));
16366 }
16367 worker_ids__ =
16368 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16369 .into_iter().map(|x| x.0).collect())
16370 ;
16371 }
16372 GeneratedField::Schedulability => {
16373 if schedulability__.is_some() {
16374 return Err(serde::de::Error::duplicate_field("schedulability"));
16375 }
16376 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
16377 }
16378 }
16379 }
16380 Ok(UpdateWorkerNodeSchedulabilityRequest {
16381 worker_ids: worker_ids__.unwrap_or_default(),
16382 schedulability: schedulability__.unwrap_or_default(),
16383 })
16384 }
16385 }
16386 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
16387 }
16388}
16389impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
16390 #[allow(deprecated)]
16391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16392 where
16393 S: serde::Serializer,
16394 {
16395 let variant = match self {
16396 Self::Unspecified => "UNSPECIFIED",
16397 Self::Schedulable => "SCHEDULABLE",
16398 Self::Unschedulable => "UNSCHEDULABLE",
16399 };
16400 serializer.serialize_str(variant)
16401 }
16402}
16403impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
16404 #[allow(deprecated)]
16405 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16406 where
16407 D: serde::Deserializer<'de>,
16408 {
16409 const FIELDS: &[&str] = &[
16410 "UNSPECIFIED",
16411 "SCHEDULABLE",
16412 "UNSCHEDULABLE",
16413 ];
16414
16415 struct GeneratedVisitor;
16416
16417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16418 type Value = update_worker_node_schedulability_request::Schedulability;
16419
16420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16421 write!(formatter, "expected one of: {:?}", &FIELDS)
16422 }
16423
16424 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16425 where
16426 E: serde::de::Error,
16427 {
16428 i32::try_from(v)
16429 .ok()
16430 .and_then(|x| x.try_into().ok())
16431 .ok_or_else(|| {
16432 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16433 })
16434 }
16435
16436 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16437 where
16438 E: serde::de::Error,
16439 {
16440 i32::try_from(v)
16441 .ok()
16442 .and_then(|x| x.try_into().ok())
16443 .ok_or_else(|| {
16444 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16445 })
16446 }
16447
16448 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16449 where
16450 E: serde::de::Error,
16451 {
16452 match value {
16453 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
16454 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
16455 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
16456 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16457 }
16458 }
16459 }
16460 deserializer.deserialize_any(GeneratedVisitor)
16461 }
16462}
16463impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
16464 #[allow(deprecated)]
16465 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16466 where
16467 S: serde::Serializer,
16468 {
16469 use serde::ser::SerializeStruct;
16470 let mut len = 0;
16471 if self.status.is_some() {
16472 len += 1;
16473 }
16474 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
16475 if let Some(v) = self.status.as_ref() {
16476 struct_ser.serialize_field("status", v)?;
16477 }
16478 struct_ser.end()
16479 }
16480}
16481impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
16482 #[allow(deprecated)]
16483 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16484 where
16485 D: serde::Deserializer<'de>,
16486 {
16487 const FIELDS: &[&str] = &[
16488 "status",
16489 ];
16490
16491 #[allow(clippy::enum_variant_names)]
16492 enum GeneratedField {
16493 Status,
16494 }
16495 impl<'de> serde::Deserialize<'de> for GeneratedField {
16496 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16497 where
16498 D: serde::Deserializer<'de>,
16499 {
16500 struct GeneratedVisitor;
16501
16502 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16503 type Value = GeneratedField;
16504
16505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16506 write!(formatter, "expected one of: {:?}", &FIELDS)
16507 }
16508
16509 #[allow(unused_variables)]
16510 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16511 where
16512 E: serde::de::Error,
16513 {
16514 match value {
16515 "status" => Ok(GeneratedField::Status),
16516 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16517 }
16518 }
16519 }
16520 deserializer.deserialize_identifier(GeneratedVisitor)
16521 }
16522 }
16523 struct GeneratedVisitor;
16524 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16525 type Value = UpdateWorkerNodeSchedulabilityResponse;
16526
16527 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16528 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
16529 }
16530
16531 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
16532 where
16533 V: serde::de::MapAccess<'de>,
16534 {
16535 let mut status__ = None;
16536 while let Some(k) = map_.next_key()? {
16537 match k {
16538 GeneratedField::Status => {
16539 if status__.is_some() {
16540 return Err(serde::de::Error::duplicate_field("status"));
16541 }
16542 status__ = map_.next_value()?;
16543 }
16544 }
16545 }
16546 Ok(UpdateWorkerNodeSchedulabilityResponse {
16547 status: status__,
16548 })
16549 }
16550 }
16551 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
16552 }
16553}
16554impl serde::Serialize for WorkerReschedule {
16555 #[allow(deprecated)]
16556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16557 where
16558 S: serde::Serializer,
16559 {
16560 use serde::ser::SerializeStruct;
16561 let mut len = 0;
16562 if !self.worker_actor_diff.is_empty() {
16563 len += 1;
16564 }
16565 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
16566 if !self.worker_actor_diff.is_empty() {
16567 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
16568 }
16569 struct_ser.end()
16570 }
16571}
16572impl<'de> serde::Deserialize<'de> for WorkerReschedule {
16573 #[allow(deprecated)]
16574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16575 where
16576 D: serde::Deserializer<'de>,
16577 {
16578 const FIELDS: &[&str] = &[
16579 "worker_actor_diff",
16580 "workerActorDiff",
16581 ];
16582
16583 #[allow(clippy::enum_variant_names)]
16584 enum GeneratedField {
16585 WorkerActorDiff,
16586 }
16587 impl<'de> serde::Deserialize<'de> for GeneratedField {
16588 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16589 where
16590 D: serde::Deserializer<'de>,
16591 {
16592 struct GeneratedVisitor;
16593
16594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16595 type Value = GeneratedField;
16596
16597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16598 write!(formatter, "expected one of: {:?}", &FIELDS)
16599 }
16600
16601 #[allow(unused_variables)]
16602 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16603 where
16604 E: serde::de::Error,
16605 {
16606 match value {
16607 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
16608 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16609 }
16610 }
16611 }
16612 deserializer.deserialize_identifier(GeneratedVisitor)
16613 }
16614 }
16615 struct GeneratedVisitor;
16616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16617 type Value = WorkerReschedule;
16618
16619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16620 formatter.write_str("struct meta.WorkerReschedule")
16621 }
16622
16623 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
16624 where
16625 V: serde::de::MapAccess<'de>,
16626 {
16627 let mut worker_actor_diff__ = None;
16628 while let Some(k) = map_.next_key()? {
16629 match k {
16630 GeneratedField::WorkerActorDiff => {
16631 if worker_actor_diff__.is_some() {
16632 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
16633 }
16634 worker_actor_diff__ = Some(
16635 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
16636 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
16637 );
16638 }
16639 }
16640 }
16641 Ok(WorkerReschedule {
16642 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
16643 })
16644 }
16645 }
16646 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
16647 }
16648}