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 ListCreatingFragmentDistributionRequest {
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.ListCreatingFragmentDistributionRequest", len)?;
8585 struct_ser.end()
8586 }
8587}
8588impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
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 = ListCreatingFragmentDistributionRequest;
8628
8629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8630 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
8631 }
8632
8633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, 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(ListCreatingFragmentDistributionRequest {
8641 })
8642 }
8643 }
8644 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8645 }
8646}
8647impl serde::Serialize for ListCreatingFragmentDistributionResponse {
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.ListCreatingFragmentDistributionResponse", 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 ListCreatingFragmentDistributionResponse {
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 = ListCreatingFragmentDistributionResponse;
8710
8711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8712 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
8713 }
8714
8715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, 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(ListCreatingFragmentDistributionResponse {
8731 distributions: distributions__.unwrap_or_default(),
8732 })
8733 }
8734 }
8735 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", 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 if self.database_id != 0 {
10208 len += 1;
10209 }
10210 if self.schema_id != 0 {
10211 len += 1;
10212 }
10213 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10214 if self.table_id != 0 {
10215 struct_ser.serialize_field("tableId", &self.table_id)?;
10216 }
10217 if self.state != 0 {
10218 let v = table_fragments::State::try_from(self.state)
10219 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10220 struct_ser.serialize_field("state", &v)?;
10221 }
10222 if let Some(v) = self.parallelism.as_ref() {
10223 struct_ser.serialize_field("parallelism", v)?;
10224 }
10225 if self.max_parallelism != 0 {
10226 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10227 }
10228 if !self.name.is_empty() {
10229 struct_ser.serialize_field("name", &self.name)?;
10230 }
10231 if !self.resource_group.is_empty() {
10232 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10233 }
10234 if self.database_id != 0 {
10235 struct_ser.serialize_field("databaseId", &self.database_id)?;
10236 }
10237 if self.schema_id != 0 {
10238 struct_ser.serialize_field("schemaId", &self.schema_id)?;
10239 }
10240 struct_ser.end()
10241 }
10242}
10243impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10244 #[allow(deprecated)]
10245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10246 where
10247 D: serde::Deserializer<'de>,
10248 {
10249 const FIELDS: &[&str] = &[
10250 "table_id",
10251 "tableId",
10252 "state",
10253 "parallelism",
10254 "max_parallelism",
10255 "maxParallelism",
10256 "name",
10257 "resource_group",
10258 "resourceGroup",
10259 "database_id",
10260 "databaseId",
10261 "schema_id",
10262 "schemaId",
10263 ];
10264
10265 #[allow(clippy::enum_variant_names)]
10266 enum GeneratedField {
10267 TableId,
10268 State,
10269 Parallelism,
10270 MaxParallelism,
10271 Name,
10272 ResourceGroup,
10273 DatabaseId,
10274 SchemaId,
10275 }
10276 impl<'de> serde::Deserialize<'de> for GeneratedField {
10277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10278 where
10279 D: serde::Deserializer<'de>,
10280 {
10281 struct GeneratedVisitor;
10282
10283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10284 type Value = GeneratedField;
10285
10286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10287 write!(formatter, "expected one of: {:?}", &FIELDS)
10288 }
10289
10290 #[allow(unused_variables)]
10291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10292 where
10293 E: serde::de::Error,
10294 {
10295 match value {
10296 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10297 "state" => Ok(GeneratedField::State),
10298 "parallelism" => Ok(GeneratedField::Parallelism),
10299 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10300 "name" => Ok(GeneratedField::Name),
10301 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10302 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
10303 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
10304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10305 }
10306 }
10307 }
10308 deserializer.deserialize_identifier(GeneratedVisitor)
10309 }
10310 }
10311 struct GeneratedVisitor;
10312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10313 type Value = list_streaming_job_states_response::StreamingJobState;
10314
10315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10316 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10317 }
10318
10319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10320 where
10321 V: serde::de::MapAccess<'de>,
10322 {
10323 let mut table_id__ = None;
10324 let mut state__ = None;
10325 let mut parallelism__ = None;
10326 let mut max_parallelism__ = None;
10327 let mut name__ = None;
10328 let mut resource_group__ = None;
10329 let mut database_id__ = None;
10330 let mut schema_id__ = None;
10331 while let Some(k) = map_.next_key()? {
10332 match k {
10333 GeneratedField::TableId => {
10334 if table_id__.is_some() {
10335 return Err(serde::de::Error::duplicate_field("tableId"));
10336 }
10337 table_id__ =
10338 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10339 ;
10340 }
10341 GeneratedField::State => {
10342 if state__.is_some() {
10343 return Err(serde::de::Error::duplicate_field("state"));
10344 }
10345 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10346 }
10347 GeneratedField::Parallelism => {
10348 if parallelism__.is_some() {
10349 return Err(serde::de::Error::duplicate_field("parallelism"));
10350 }
10351 parallelism__ = map_.next_value()?;
10352 }
10353 GeneratedField::MaxParallelism => {
10354 if max_parallelism__.is_some() {
10355 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10356 }
10357 max_parallelism__ =
10358 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10359 ;
10360 }
10361 GeneratedField::Name => {
10362 if name__.is_some() {
10363 return Err(serde::de::Error::duplicate_field("name"));
10364 }
10365 name__ = Some(map_.next_value()?);
10366 }
10367 GeneratedField::ResourceGroup => {
10368 if resource_group__.is_some() {
10369 return Err(serde::de::Error::duplicate_field("resourceGroup"));
10370 }
10371 resource_group__ = Some(map_.next_value()?);
10372 }
10373 GeneratedField::DatabaseId => {
10374 if database_id__.is_some() {
10375 return Err(serde::de::Error::duplicate_field("databaseId"));
10376 }
10377 database_id__ =
10378 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10379 ;
10380 }
10381 GeneratedField::SchemaId => {
10382 if schema_id__.is_some() {
10383 return Err(serde::de::Error::duplicate_field("schemaId"));
10384 }
10385 schema_id__ =
10386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10387 ;
10388 }
10389 }
10390 }
10391 Ok(list_streaming_job_states_response::StreamingJobState {
10392 table_id: table_id__.unwrap_or_default(),
10393 state: state__.unwrap_or_default(),
10394 parallelism: parallelism__,
10395 max_parallelism: max_parallelism__.unwrap_or_default(),
10396 name: name__.unwrap_or_default(),
10397 resource_group: resource_group__.unwrap_or_default(),
10398 database_id: database_id__.unwrap_or_default(),
10399 schema_id: schema_id__.unwrap_or_default(),
10400 })
10401 }
10402 }
10403 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10404 }
10405}
10406impl serde::Serialize for ListTableFragmentsRequest {
10407 #[allow(deprecated)]
10408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10409 where
10410 S: serde::Serializer,
10411 {
10412 use serde::ser::SerializeStruct;
10413 let mut len = 0;
10414 if !self.table_ids.is_empty() {
10415 len += 1;
10416 }
10417 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10418 if !self.table_ids.is_empty() {
10419 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10420 }
10421 struct_ser.end()
10422 }
10423}
10424impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10425 #[allow(deprecated)]
10426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10427 where
10428 D: serde::Deserializer<'de>,
10429 {
10430 const FIELDS: &[&str] = &[
10431 "table_ids",
10432 "tableIds",
10433 ];
10434
10435 #[allow(clippy::enum_variant_names)]
10436 enum GeneratedField {
10437 TableIds,
10438 }
10439 impl<'de> serde::Deserialize<'de> for GeneratedField {
10440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10441 where
10442 D: serde::Deserializer<'de>,
10443 {
10444 struct GeneratedVisitor;
10445
10446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10447 type Value = GeneratedField;
10448
10449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10450 write!(formatter, "expected one of: {:?}", &FIELDS)
10451 }
10452
10453 #[allow(unused_variables)]
10454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10455 where
10456 E: serde::de::Error,
10457 {
10458 match value {
10459 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10460 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10461 }
10462 }
10463 }
10464 deserializer.deserialize_identifier(GeneratedVisitor)
10465 }
10466 }
10467 struct GeneratedVisitor;
10468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10469 type Value = ListTableFragmentsRequest;
10470
10471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10472 formatter.write_str("struct meta.ListTableFragmentsRequest")
10473 }
10474
10475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10476 where
10477 V: serde::de::MapAccess<'de>,
10478 {
10479 let mut table_ids__ = None;
10480 while let Some(k) = map_.next_key()? {
10481 match k {
10482 GeneratedField::TableIds => {
10483 if table_ids__.is_some() {
10484 return Err(serde::de::Error::duplicate_field("tableIds"));
10485 }
10486 table_ids__ =
10487 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10488 .into_iter().map(|x| x.0).collect())
10489 ;
10490 }
10491 }
10492 }
10493 Ok(ListTableFragmentsRequest {
10494 table_ids: table_ids__.unwrap_or_default(),
10495 })
10496 }
10497 }
10498 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10499 }
10500}
10501impl serde::Serialize for ListTableFragmentsResponse {
10502 #[allow(deprecated)]
10503 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10504 where
10505 S: serde::Serializer,
10506 {
10507 use serde::ser::SerializeStruct;
10508 let mut len = 0;
10509 if !self.table_fragments.is_empty() {
10510 len += 1;
10511 }
10512 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10513 if !self.table_fragments.is_empty() {
10514 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10515 }
10516 struct_ser.end()
10517 }
10518}
10519impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10520 #[allow(deprecated)]
10521 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10522 where
10523 D: serde::Deserializer<'de>,
10524 {
10525 const FIELDS: &[&str] = &[
10526 "table_fragments",
10527 "tableFragments",
10528 ];
10529
10530 #[allow(clippy::enum_variant_names)]
10531 enum GeneratedField {
10532 TableFragments,
10533 }
10534 impl<'de> serde::Deserialize<'de> for GeneratedField {
10535 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10536 where
10537 D: serde::Deserializer<'de>,
10538 {
10539 struct GeneratedVisitor;
10540
10541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10542 type Value = GeneratedField;
10543
10544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10545 write!(formatter, "expected one of: {:?}", &FIELDS)
10546 }
10547
10548 #[allow(unused_variables)]
10549 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10550 where
10551 E: serde::de::Error,
10552 {
10553 match value {
10554 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
10555 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10556 }
10557 }
10558 }
10559 deserializer.deserialize_identifier(GeneratedVisitor)
10560 }
10561 }
10562 struct GeneratedVisitor;
10563 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10564 type Value = ListTableFragmentsResponse;
10565
10566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10567 formatter.write_str("struct meta.ListTableFragmentsResponse")
10568 }
10569
10570 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
10571 where
10572 V: serde::de::MapAccess<'de>,
10573 {
10574 let mut table_fragments__ = None;
10575 while let Some(k) = map_.next_key()? {
10576 match k {
10577 GeneratedField::TableFragments => {
10578 if table_fragments__.is_some() {
10579 return Err(serde::de::Error::duplicate_field("tableFragments"));
10580 }
10581 table_fragments__ = Some(
10582 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10583 .into_iter().map(|(k,v)| (k.0, v)).collect()
10584 );
10585 }
10586 }
10587 }
10588 Ok(ListTableFragmentsResponse {
10589 table_fragments: table_fragments__.unwrap_or_default(),
10590 })
10591 }
10592 }
10593 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
10594 }
10595}
10596impl serde::Serialize for list_table_fragments_response::ActorInfo {
10597 #[allow(deprecated)]
10598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10599 where
10600 S: serde::Serializer,
10601 {
10602 use serde::ser::SerializeStruct;
10603 let mut len = 0;
10604 if self.id != 0 {
10605 len += 1;
10606 }
10607 if self.node.is_some() {
10608 len += 1;
10609 }
10610 if !self.dispatcher.is_empty() {
10611 len += 1;
10612 }
10613 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
10614 if self.id != 0 {
10615 struct_ser.serialize_field("id", &self.id)?;
10616 }
10617 if let Some(v) = self.node.as_ref() {
10618 struct_ser.serialize_field("node", v)?;
10619 }
10620 if !self.dispatcher.is_empty() {
10621 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10622 }
10623 struct_ser.end()
10624 }
10625}
10626impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
10627 #[allow(deprecated)]
10628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10629 where
10630 D: serde::Deserializer<'de>,
10631 {
10632 const FIELDS: &[&str] = &[
10633 "id",
10634 "node",
10635 "dispatcher",
10636 ];
10637
10638 #[allow(clippy::enum_variant_names)]
10639 enum GeneratedField {
10640 Id,
10641 Node,
10642 Dispatcher,
10643 }
10644 impl<'de> serde::Deserialize<'de> for GeneratedField {
10645 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10646 where
10647 D: serde::Deserializer<'de>,
10648 {
10649 struct GeneratedVisitor;
10650
10651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10652 type Value = GeneratedField;
10653
10654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10655 write!(formatter, "expected one of: {:?}", &FIELDS)
10656 }
10657
10658 #[allow(unused_variables)]
10659 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10660 where
10661 E: serde::de::Error,
10662 {
10663 match value {
10664 "id" => Ok(GeneratedField::Id),
10665 "node" => Ok(GeneratedField::Node),
10666 "dispatcher" => Ok(GeneratedField::Dispatcher),
10667 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10668 }
10669 }
10670 }
10671 deserializer.deserialize_identifier(GeneratedVisitor)
10672 }
10673 }
10674 struct GeneratedVisitor;
10675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10676 type Value = list_table_fragments_response::ActorInfo;
10677
10678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10679 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
10680 }
10681
10682 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
10683 where
10684 V: serde::de::MapAccess<'de>,
10685 {
10686 let mut id__ = None;
10687 let mut node__ = None;
10688 let mut dispatcher__ = None;
10689 while let Some(k) = map_.next_key()? {
10690 match k {
10691 GeneratedField::Id => {
10692 if id__.is_some() {
10693 return Err(serde::de::Error::duplicate_field("id"));
10694 }
10695 id__ =
10696 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10697 ;
10698 }
10699 GeneratedField::Node => {
10700 if node__.is_some() {
10701 return Err(serde::de::Error::duplicate_field("node"));
10702 }
10703 node__ = map_.next_value()?;
10704 }
10705 GeneratedField::Dispatcher => {
10706 if dispatcher__.is_some() {
10707 return Err(serde::de::Error::duplicate_field("dispatcher"));
10708 }
10709 dispatcher__ = Some(map_.next_value()?);
10710 }
10711 }
10712 }
10713 Ok(list_table_fragments_response::ActorInfo {
10714 id: id__.unwrap_or_default(),
10715 node: node__,
10716 dispatcher: dispatcher__.unwrap_or_default(),
10717 })
10718 }
10719 }
10720 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
10721 }
10722}
10723impl serde::Serialize for list_table_fragments_response::FragmentInfo {
10724 #[allow(deprecated)]
10725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10726 where
10727 S: serde::Serializer,
10728 {
10729 use serde::ser::SerializeStruct;
10730 let mut len = 0;
10731 if self.id != 0 {
10732 len += 1;
10733 }
10734 if !self.actors.is_empty() {
10735 len += 1;
10736 }
10737 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
10738 if self.id != 0 {
10739 struct_ser.serialize_field("id", &self.id)?;
10740 }
10741 if !self.actors.is_empty() {
10742 struct_ser.serialize_field("actors", &self.actors)?;
10743 }
10744 struct_ser.end()
10745 }
10746}
10747impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
10748 #[allow(deprecated)]
10749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10750 where
10751 D: serde::Deserializer<'de>,
10752 {
10753 const FIELDS: &[&str] = &[
10754 "id",
10755 "actors",
10756 ];
10757
10758 #[allow(clippy::enum_variant_names)]
10759 enum GeneratedField {
10760 Id,
10761 Actors,
10762 }
10763 impl<'de> serde::Deserialize<'de> for GeneratedField {
10764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10765 where
10766 D: serde::Deserializer<'de>,
10767 {
10768 struct GeneratedVisitor;
10769
10770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10771 type Value = GeneratedField;
10772
10773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10774 write!(formatter, "expected one of: {:?}", &FIELDS)
10775 }
10776
10777 #[allow(unused_variables)]
10778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10779 where
10780 E: serde::de::Error,
10781 {
10782 match value {
10783 "id" => Ok(GeneratedField::Id),
10784 "actors" => Ok(GeneratedField::Actors),
10785 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10786 }
10787 }
10788 }
10789 deserializer.deserialize_identifier(GeneratedVisitor)
10790 }
10791 }
10792 struct GeneratedVisitor;
10793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10794 type Value = list_table_fragments_response::FragmentInfo;
10795
10796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10797 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
10798 }
10799
10800 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
10801 where
10802 V: serde::de::MapAccess<'de>,
10803 {
10804 let mut id__ = None;
10805 let mut actors__ = None;
10806 while let Some(k) = map_.next_key()? {
10807 match k {
10808 GeneratedField::Id => {
10809 if id__.is_some() {
10810 return Err(serde::de::Error::duplicate_field("id"));
10811 }
10812 id__ =
10813 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10814 ;
10815 }
10816 GeneratedField::Actors => {
10817 if actors__.is_some() {
10818 return Err(serde::de::Error::duplicate_field("actors"));
10819 }
10820 actors__ = Some(map_.next_value()?);
10821 }
10822 }
10823 }
10824 Ok(list_table_fragments_response::FragmentInfo {
10825 id: id__.unwrap_or_default(),
10826 actors: actors__.unwrap_or_default(),
10827 })
10828 }
10829 }
10830 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
10831 }
10832}
10833impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
10834 #[allow(deprecated)]
10835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10836 where
10837 S: serde::Serializer,
10838 {
10839 use serde::ser::SerializeStruct;
10840 let mut len = 0;
10841 if !self.fragments.is_empty() {
10842 len += 1;
10843 }
10844 if self.ctx.is_some() {
10845 len += 1;
10846 }
10847 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
10848 if !self.fragments.is_empty() {
10849 struct_ser.serialize_field("fragments", &self.fragments)?;
10850 }
10851 if let Some(v) = self.ctx.as_ref() {
10852 struct_ser.serialize_field("ctx", v)?;
10853 }
10854 struct_ser.end()
10855 }
10856}
10857impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
10858 #[allow(deprecated)]
10859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10860 where
10861 D: serde::Deserializer<'de>,
10862 {
10863 const FIELDS: &[&str] = &[
10864 "fragments",
10865 "ctx",
10866 ];
10867
10868 #[allow(clippy::enum_variant_names)]
10869 enum GeneratedField {
10870 Fragments,
10871 Ctx,
10872 }
10873 impl<'de> serde::Deserialize<'de> for GeneratedField {
10874 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10875 where
10876 D: serde::Deserializer<'de>,
10877 {
10878 struct GeneratedVisitor;
10879
10880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10881 type Value = GeneratedField;
10882
10883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10884 write!(formatter, "expected one of: {:?}", &FIELDS)
10885 }
10886
10887 #[allow(unused_variables)]
10888 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10889 where
10890 E: serde::de::Error,
10891 {
10892 match value {
10893 "fragments" => Ok(GeneratedField::Fragments),
10894 "ctx" => Ok(GeneratedField::Ctx),
10895 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10896 }
10897 }
10898 }
10899 deserializer.deserialize_identifier(GeneratedVisitor)
10900 }
10901 }
10902 struct GeneratedVisitor;
10903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10904 type Value = list_table_fragments_response::TableFragmentInfo;
10905
10906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10907 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
10908 }
10909
10910 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
10911 where
10912 V: serde::de::MapAccess<'de>,
10913 {
10914 let mut fragments__ = None;
10915 let mut ctx__ = None;
10916 while let Some(k) = map_.next_key()? {
10917 match k {
10918 GeneratedField::Fragments => {
10919 if fragments__.is_some() {
10920 return Err(serde::de::Error::duplicate_field("fragments"));
10921 }
10922 fragments__ = Some(map_.next_value()?);
10923 }
10924 GeneratedField::Ctx => {
10925 if ctx__.is_some() {
10926 return Err(serde::de::Error::duplicate_field("ctx"));
10927 }
10928 ctx__ = map_.next_value()?;
10929 }
10930 }
10931 }
10932 Ok(list_table_fragments_response::TableFragmentInfo {
10933 fragments: fragments__.unwrap_or_default(),
10934 ctx: ctx__,
10935 })
10936 }
10937 }
10938 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
10939 }
10940}
10941impl serde::Serialize for MembersRequest {
10942 #[allow(deprecated)]
10943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10944 where
10945 S: serde::Serializer,
10946 {
10947 use serde::ser::SerializeStruct;
10948 let len = 0;
10949 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
10950 struct_ser.end()
10951 }
10952}
10953impl<'de> serde::Deserialize<'de> for MembersRequest {
10954 #[allow(deprecated)]
10955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10956 where
10957 D: serde::Deserializer<'de>,
10958 {
10959 const FIELDS: &[&str] = &[
10960 ];
10961
10962 #[allow(clippy::enum_variant_names)]
10963 enum GeneratedField {
10964 }
10965 impl<'de> serde::Deserialize<'de> for GeneratedField {
10966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10967 where
10968 D: serde::Deserializer<'de>,
10969 {
10970 struct GeneratedVisitor;
10971
10972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10973 type Value = GeneratedField;
10974
10975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10976 write!(formatter, "expected one of: {:?}", &FIELDS)
10977 }
10978
10979 #[allow(unused_variables)]
10980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10981 where
10982 E: serde::de::Error,
10983 {
10984 Err(serde::de::Error::unknown_field(value, FIELDS))
10985 }
10986 }
10987 deserializer.deserialize_identifier(GeneratedVisitor)
10988 }
10989 }
10990 struct GeneratedVisitor;
10991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10992 type Value = MembersRequest;
10993
10994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10995 formatter.write_str("struct meta.MembersRequest")
10996 }
10997
10998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
10999 where
11000 V: serde::de::MapAccess<'de>,
11001 {
11002 while map_.next_key::<GeneratedField>()?.is_some() {
11003 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11004 }
11005 Ok(MembersRequest {
11006 })
11007 }
11008 }
11009 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
11010 }
11011}
11012impl serde::Serialize for MembersResponse {
11013 #[allow(deprecated)]
11014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11015 where
11016 S: serde::Serializer,
11017 {
11018 use serde::ser::SerializeStruct;
11019 let mut len = 0;
11020 if !self.members.is_empty() {
11021 len += 1;
11022 }
11023 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
11024 if !self.members.is_empty() {
11025 struct_ser.serialize_field("members", &self.members)?;
11026 }
11027 struct_ser.end()
11028 }
11029}
11030impl<'de> serde::Deserialize<'de> for MembersResponse {
11031 #[allow(deprecated)]
11032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11033 where
11034 D: serde::Deserializer<'de>,
11035 {
11036 const FIELDS: &[&str] = &[
11037 "members",
11038 ];
11039
11040 #[allow(clippy::enum_variant_names)]
11041 enum GeneratedField {
11042 Members,
11043 }
11044 impl<'de> serde::Deserialize<'de> for GeneratedField {
11045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11046 where
11047 D: serde::Deserializer<'de>,
11048 {
11049 struct GeneratedVisitor;
11050
11051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11052 type Value = GeneratedField;
11053
11054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11055 write!(formatter, "expected one of: {:?}", &FIELDS)
11056 }
11057
11058 #[allow(unused_variables)]
11059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11060 where
11061 E: serde::de::Error,
11062 {
11063 match value {
11064 "members" => Ok(GeneratedField::Members),
11065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11066 }
11067 }
11068 }
11069 deserializer.deserialize_identifier(GeneratedVisitor)
11070 }
11071 }
11072 struct GeneratedVisitor;
11073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11074 type Value = MembersResponse;
11075
11076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11077 formatter.write_str("struct meta.MembersResponse")
11078 }
11079
11080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11081 where
11082 V: serde::de::MapAccess<'de>,
11083 {
11084 let mut members__ = None;
11085 while let Some(k) = map_.next_key()? {
11086 match k {
11087 GeneratedField::Members => {
11088 if members__.is_some() {
11089 return Err(serde::de::Error::duplicate_field("members"));
11090 }
11091 members__ = Some(map_.next_value()?);
11092 }
11093 }
11094 }
11095 Ok(MembersResponse {
11096 members: members__.unwrap_or_default(),
11097 })
11098 }
11099 }
11100 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11101 }
11102}
11103impl serde::Serialize for MetaMember {
11104 #[allow(deprecated)]
11105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11106 where
11107 S: serde::Serializer,
11108 {
11109 use serde::ser::SerializeStruct;
11110 let mut len = 0;
11111 if self.address.is_some() {
11112 len += 1;
11113 }
11114 if self.is_leader {
11115 len += 1;
11116 }
11117 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11118 if let Some(v) = self.address.as_ref() {
11119 struct_ser.serialize_field("address", v)?;
11120 }
11121 if self.is_leader {
11122 struct_ser.serialize_field("isLeader", &self.is_leader)?;
11123 }
11124 struct_ser.end()
11125 }
11126}
11127impl<'de> serde::Deserialize<'de> for MetaMember {
11128 #[allow(deprecated)]
11129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11130 where
11131 D: serde::Deserializer<'de>,
11132 {
11133 const FIELDS: &[&str] = &[
11134 "address",
11135 "is_leader",
11136 "isLeader",
11137 ];
11138
11139 #[allow(clippy::enum_variant_names)]
11140 enum GeneratedField {
11141 Address,
11142 IsLeader,
11143 }
11144 impl<'de> serde::Deserialize<'de> for GeneratedField {
11145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11146 where
11147 D: serde::Deserializer<'de>,
11148 {
11149 struct GeneratedVisitor;
11150
11151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11152 type Value = GeneratedField;
11153
11154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11155 write!(formatter, "expected one of: {:?}", &FIELDS)
11156 }
11157
11158 #[allow(unused_variables)]
11159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11160 where
11161 E: serde::de::Error,
11162 {
11163 match value {
11164 "address" => Ok(GeneratedField::Address),
11165 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11167 }
11168 }
11169 }
11170 deserializer.deserialize_identifier(GeneratedVisitor)
11171 }
11172 }
11173 struct GeneratedVisitor;
11174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11175 type Value = MetaMember;
11176
11177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11178 formatter.write_str("struct meta.MetaMember")
11179 }
11180
11181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11182 where
11183 V: serde::de::MapAccess<'de>,
11184 {
11185 let mut address__ = None;
11186 let mut is_leader__ = None;
11187 while let Some(k) = map_.next_key()? {
11188 match k {
11189 GeneratedField::Address => {
11190 if address__.is_some() {
11191 return Err(serde::de::Error::duplicate_field("address"));
11192 }
11193 address__ = map_.next_value()?;
11194 }
11195 GeneratedField::IsLeader => {
11196 if is_leader__.is_some() {
11197 return Err(serde::de::Error::duplicate_field("isLeader"));
11198 }
11199 is_leader__ = Some(map_.next_value()?);
11200 }
11201 }
11202 }
11203 Ok(MetaMember {
11204 address: address__,
11205 is_leader: is_leader__.unwrap_or_default(),
11206 })
11207 }
11208 }
11209 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11210 }
11211}
11212impl serde::Serialize for MetaSnapshot {
11213 #[allow(deprecated)]
11214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11215 where
11216 S: serde::Serializer,
11217 {
11218 use serde::ser::SerializeStruct;
11219 let mut len = 0;
11220 if !self.databases.is_empty() {
11221 len += 1;
11222 }
11223 if !self.schemas.is_empty() {
11224 len += 1;
11225 }
11226 if !self.sources.is_empty() {
11227 len += 1;
11228 }
11229 if !self.sinks.is_empty() {
11230 len += 1;
11231 }
11232 if !self.tables.is_empty() {
11233 len += 1;
11234 }
11235 if !self.indexes.is_empty() {
11236 len += 1;
11237 }
11238 if !self.views.is_empty() {
11239 len += 1;
11240 }
11241 if !self.functions.is_empty() {
11242 len += 1;
11243 }
11244 if !self.connections.is_empty() {
11245 len += 1;
11246 }
11247 if !self.subscriptions.is_empty() {
11248 len += 1;
11249 }
11250 if !self.users.is_empty() {
11251 len += 1;
11252 }
11253 if self.session_params.is_some() {
11254 len += 1;
11255 }
11256 if !self.secrets.is_empty() {
11257 len += 1;
11258 }
11259 if self.compute_node_total_cpu_count != 0 {
11260 len += 1;
11261 }
11262 if !self.nodes.is_empty() {
11263 len += 1;
11264 }
11265 if self.hummock_version.is_some() {
11266 len += 1;
11267 }
11268 if self.meta_backup_manifest_id.is_some() {
11269 len += 1;
11270 }
11271 if self.hummock_write_limits.is_some() {
11272 len += 1;
11273 }
11274 if !self.streaming_worker_slot_mappings.is_empty() {
11275 len += 1;
11276 }
11277 if !self.serving_worker_slot_mappings.is_empty() {
11278 len += 1;
11279 }
11280 if self.version.is_some() {
11281 len += 1;
11282 }
11283 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11284 if !self.databases.is_empty() {
11285 struct_ser.serialize_field("databases", &self.databases)?;
11286 }
11287 if !self.schemas.is_empty() {
11288 struct_ser.serialize_field("schemas", &self.schemas)?;
11289 }
11290 if !self.sources.is_empty() {
11291 struct_ser.serialize_field("sources", &self.sources)?;
11292 }
11293 if !self.sinks.is_empty() {
11294 struct_ser.serialize_field("sinks", &self.sinks)?;
11295 }
11296 if !self.tables.is_empty() {
11297 struct_ser.serialize_field("tables", &self.tables)?;
11298 }
11299 if !self.indexes.is_empty() {
11300 struct_ser.serialize_field("indexes", &self.indexes)?;
11301 }
11302 if !self.views.is_empty() {
11303 struct_ser.serialize_field("views", &self.views)?;
11304 }
11305 if !self.functions.is_empty() {
11306 struct_ser.serialize_field("functions", &self.functions)?;
11307 }
11308 if !self.connections.is_empty() {
11309 struct_ser.serialize_field("connections", &self.connections)?;
11310 }
11311 if !self.subscriptions.is_empty() {
11312 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11313 }
11314 if !self.users.is_empty() {
11315 struct_ser.serialize_field("users", &self.users)?;
11316 }
11317 if let Some(v) = self.session_params.as_ref() {
11318 struct_ser.serialize_field("sessionParams", v)?;
11319 }
11320 if !self.secrets.is_empty() {
11321 struct_ser.serialize_field("secrets", &self.secrets)?;
11322 }
11323 if self.compute_node_total_cpu_count != 0 {
11324 #[allow(clippy::needless_borrow)]
11325 #[allow(clippy::needless_borrows_for_generic_args)]
11326 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11327 }
11328 if !self.nodes.is_empty() {
11329 struct_ser.serialize_field("nodes", &self.nodes)?;
11330 }
11331 if let Some(v) = self.hummock_version.as_ref() {
11332 struct_ser.serialize_field("hummockVersion", v)?;
11333 }
11334 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11335 struct_ser.serialize_field("metaBackupManifestId", v)?;
11336 }
11337 if let Some(v) = self.hummock_write_limits.as_ref() {
11338 struct_ser.serialize_field("hummockWriteLimits", v)?;
11339 }
11340 if !self.streaming_worker_slot_mappings.is_empty() {
11341 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11342 }
11343 if !self.serving_worker_slot_mappings.is_empty() {
11344 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11345 }
11346 if let Some(v) = self.version.as_ref() {
11347 struct_ser.serialize_field("version", v)?;
11348 }
11349 struct_ser.end()
11350 }
11351}
11352impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11353 #[allow(deprecated)]
11354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11355 where
11356 D: serde::Deserializer<'de>,
11357 {
11358 const FIELDS: &[&str] = &[
11359 "databases",
11360 "schemas",
11361 "sources",
11362 "sinks",
11363 "tables",
11364 "indexes",
11365 "views",
11366 "functions",
11367 "connections",
11368 "subscriptions",
11369 "users",
11370 "session_params",
11371 "sessionParams",
11372 "secrets",
11373 "compute_node_total_cpu_count",
11374 "computeNodeTotalCpuCount",
11375 "nodes",
11376 "hummock_version",
11377 "hummockVersion",
11378 "meta_backup_manifest_id",
11379 "metaBackupManifestId",
11380 "hummock_write_limits",
11381 "hummockWriteLimits",
11382 "streaming_worker_slot_mappings",
11383 "streamingWorkerSlotMappings",
11384 "serving_worker_slot_mappings",
11385 "servingWorkerSlotMappings",
11386 "version",
11387 ];
11388
11389 #[allow(clippy::enum_variant_names)]
11390 enum GeneratedField {
11391 Databases,
11392 Schemas,
11393 Sources,
11394 Sinks,
11395 Tables,
11396 Indexes,
11397 Views,
11398 Functions,
11399 Connections,
11400 Subscriptions,
11401 Users,
11402 SessionParams,
11403 Secrets,
11404 ComputeNodeTotalCpuCount,
11405 Nodes,
11406 HummockVersion,
11407 MetaBackupManifestId,
11408 HummockWriteLimits,
11409 StreamingWorkerSlotMappings,
11410 ServingWorkerSlotMappings,
11411 Version,
11412 }
11413 impl<'de> serde::Deserialize<'de> for GeneratedField {
11414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11415 where
11416 D: serde::Deserializer<'de>,
11417 {
11418 struct GeneratedVisitor;
11419
11420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11421 type Value = GeneratedField;
11422
11423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11424 write!(formatter, "expected one of: {:?}", &FIELDS)
11425 }
11426
11427 #[allow(unused_variables)]
11428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11429 where
11430 E: serde::de::Error,
11431 {
11432 match value {
11433 "databases" => Ok(GeneratedField::Databases),
11434 "schemas" => Ok(GeneratedField::Schemas),
11435 "sources" => Ok(GeneratedField::Sources),
11436 "sinks" => Ok(GeneratedField::Sinks),
11437 "tables" => Ok(GeneratedField::Tables),
11438 "indexes" => Ok(GeneratedField::Indexes),
11439 "views" => Ok(GeneratedField::Views),
11440 "functions" => Ok(GeneratedField::Functions),
11441 "connections" => Ok(GeneratedField::Connections),
11442 "subscriptions" => Ok(GeneratedField::Subscriptions),
11443 "users" => Ok(GeneratedField::Users),
11444 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11445 "secrets" => Ok(GeneratedField::Secrets),
11446 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11447 "nodes" => Ok(GeneratedField::Nodes),
11448 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11449 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11450 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11451 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11452 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11453 "version" => Ok(GeneratedField::Version),
11454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11455 }
11456 }
11457 }
11458 deserializer.deserialize_identifier(GeneratedVisitor)
11459 }
11460 }
11461 struct GeneratedVisitor;
11462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11463 type Value = MetaSnapshot;
11464
11465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11466 formatter.write_str("struct meta.MetaSnapshot")
11467 }
11468
11469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11470 where
11471 V: serde::de::MapAccess<'de>,
11472 {
11473 let mut databases__ = None;
11474 let mut schemas__ = None;
11475 let mut sources__ = None;
11476 let mut sinks__ = None;
11477 let mut tables__ = None;
11478 let mut indexes__ = None;
11479 let mut views__ = None;
11480 let mut functions__ = None;
11481 let mut connections__ = None;
11482 let mut subscriptions__ = None;
11483 let mut users__ = None;
11484 let mut session_params__ = None;
11485 let mut secrets__ = None;
11486 let mut compute_node_total_cpu_count__ = None;
11487 let mut nodes__ = None;
11488 let mut hummock_version__ = None;
11489 let mut meta_backup_manifest_id__ = None;
11490 let mut hummock_write_limits__ = None;
11491 let mut streaming_worker_slot_mappings__ = None;
11492 let mut serving_worker_slot_mappings__ = None;
11493 let mut version__ = None;
11494 while let Some(k) = map_.next_key()? {
11495 match k {
11496 GeneratedField::Databases => {
11497 if databases__.is_some() {
11498 return Err(serde::de::Error::duplicate_field("databases"));
11499 }
11500 databases__ = Some(map_.next_value()?);
11501 }
11502 GeneratedField::Schemas => {
11503 if schemas__.is_some() {
11504 return Err(serde::de::Error::duplicate_field("schemas"));
11505 }
11506 schemas__ = Some(map_.next_value()?);
11507 }
11508 GeneratedField::Sources => {
11509 if sources__.is_some() {
11510 return Err(serde::de::Error::duplicate_field("sources"));
11511 }
11512 sources__ = Some(map_.next_value()?);
11513 }
11514 GeneratedField::Sinks => {
11515 if sinks__.is_some() {
11516 return Err(serde::de::Error::duplicate_field("sinks"));
11517 }
11518 sinks__ = Some(map_.next_value()?);
11519 }
11520 GeneratedField::Tables => {
11521 if tables__.is_some() {
11522 return Err(serde::de::Error::duplicate_field("tables"));
11523 }
11524 tables__ = Some(map_.next_value()?);
11525 }
11526 GeneratedField::Indexes => {
11527 if indexes__.is_some() {
11528 return Err(serde::de::Error::duplicate_field("indexes"));
11529 }
11530 indexes__ = Some(map_.next_value()?);
11531 }
11532 GeneratedField::Views => {
11533 if views__.is_some() {
11534 return Err(serde::de::Error::duplicate_field("views"));
11535 }
11536 views__ = Some(map_.next_value()?);
11537 }
11538 GeneratedField::Functions => {
11539 if functions__.is_some() {
11540 return Err(serde::de::Error::duplicate_field("functions"));
11541 }
11542 functions__ = Some(map_.next_value()?);
11543 }
11544 GeneratedField::Connections => {
11545 if connections__.is_some() {
11546 return Err(serde::de::Error::duplicate_field("connections"));
11547 }
11548 connections__ = Some(map_.next_value()?);
11549 }
11550 GeneratedField::Subscriptions => {
11551 if subscriptions__.is_some() {
11552 return Err(serde::de::Error::duplicate_field("subscriptions"));
11553 }
11554 subscriptions__ = Some(map_.next_value()?);
11555 }
11556 GeneratedField::Users => {
11557 if users__.is_some() {
11558 return Err(serde::de::Error::duplicate_field("users"));
11559 }
11560 users__ = Some(map_.next_value()?);
11561 }
11562 GeneratedField::SessionParams => {
11563 if session_params__.is_some() {
11564 return Err(serde::de::Error::duplicate_field("sessionParams"));
11565 }
11566 session_params__ = map_.next_value()?;
11567 }
11568 GeneratedField::Secrets => {
11569 if secrets__.is_some() {
11570 return Err(serde::de::Error::duplicate_field("secrets"));
11571 }
11572 secrets__ = Some(map_.next_value()?);
11573 }
11574 GeneratedField::ComputeNodeTotalCpuCount => {
11575 if compute_node_total_cpu_count__.is_some() {
11576 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
11577 }
11578 compute_node_total_cpu_count__ =
11579 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11580 ;
11581 }
11582 GeneratedField::Nodes => {
11583 if nodes__.is_some() {
11584 return Err(serde::de::Error::duplicate_field("nodes"));
11585 }
11586 nodes__ = Some(map_.next_value()?);
11587 }
11588 GeneratedField::HummockVersion => {
11589 if hummock_version__.is_some() {
11590 return Err(serde::de::Error::duplicate_field("hummockVersion"));
11591 }
11592 hummock_version__ = map_.next_value()?;
11593 }
11594 GeneratedField::MetaBackupManifestId => {
11595 if meta_backup_manifest_id__.is_some() {
11596 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
11597 }
11598 meta_backup_manifest_id__ = map_.next_value()?;
11599 }
11600 GeneratedField::HummockWriteLimits => {
11601 if hummock_write_limits__.is_some() {
11602 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
11603 }
11604 hummock_write_limits__ = map_.next_value()?;
11605 }
11606 GeneratedField::StreamingWorkerSlotMappings => {
11607 if streaming_worker_slot_mappings__.is_some() {
11608 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
11609 }
11610 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
11611 }
11612 GeneratedField::ServingWorkerSlotMappings => {
11613 if serving_worker_slot_mappings__.is_some() {
11614 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
11615 }
11616 serving_worker_slot_mappings__ = Some(map_.next_value()?);
11617 }
11618 GeneratedField::Version => {
11619 if version__.is_some() {
11620 return Err(serde::de::Error::duplicate_field("version"));
11621 }
11622 version__ = map_.next_value()?;
11623 }
11624 }
11625 }
11626 Ok(MetaSnapshot {
11627 databases: databases__.unwrap_or_default(),
11628 schemas: schemas__.unwrap_or_default(),
11629 sources: sources__.unwrap_or_default(),
11630 sinks: sinks__.unwrap_or_default(),
11631 tables: tables__.unwrap_or_default(),
11632 indexes: indexes__.unwrap_or_default(),
11633 views: views__.unwrap_or_default(),
11634 functions: functions__.unwrap_or_default(),
11635 connections: connections__.unwrap_or_default(),
11636 subscriptions: subscriptions__.unwrap_or_default(),
11637 users: users__.unwrap_or_default(),
11638 session_params: session_params__,
11639 secrets: secrets__.unwrap_or_default(),
11640 compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
11641 nodes: nodes__.unwrap_or_default(),
11642 hummock_version: hummock_version__,
11643 meta_backup_manifest_id: meta_backup_manifest_id__,
11644 hummock_write_limits: hummock_write_limits__,
11645 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
11646 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
11647 version: version__,
11648 })
11649 }
11650 }
11651 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
11652 }
11653}
11654impl serde::Serialize for meta_snapshot::SnapshotVersion {
11655 #[allow(deprecated)]
11656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11657 where
11658 S: serde::Serializer,
11659 {
11660 use serde::ser::SerializeStruct;
11661 let mut len = 0;
11662 if self.catalog_version != 0 {
11663 len += 1;
11664 }
11665 if self.worker_node_version != 0 {
11666 len += 1;
11667 }
11668 if self.streaming_worker_slot_mapping_version != 0 {
11669 len += 1;
11670 }
11671 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
11672 if self.catalog_version != 0 {
11673 #[allow(clippy::needless_borrow)]
11674 #[allow(clippy::needless_borrows_for_generic_args)]
11675 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11676 }
11677 if self.worker_node_version != 0 {
11678 #[allow(clippy::needless_borrow)]
11679 #[allow(clippy::needless_borrows_for_generic_args)]
11680 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
11681 }
11682 if self.streaming_worker_slot_mapping_version != 0 {
11683 #[allow(clippy::needless_borrow)]
11684 #[allow(clippy::needless_borrows_for_generic_args)]
11685 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
11686 }
11687 struct_ser.end()
11688 }
11689}
11690impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
11691 #[allow(deprecated)]
11692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11693 where
11694 D: serde::Deserializer<'de>,
11695 {
11696 const FIELDS: &[&str] = &[
11697 "catalog_version",
11698 "catalogVersion",
11699 "worker_node_version",
11700 "workerNodeVersion",
11701 "streaming_worker_slot_mapping_version",
11702 "streamingWorkerSlotMappingVersion",
11703 ];
11704
11705 #[allow(clippy::enum_variant_names)]
11706 enum GeneratedField {
11707 CatalogVersion,
11708 WorkerNodeVersion,
11709 StreamingWorkerSlotMappingVersion,
11710 }
11711 impl<'de> serde::Deserialize<'de> for GeneratedField {
11712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11713 where
11714 D: serde::Deserializer<'de>,
11715 {
11716 struct GeneratedVisitor;
11717
11718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11719 type Value = GeneratedField;
11720
11721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11722 write!(formatter, "expected one of: {:?}", &FIELDS)
11723 }
11724
11725 #[allow(unused_variables)]
11726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11727 where
11728 E: serde::de::Error,
11729 {
11730 match value {
11731 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
11732 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
11733 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
11734 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11735 }
11736 }
11737 }
11738 deserializer.deserialize_identifier(GeneratedVisitor)
11739 }
11740 }
11741 struct GeneratedVisitor;
11742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11743 type Value = meta_snapshot::SnapshotVersion;
11744
11745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11746 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
11747 }
11748
11749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
11750 where
11751 V: serde::de::MapAccess<'de>,
11752 {
11753 let mut catalog_version__ = None;
11754 let mut worker_node_version__ = None;
11755 let mut streaming_worker_slot_mapping_version__ = None;
11756 while let Some(k) = map_.next_key()? {
11757 match k {
11758 GeneratedField::CatalogVersion => {
11759 if catalog_version__.is_some() {
11760 return Err(serde::de::Error::duplicate_field("catalogVersion"));
11761 }
11762 catalog_version__ =
11763 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11764 ;
11765 }
11766 GeneratedField::WorkerNodeVersion => {
11767 if worker_node_version__.is_some() {
11768 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
11769 }
11770 worker_node_version__ =
11771 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11772 ;
11773 }
11774 GeneratedField::StreamingWorkerSlotMappingVersion => {
11775 if streaming_worker_slot_mapping_version__.is_some() {
11776 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
11777 }
11778 streaming_worker_slot_mapping_version__ =
11779 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11780 ;
11781 }
11782 }
11783 }
11784 Ok(meta_snapshot::SnapshotVersion {
11785 catalog_version: catalog_version__.unwrap_or_default(),
11786 worker_node_version: worker_node_version__.unwrap_or_default(),
11787 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
11788 })
11789 }
11790 }
11791 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
11792 }
11793}
11794impl serde::Serialize for MigrationPlan {
11795 #[allow(deprecated)]
11796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11797 where
11798 S: serde::Serializer,
11799 {
11800 use serde::ser::SerializeStruct;
11801 let mut len = 0;
11802 if !self.worker_slot_migration_plan.is_empty() {
11803 len += 1;
11804 }
11805 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
11806 if !self.worker_slot_migration_plan.is_empty() {
11807 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
11808 .map(|(k, v)| (k, v.to_string())).collect();
11809 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
11810 }
11811 struct_ser.end()
11812 }
11813}
11814impl<'de> serde::Deserialize<'de> for MigrationPlan {
11815 #[allow(deprecated)]
11816 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11817 where
11818 D: serde::Deserializer<'de>,
11819 {
11820 const FIELDS: &[&str] = &[
11821 "worker_slot_migration_plan",
11822 "workerSlotMigrationPlan",
11823 ];
11824
11825 #[allow(clippy::enum_variant_names)]
11826 enum GeneratedField {
11827 WorkerSlotMigrationPlan,
11828 }
11829 impl<'de> serde::Deserialize<'de> for GeneratedField {
11830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11831 where
11832 D: serde::Deserializer<'de>,
11833 {
11834 struct GeneratedVisitor;
11835
11836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11837 type Value = GeneratedField;
11838
11839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11840 write!(formatter, "expected one of: {:?}", &FIELDS)
11841 }
11842
11843 #[allow(unused_variables)]
11844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11845 where
11846 E: serde::de::Error,
11847 {
11848 match value {
11849 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
11850 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11851 }
11852 }
11853 }
11854 deserializer.deserialize_identifier(GeneratedVisitor)
11855 }
11856 }
11857 struct GeneratedVisitor;
11858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11859 type Value = MigrationPlan;
11860
11861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11862 formatter.write_str("struct meta.MigrationPlan")
11863 }
11864
11865 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
11866 where
11867 V: serde::de::MapAccess<'de>,
11868 {
11869 let mut worker_slot_migration_plan__ = None;
11870 while let Some(k) = map_.next_key()? {
11871 match k {
11872 GeneratedField::WorkerSlotMigrationPlan => {
11873 if worker_slot_migration_plan__.is_some() {
11874 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
11875 }
11876 worker_slot_migration_plan__ = Some(
11877 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11878 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
11879 );
11880 }
11881 }
11882 }
11883 Ok(MigrationPlan {
11884 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
11885 })
11886 }
11887 }
11888 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
11889 }
11890}
11891impl serde::Serialize for Object {
11892 #[allow(deprecated)]
11893 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11894 where
11895 S: serde::Serializer,
11896 {
11897 use serde::ser::SerializeStruct;
11898 let mut len = 0;
11899 if self.object_info.is_some() {
11900 len += 1;
11901 }
11902 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
11903 if let Some(v) = self.object_info.as_ref() {
11904 match v {
11905 object::ObjectInfo::Database(v) => {
11906 struct_ser.serialize_field("database", v)?;
11907 }
11908 object::ObjectInfo::Schema(v) => {
11909 struct_ser.serialize_field("schema", v)?;
11910 }
11911 object::ObjectInfo::Table(v) => {
11912 struct_ser.serialize_field("table", v)?;
11913 }
11914 object::ObjectInfo::Index(v) => {
11915 struct_ser.serialize_field("index", v)?;
11916 }
11917 object::ObjectInfo::Source(v) => {
11918 struct_ser.serialize_field("source", v)?;
11919 }
11920 object::ObjectInfo::Sink(v) => {
11921 struct_ser.serialize_field("sink", v)?;
11922 }
11923 object::ObjectInfo::View(v) => {
11924 struct_ser.serialize_field("view", v)?;
11925 }
11926 object::ObjectInfo::Function(v) => {
11927 struct_ser.serialize_field("function", v)?;
11928 }
11929 object::ObjectInfo::Connection(v) => {
11930 struct_ser.serialize_field("connection", v)?;
11931 }
11932 object::ObjectInfo::Subscription(v) => {
11933 struct_ser.serialize_field("subscription", v)?;
11934 }
11935 object::ObjectInfo::Secret(v) => {
11936 struct_ser.serialize_field("secret", v)?;
11937 }
11938 }
11939 }
11940 struct_ser.end()
11941 }
11942}
11943impl<'de> serde::Deserialize<'de> for Object {
11944 #[allow(deprecated)]
11945 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11946 where
11947 D: serde::Deserializer<'de>,
11948 {
11949 const FIELDS: &[&str] = &[
11950 "database",
11951 "schema",
11952 "table",
11953 "index",
11954 "source",
11955 "sink",
11956 "view",
11957 "function",
11958 "connection",
11959 "subscription",
11960 "secret",
11961 ];
11962
11963 #[allow(clippy::enum_variant_names)]
11964 enum GeneratedField {
11965 Database,
11966 Schema,
11967 Table,
11968 Index,
11969 Source,
11970 Sink,
11971 View,
11972 Function,
11973 Connection,
11974 Subscription,
11975 Secret,
11976 }
11977 impl<'de> serde::Deserialize<'de> for GeneratedField {
11978 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11979 where
11980 D: serde::Deserializer<'de>,
11981 {
11982 struct GeneratedVisitor;
11983
11984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11985 type Value = GeneratedField;
11986
11987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11988 write!(formatter, "expected one of: {:?}", &FIELDS)
11989 }
11990
11991 #[allow(unused_variables)]
11992 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11993 where
11994 E: serde::de::Error,
11995 {
11996 match value {
11997 "database" => Ok(GeneratedField::Database),
11998 "schema" => Ok(GeneratedField::Schema),
11999 "table" => Ok(GeneratedField::Table),
12000 "index" => Ok(GeneratedField::Index),
12001 "source" => Ok(GeneratedField::Source),
12002 "sink" => Ok(GeneratedField::Sink),
12003 "view" => Ok(GeneratedField::View),
12004 "function" => Ok(GeneratedField::Function),
12005 "connection" => Ok(GeneratedField::Connection),
12006 "subscription" => Ok(GeneratedField::Subscription),
12007 "secret" => Ok(GeneratedField::Secret),
12008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12009 }
12010 }
12011 }
12012 deserializer.deserialize_identifier(GeneratedVisitor)
12013 }
12014 }
12015 struct GeneratedVisitor;
12016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12017 type Value = Object;
12018
12019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12020 formatter.write_str("struct meta.Object")
12021 }
12022
12023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12024 where
12025 V: serde::de::MapAccess<'de>,
12026 {
12027 let mut object_info__ = None;
12028 while let Some(k) = map_.next_key()? {
12029 match k {
12030 GeneratedField::Database => {
12031 if object_info__.is_some() {
12032 return Err(serde::de::Error::duplicate_field("database"));
12033 }
12034 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12035;
12036 }
12037 GeneratedField::Schema => {
12038 if object_info__.is_some() {
12039 return Err(serde::de::Error::duplicate_field("schema"));
12040 }
12041 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12042;
12043 }
12044 GeneratedField::Table => {
12045 if object_info__.is_some() {
12046 return Err(serde::de::Error::duplicate_field("table"));
12047 }
12048 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12049;
12050 }
12051 GeneratedField::Index => {
12052 if object_info__.is_some() {
12053 return Err(serde::de::Error::duplicate_field("index"));
12054 }
12055 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12056;
12057 }
12058 GeneratedField::Source => {
12059 if object_info__.is_some() {
12060 return Err(serde::de::Error::duplicate_field("source"));
12061 }
12062 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12063;
12064 }
12065 GeneratedField::Sink => {
12066 if object_info__.is_some() {
12067 return Err(serde::de::Error::duplicate_field("sink"));
12068 }
12069 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12070;
12071 }
12072 GeneratedField::View => {
12073 if object_info__.is_some() {
12074 return Err(serde::de::Error::duplicate_field("view"));
12075 }
12076 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12077;
12078 }
12079 GeneratedField::Function => {
12080 if object_info__.is_some() {
12081 return Err(serde::de::Error::duplicate_field("function"));
12082 }
12083 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12084;
12085 }
12086 GeneratedField::Connection => {
12087 if object_info__.is_some() {
12088 return Err(serde::de::Error::duplicate_field("connection"));
12089 }
12090 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12091;
12092 }
12093 GeneratedField::Subscription => {
12094 if object_info__.is_some() {
12095 return Err(serde::de::Error::duplicate_field("subscription"));
12096 }
12097 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12098;
12099 }
12100 GeneratedField::Secret => {
12101 if object_info__.is_some() {
12102 return Err(serde::de::Error::duplicate_field("secret"));
12103 }
12104 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12105;
12106 }
12107 }
12108 }
12109 Ok(Object {
12110 object_info: object_info__,
12111 })
12112 }
12113 }
12114 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12115 }
12116}
12117impl serde::Serialize for ObjectGroup {
12118 #[allow(deprecated)]
12119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12120 where
12121 S: serde::Serializer,
12122 {
12123 use serde::ser::SerializeStruct;
12124 let mut len = 0;
12125 if !self.objects.is_empty() {
12126 len += 1;
12127 }
12128 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12129 if !self.objects.is_empty() {
12130 struct_ser.serialize_field("objects", &self.objects)?;
12131 }
12132 struct_ser.end()
12133 }
12134}
12135impl<'de> serde::Deserialize<'de> for ObjectGroup {
12136 #[allow(deprecated)]
12137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12138 where
12139 D: serde::Deserializer<'de>,
12140 {
12141 const FIELDS: &[&str] = &[
12142 "objects",
12143 ];
12144
12145 #[allow(clippy::enum_variant_names)]
12146 enum GeneratedField {
12147 Objects,
12148 }
12149 impl<'de> serde::Deserialize<'de> for GeneratedField {
12150 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12151 where
12152 D: serde::Deserializer<'de>,
12153 {
12154 struct GeneratedVisitor;
12155
12156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12157 type Value = GeneratedField;
12158
12159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12160 write!(formatter, "expected one of: {:?}", &FIELDS)
12161 }
12162
12163 #[allow(unused_variables)]
12164 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12165 where
12166 E: serde::de::Error,
12167 {
12168 match value {
12169 "objects" => Ok(GeneratedField::Objects),
12170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12171 }
12172 }
12173 }
12174 deserializer.deserialize_identifier(GeneratedVisitor)
12175 }
12176 }
12177 struct GeneratedVisitor;
12178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12179 type Value = ObjectGroup;
12180
12181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12182 formatter.write_str("struct meta.ObjectGroup")
12183 }
12184
12185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12186 where
12187 V: serde::de::MapAccess<'de>,
12188 {
12189 let mut objects__ = None;
12190 while let Some(k) = map_.next_key()? {
12191 match k {
12192 GeneratedField::Objects => {
12193 if objects__.is_some() {
12194 return Err(serde::de::Error::duplicate_field("objects"));
12195 }
12196 objects__ = Some(map_.next_value()?);
12197 }
12198 }
12199 }
12200 Ok(ObjectGroup {
12201 objects: objects__.unwrap_or_default(),
12202 })
12203 }
12204 }
12205 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12206 }
12207}
12208impl serde::Serialize for PauseRequest {
12209 #[allow(deprecated)]
12210 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12211 where
12212 S: serde::Serializer,
12213 {
12214 use serde::ser::SerializeStruct;
12215 let len = 0;
12216 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12217 struct_ser.end()
12218 }
12219}
12220impl<'de> serde::Deserialize<'de> for PauseRequest {
12221 #[allow(deprecated)]
12222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12223 where
12224 D: serde::Deserializer<'de>,
12225 {
12226 const FIELDS: &[&str] = &[
12227 ];
12228
12229 #[allow(clippy::enum_variant_names)]
12230 enum GeneratedField {
12231 }
12232 impl<'de> serde::Deserialize<'de> for GeneratedField {
12233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12234 where
12235 D: serde::Deserializer<'de>,
12236 {
12237 struct GeneratedVisitor;
12238
12239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12240 type Value = GeneratedField;
12241
12242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12243 write!(formatter, "expected one of: {:?}", &FIELDS)
12244 }
12245
12246 #[allow(unused_variables)]
12247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12248 where
12249 E: serde::de::Error,
12250 {
12251 Err(serde::de::Error::unknown_field(value, FIELDS))
12252 }
12253 }
12254 deserializer.deserialize_identifier(GeneratedVisitor)
12255 }
12256 }
12257 struct GeneratedVisitor;
12258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12259 type Value = PauseRequest;
12260
12261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12262 formatter.write_str("struct meta.PauseRequest")
12263 }
12264
12265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12266 where
12267 V: serde::de::MapAccess<'de>,
12268 {
12269 while map_.next_key::<GeneratedField>()?.is_some() {
12270 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12271 }
12272 Ok(PauseRequest {
12273 })
12274 }
12275 }
12276 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12277 }
12278}
12279impl serde::Serialize for PauseResponse {
12280 #[allow(deprecated)]
12281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12282 where
12283 S: serde::Serializer,
12284 {
12285 use serde::ser::SerializeStruct;
12286 let len = 0;
12287 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12288 struct_ser.end()
12289 }
12290}
12291impl<'de> serde::Deserialize<'de> for PauseResponse {
12292 #[allow(deprecated)]
12293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12294 where
12295 D: serde::Deserializer<'de>,
12296 {
12297 const FIELDS: &[&str] = &[
12298 ];
12299
12300 #[allow(clippy::enum_variant_names)]
12301 enum GeneratedField {
12302 }
12303 impl<'de> serde::Deserialize<'de> for GeneratedField {
12304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12305 where
12306 D: serde::Deserializer<'de>,
12307 {
12308 struct GeneratedVisitor;
12309
12310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12311 type Value = GeneratedField;
12312
12313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12314 write!(formatter, "expected one of: {:?}", &FIELDS)
12315 }
12316
12317 #[allow(unused_variables)]
12318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12319 where
12320 E: serde::de::Error,
12321 {
12322 Err(serde::de::Error::unknown_field(value, FIELDS))
12323 }
12324 }
12325 deserializer.deserialize_identifier(GeneratedVisitor)
12326 }
12327 }
12328 struct GeneratedVisitor;
12329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12330 type Value = PauseResponse;
12331
12332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12333 formatter.write_str("struct meta.PauseResponse")
12334 }
12335
12336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12337 where
12338 V: serde::de::MapAccess<'de>,
12339 {
12340 while map_.next_key::<GeneratedField>()?.is_some() {
12341 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12342 }
12343 Ok(PauseResponse {
12344 })
12345 }
12346 }
12347 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12348 }
12349}
12350impl serde::Serialize for RecoverRequest {
12351 #[allow(deprecated)]
12352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12353 where
12354 S: serde::Serializer,
12355 {
12356 use serde::ser::SerializeStruct;
12357 let len = 0;
12358 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12359 struct_ser.end()
12360 }
12361}
12362impl<'de> serde::Deserialize<'de> for RecoverRequest {
12363 #[allow(deprecated)]
12364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12365 where
12366 D: serde::Deserializer<'de>,
12367 {
12368 const FIELDS: &[&str] = &[
12369 ];
12370
12371 #[allow(clippy::enum_variant_names)]
12372 enum GeneratedField {
12373 }
12374 impl<'de> serde::Deserialize<'de> for GeneratedField {
12375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12376 where
12377 D: serde::Deserializer<'de>,
12378 {
12379 struct GeneratedVisitor;
12380
12381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12382 type Value = GeneratedField;
12383
12384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12385 write!(formatter, "expected one of: {:?}", &FIELDS)
12386 }
12387
12388 #[allow(unused_variables)]
12389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12390 where
12391 E: serde::de::Error,
12392 {
12393 Err(serde::de::Error::unknown_field(value, FIELDS))
12394 }
12395 }
12396 deserializer.deserialize_identifier(GeneratedVisitor)
12397 }
12398 }
12399 struct GeneratedVisitor;
12400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12401 type Value = RecoverRequest;
12402
12403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12404 formatter.write_str("struct meta.RecoverRequest")
12405 }
12406
12407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12408 where
12409 V: serde::de::MapAccess<'de>,
12410 {
12411 while map_.next_key::<GeneratedField>()?.is_some() {
12412 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12413 }
12414 Ok(RecoverRequest {
12415 })
12416 }
12417 }
12418 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12419 }
12420}
12421impl serde::Serialize for RecoverResponse {
12422 #[allow(deprecated)]
12423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12424 where
12425 S: serde::Serializer,
12426 {
12427 use serde::ser::SerializeStruct;
12428 let len = 0;
12429 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12430 struct_ser.end()
12431 }
12432}
12433impl<'de> serde::Deserialize<'de> for RecoverResponse {
12434 #[allow(deprecated)]
12435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12436 where
12437 D: serde::Deserializer<'de>,
12438 {
12439 const FIELDS: &[&str] = &[
12440 ];
12441
12442 #[allow(clippy::enum_variant_names)]
12443 enum GeneratedField {
12444 }
12445 impl<'de> serde::Deserialize<'de> for GeneratedField {
12446 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12447 where
12448 D: serde::Deserializer<'de>,
12449 {
12450 struct GeneratedVisitor;
12451
12452 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12453 type Value = GeneratedField;
12454
12455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12456 write!(formatter, "expected one of: {:?}", &FIELDS)
12457 }
12458
12459 #[allow(unused_variables)]
12460 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12461 where
12462 E: serde::de::Error,
12463 {
12464 Err(serde::de::Error::unknown_field(value, FIELDS))
12465 }
12466 }
12467 deserializer.deserialize_identifier(GeneratedVisitor)
12468 }
12469 }
12470 struct GeneratedVisitor;
12471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12472 type Value = RecoverResponse;
12473
12474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12475 formatter.write_str("struct meta.RecoverResponse")
12476 }
12477
12478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12479 where
12480 V: serde::de::MapAccess<'de>,
12481 {
12482 while map_.next_key::<GeneratedField>()?.is_some() {
12483 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12484 }
12485 Ok(RecoverResponse {
12486 })
12487 }
12488 }
12489 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12490 }
12491}
12492impl serde::Serialize for Recovery {
12493 #[allow(deprecated)]
12494 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12495 where
12496 S: serde::Serializer,
12497 {
12498 use serde::ser::SerializeStruct;
12499 let len = 0;
12500 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12501 struct_ser.end()
12502 }
12503}
12504impl<'de> serde::Deserialize<'de> for Recovery {
12505 #[allow(deprecated)]
12506 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12507 where
12508 D: serde::Deserializer<'de>,
12509 {
12510 const FIELDS: &[&str] = &[
12511 ];
12512
12513 #[allow(clippy::enum_variant_names)]
12514 enum GeneratedField {
12515 }
12516 impl<'de> serde::Deserialize<'de> for GeneratedField {
12517 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12518 where
12519 D: serde::Deserializer<'de>,
12520 {
12521 struct GeneratedVisitor;
12522
12523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12524 type Value = GeneratedField;
12525
12526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12527 write!(formatter, "expected one of: {:?}", &FIELDS)
12528 }
12529
12530 #[allow(unused_variables)]
12531 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12532 where
12533 E: serde::de::Error,
12534 {
12535 Err(serde::de::Error::unknown_field(value, FIELDS))
12536 }
12537 }
12538 deserializer.deserialize_identifier(GeneratedVisitor)
12539 }
12540 }
12541 struct GeneratedVisitor;
12542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12543 type Value = Recovery;
12544
12545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12546 formatter.write_str("struct meta.Recovery")
12547 }
12548
12549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
12550 where
12551 V: serde::de::MapAccess<'de>,
12552 {
12553 while map_.next_key::<GeneratedField>()?.is_some() {
12554 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12555 }
12556 Ok(Recovery {
12557 })
12558 }
12559 }
12560 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
12561 }
12562}
12563impl serde::Serialize for RecoveryStatus {
12564 #[allow(deprecated)]
12565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12566 where
12567 S: serde::Serializer,
12568 {
12569 let variant = match self {
12570 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
12571 Self::StatusStarting => "STATUS_STARTING",
12572 Self::StatusRecovering => "STATUS_RECOVERING",
12573 Self::StatusRunning => "STATUS_RUNNING",
12574 };
12575 serializer.serialize_str(variant)
12576 }
12577}
12578impl<'de> serde::Deserialize<'de> for RecoveryStatus {
12579 #[allow(deprecated)]
12580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12581 where
12582 D: serde::Deserializer<'de>,
12583 {
12584 const FIELDS: &[&str] = &[
12585 "STATUS_UNSPECIFIED",
12586 "STATUS_STARTING",
12587 "STATUS_RECOVERING",
12588 "STATUS_RUNNING",
12589 ];
12590
12591 struct GeneratedVisitor;
12592
12593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12594 type Value = RecoveryStatus;
12595
12596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12597 write!(formatter, "expected one of: {:?}", &FIELDS)
12598 }
12599
12600 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12601 where
12602 E: serde::de::Error,
12603 {
12604 i32::try_from(v)
12605 .ok()
12606 .and_then(|x| x.try_into().ok())
12607 .ok_or_else(|| {
12608 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12609 })
12610 }
12611
12612 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12613 where
12614 E: serde::de::Error,
12615 {
12616 i32::try_from(v)
12617 .ok()
12618 .and_then(|x| x.try_into().ok())
12619 .ok_or_else(|| {
12620 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12621 })
12622 }
12623
12624 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12625 where
12626 E: serde::de::Error,
12627 {
12628 match value {
12629 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
12630 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
12631 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
12632 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
12633 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12634 }
12635 }
12636 }
12637 deserializer.deserialize_any(GeneratedVisitor)
12638 }
12639}
12640impl serde::Serialize for RefreshRequest {
12641 #[allow(deprecated)]
12642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12643 where
12644 S: serde::Serializer,
12645 {
12646 use serde::ser::SerializeStruct;
12647 let mut len = 0;
12648 if self.table_id != 0 {
12649 len += 1;
12650 }
12651 if self.associated_source_id != 0 {
12652 len += 1;
12653 }
12654 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
12655 if self.table_id != 0 {
12656 struct_ser.serialize_field("tableId", &self.table_id)?;
12657 }
12658 if self.associated_source_id != 0 {
12659 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
12660 }
12661 struct_ser.end()
12662 }
12663}
12664impl<'de> serde::Deserialize<'de> for RefreshRequest {
12665 #[allow(deprecated)]
12666 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12667 where
12668 D: serde::Deserializer<'de>,
12669 {
12670 const FIELDS: &[&str] = &[
12671 "table_id",
12672 "tableId",
12673 "associated_source_id",
12674 "associatedSourceId",
12675 ];
12676
12677 #[allow(clippy::enum_variant_names)]
12678 enum GeneratedField {
12679 TableId,
12680 AssociatedSourceId,
12681 }
12682 impl<'de> serde::Deserialize<'de> for GeneratedField {
12683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12684 where
12685 D: serde::Deserializer<'de>,
12686 {
12687 struct GeneratedVisitor;
12688
12689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12690 type Value = GeneratedField;
12691
12692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12693 write!(formatter, "expected one of: {:?}", &FIELDS)
12694 }
12695
12696 #[allow(unused_variables)]
12697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12698 where
12699 E: serde::de::Error,
12700 {
12701 match value {
12702 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12703 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
12704 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12705 }
12706 }
12707 }
12708 deserializer.deserialize_identifier(GeneratedVisitor)
12709 }
12710 }
12711 struct GeneratedVisitor;
12712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12713 type Value = RefreshRequest;
12714
12715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12716 formatter.write_str("struct meta.RefreshRequest")
12717 }
12718
12719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
12720 where
12721 V: serde::de::MapAccess<'de>,
12722 {
12723 let mut table_id__ = None;
12724 let mut associated_source_id__ = None;
12725 while let Some(k) = map_.next_key()? {
12726 match k {
12727 GeneratedField::TableId => {
12728 if table_id__.is_some() {
12729 return Err(serde::de::Error::duplicate_field("tableId"));
12730 }
12731 table_id__ =
12732 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12733 ;
12734 }
12735 GeneratedField::AssociatedSourceId => {
12736 if associated_source_id__.is_some() {
12737 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
12738 }
12739 associated_source_id__ =
12740 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12741 ;
12742 }
12743 }
12744 }
12745 Ok(RefreshRequest {
12746 table_id: table_id__.unwrap_or_default(),
12747 associated_source_id: associated_source_id__.unwrap_or_default(),
12748 })
12749 }
12750 }
12751 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
12752 }
12753}
12754impl serde::Serialize for RefreshResponse {
12755 #[allow(deprecated)]
12756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12757 where
12758 S: serde::Serializer,
12759 {
12760 use serde::ser::SerializeStruct;
12761 let mut len = 0;
12762 if self.status.is_some() {
12763 len += 1;
12764 }
12765 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
12766 if let Some(v) = self.status.as_ref() {
12767 struct_ser.serialize_field("status", v)?;
12768 }
12769 struct_ser.end()
12770 }
12771}
12772impl<'de> serde::Deserialize<'de> for RefreshResponse {
12773 #[allow(deprecated)]
12774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12775 where
12776 D: serde::Deserializer<'de>,
12777 {
12778 const FIELDS: &[&str] = &[
12779 "status",
12780 ];
12781
12782 #[allow(clippy::enum_variant_names)]
12783 enum GeneratedField {
12784 Status,
12785 }
12786 impl<'de> serde::Deserialize<'de> for GeneratedField {
12787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12788 where
12789 D: serde::Deserializer<'de>,
12790 {
12791 struct GeneratedVisitor;
12792
12793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12794 type Value = GeneratedField;
12795
12796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12797 write!(formatter, "expected one of: {:?}", &FIELDS)
12798 }
12799
12800 #[allow(unused_variables)]
12801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12802 where
12803 E: serde::de::Error,
12804 {
12805 match value {
12806 "status" => Ok(GeneratedField::Status),
12807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12808 }
12809 }
12810 }
12811 deserializer.deserialize_identifier(GeneratedVisitor)
12812 }
12813 }
12814 struct GeneratedVisitor;
12815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12816 type Value = RefreshResponse;
12817
12818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12819 formatter.write_str("struct meta.RefreshResponse")
12820 }
12821
12822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
12823 where
12824 V: serde::de::MapAccess<'de>,
12825 {
12826 let mut status__ = None;
12827 while let Some(k) = map_.next_key()? {
12828 match k {
12829 GeneratedField::Status => {
12830 if status__.is_some() {
12831 return Err(serde::de::Error::duplicate_field("status"));
12832 }
12833 status__ = map_.next_value()?;
12834 }
12835 }
12836 }
12837 Ok(RefreshResponse {
12838 status: status__,
12839 })
12840 }
12841 }
12842 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
12843 }
12844}
12845impl serde::Serialize for RelationIdInfos {
12846 #[allow(deprecated)]
12847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12848 where
12849 S: serde::Serializer,
12850 {
12851 use serde::ser::SerializeStruct;
12852 let mut len = 0;
12853 if !self.map.is_empty() {
12854 len += 1;
12855 }
12856 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
12857 if !self.map.is_empty() {
12858 struct_ser.serialize_field("map", &self.map)?;
12859 }
12860 struct_ser.end()
12861 }
12862}
12863impl<'de> serde::Deserialize<'de> for RelationIdInfos {
12864 #[allow(deprecated)]
12865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12866 where
12867 D: serde::Deserializer<'de>,
12868 {
12869 const FIELDS: &[&str] = &[
12870 "map",
12871 ];
12872
12873 #[allow(clippy::enum_variant_names)]
12874 enum GeneratedField {
12875 Map,
12876 }
12877 impl<'de> serde::Deserialize<'de> for GeneratedField {
12878 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12879 where
12880 D: serde::Deserializer<'de>,
12881 {
12882 struct GeneratedVisitor;
12883
12884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12885 type Value = GeneratedField;
12886
12887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12888 write!(formatter, "expected one of: {:?}", &FIELDS)
12889 }
12890
12891 #[allow(unused_variables)]
12892 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12893 where
12894 E: serde::de::Error,
12895 {
12896 match value {
12897 "map" => Ok(GeneratedField::Map),
12898 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12899 }
12900 }
12901 }
12902 deserializer.deserialize_identifier(GeneratedVisitor)
12903 }
12904 }
12905 struct GeneratedVisitor;
12906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12907 type Value = RelationIdInfos;
12908
12909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12910 formatter.write_str("struct meta.RelationIdInfos")
12911 }
12912
12913 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
12914 where
12915 V: serde::de::MapAccess<'de>,
12916 {
12917 let mut map__ = None;
12918 while let Some(k) = map_.next_key()? {
12919 match k {
12920 GeneratedField::Map => {
12921 if map__.is_some() {
12922 return Err(serde::de::Error::duplicate_field("map"));
12923 }
12924 map__ = Some(
12925 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12926 .into_iter().map(|(k,v)| (k.0, v)).collect()
12927 );
12928 }
12929 }
12930 }
12931 Ok(RelationIdInfos {
12932 map: map__.unwrap_or_default(),
12933 })
12934 }
12935 }
12936 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
12937 }
12938}
12939impl serde::Serialize for RescheduleRequest {
12940 #[allow(deprecated)]
12941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12942 where
12943 S: serde::Serializer,
12944 {
12945 use serde::ser::SerializeStruct;
12946 let mut len = 0;
12947 if self.revision != 0 {
12948 len += 1;
12949 }
12950 if self.resolve_no_shuffle_upstream {
12951 len += 1;
12952 }
12953 if !self.worker_reschedules.is_empty() {
12954 len += 1;
12955 }
12956 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
12957 if self.revision != 0 {
12958 #[allow(clippy::needless_borrow)]
12959 #[allow(clippy::needless_borrows_for_generic_args)]
12960 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
12961 }
12962 if self.resolve_no_shuffle_upstream {
12963 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
12964 }
12965 if !self.worker_reschedules.is_empty() {
12966 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
12967 }
12968 struct_ser.end()
12969 }
12970}
12971impl<'de> serde::Deserialize<'de> for RescheduleRequest {
12972 #[allow(deprecated)]
12973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12974 where
12975 D: serde::Deserializer<'de>,
12976 {
12977 const FIELDS: &[&str] = &[
12978 "revision",
12979 "resolve_no_shuffle_upstream",
12980 "resolveNoShuffleUpstream",
12981 "worker_reschedules",
12982 "workerReschedules",
12983 ];
12984
12985 #[allow(clippy::enum_variant_names)]
12986 enum GeneratedField {
12987 Revision,
12988 ResolveNoShuffleUpstream,
12989 WorkerReschedules,
12990 }
12991 impl<'de> serde::Deserialize<'de> for GeneratedField {
12992 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12993 where
12994 D: serde::Deserializer<'de>,
12995 {
12996 struct GeneratedVisitor;
12997
12998 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12999 type Value = GeneratedField;
13000
13001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13002 write!(formatter, "expected one of: {:?}", &FIELDS)
13003 }
13004
13005 #[allow(unused_variables)]
13006 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13007 where
13008 E: serde::de::Error,
13009 {
13010 match value {
13011 "revision" => Ok(GeneratedField::Revision),
13012 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
13013 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
13014 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13015 }
13016 }
13017 }
13018 deserializer.deserialize_identifier(GeneratedVisitor)
13019 }
13020 }
13021 struct GeneratedVisitor;
13022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13023 type Value = RescheduleRequest;
13024
13025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13026 formatter.write_str("struct meta.RescheduleRequest")
13027 }
13028
13029 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
13030 where
13031 V: serde::de::MapAccess<'de>,
13032 {
13033 let mut revision__ = None;
13034 let mut resolve_no_shuffle_upstream__ = None;
13035 let mut worker_reschedules__ = None;
13036 while let Some(k) = map_.next_key()? {
13037 match k {
13038 GeneratedField::Revision => {
13039 if revision__.is_some() {
13040 return Err(serde::de::Error::duplicate_field("revision"));
13041 }
13042 revision__ =
13043 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13044 ;
13045 }
13046 GeneratedField::ResolveNoShuffleUpstream => {
13047 if resolve_no_shuffle_upstream__.is_some() {
13048 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
13049 }
13050 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
13051 }
13052 GeneratedField::WorkerReschedules => {
13053 if worker_reschedules__.is_some() {
13054 return Err(serde::de::Error::duplicate_field("workerReschedules"));
13055 }
13056 worker_reschedules__ = Some(
13057 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13058 .into_iter().map(|(k,v)| (k.0, v)).collect()
13059 );
13060 }
13061 }
13062 }
13063 Ok(RescheduleRequest {
13064 revision: revision__.unwrap_or_default(),
13065 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
13066 worker_reschedules: worker_reschedules__.unwrap_or_default(),
13067 })
13068 }
13069 }
13070 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
13071 }
13072}
13073impl serde::Serialize for RescheduleResponse {
13074 #[allow(deprecated)]
13075 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13076 where
13077 S: serde::Serializer,
13078 {
13079 use serde::ser::SerializeStruct;
13080 let mut len = 0;
13081 if self.success {
13082 len += 1;
13083 }
13084 if self.revision != 0 {
13085 len += 1;
13086 }
13087 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
13088 if self.success {
13089 struct_ser.serialize_field("success", &self.success)?;
13090 }
13091 if self.revision != 0 {
13092 #[allow(clippy::needless_borrow)]
13093 #[allow(clippy::needless_borrows_for_generic_args)]
13094 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13095 }
13096 struct_ser.end()
13097 }
13098}
13099impl<'de> serde::Deserialize<'de> for RescheduleResponse {
13100 #[allow(deprecated)]
13101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13102 where
13103 D: serde::Deserializer<'de>,
13104 {
13105 const FIELDS: &[&str] = &[
13106 "success",
13107 "revision",
13108 ];
13109
13110 #[allow(clippy::enum_variant_names)]
13111 enum GeneratedField {
13112 Success,
13113 Revision,
13114 }
13115 impl<'de> serde::Deserialize<'de> for GeneratedField {
13116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13117 where
13118 D: serde::Deserializer<'de>,
13119 {
13120 struct GeneratedVisitor;
13121
13122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13123 type Value = GeneratedField;
13124
13125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13126 write!(formatter, "expected one of: {:?}", &FIELDS)
13127 }
13128
13129 #[allow(unused_variables)]
13130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13131 where
13132 E: serde::de::Error,
13133 {
13134 match value {
13135 "success" => Ok(GeneratedField::Success),
13136 "revision" => Ok(GeneratedField::Revision),
13137 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13138 }
13139 }
13140 }
13141 deserializer.deserialize_identifier(GeneratedVisitor)
13142 }
13143 }
13144 struct GeneratedVisitor;
13145 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13146 type Value = RescheduleResponse;
13147
13148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13149 formatter.write_str("struct meta.RescheduleResponse")
13150 }
13151
13152 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
13153 where
13154 V: serde::de::MapAccess<'de>,
13155 {
13156 let mut success__ = None;
13157 let mut revision__ = None;
13158 while let Some(k) = map_.next_key()? {
13159 match k {
13160 GeneratedField::Success => {
13161 if success__.is_some() {
13162 return Err(serde::de::Error::duplicate_field("success"));
13163 }
13164 success__ = Some(map_.next_value()?);
13165 }
13166 GeneratedField::Revision => {
13167 if revision__.is_some() {
13168 return Err(serde::de::Error::duplicate_field("revision"));
13169 }
13170 revision__ =
13171 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13172 ;
13173 }
13174 }
13175 }
13176 Ok(RescheduleResponse {
13177 success: success__.unwrap_or_default(),
13178 revision: revision__.unwrap_or_default(),
13179 })
13180 }
13181 }
13182 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
13183 }
13184}
13185impl serde::Serialize for ResumeRequest {
13186 #[allow(deprecated)]
13187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13188 where
13189 S: serde::Serializer,
13190 {
13191 use serde::ser::SerializeStruct;
13192 let len = 0;
13193 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
13194 struct_ser.end()
13195 }
13196}
13197impl<'de> serde::Deserialize<'de> for ResumeRequest {
13198 #[allow(deprecated)]
13199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13200 where
13201 D: serde::Deserializer<'de>,
13202 {
13203 const FIELDS: &[&str] = &[
13204 ];
13205
13206 #[allow(clippy::enum_variant_names)]
13207 enum GeneratedField {
13208 }
13209 impl<'de> serde::Deserialize<'de> for GeneratedField {
13210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13211 where
13212 D: serde::Deserializer<'de>,
13213 {
13214 struct GeneratedVisitor;
13215
13216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13217 type Value = GeneratedField;
13218
13219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13220 write!(formatter, "expected one of: {:?}", &FIELDS)
13221 }
13222
13223 #[allow(unused_variables)]
13224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13225 where
13226 E: serde::de::Error,
13227 {
13228 Err(serde::de::Error::unknown_field(value, FIELDS))
13229 }
13230 }
13231 deserializer.deserialize_identifier(GeneratedVisitor)
13232 }
13233 }
13234 struct GeneratedVisitor;
13235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13236 type Value = ResumeRequest;
13237
13238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13239 formatter.write_str("struct meta.ResumeRequest")
13240 }
13241
13242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
13243 where
13244 V: serde::de::MapAccess<'de>,
13245 {
13246 while map_.next_key::<GeneratedField>()?.is_some() {
13247 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13248 }
13249 Ok(ResumeRequest {
13250 })
13251 }
13252 }
13253 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13254 }
13255}
13256impl serde::Serialize for ResumeResponse {
13257 #[allow(deprecated)]
13258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13259 where
13260 S: serde::Serializer,
13261 {
13262 use serde::ser::SerializeStruct;
13263 let len = 0;
13264 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13265 struct_ser.end()
13266 }
13267}
13268impl<'de> serde::Deserialize<'de> for ResumeResponse {
13269 #[allow(deprecated)]
13270 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13271 where
13272 D: serde::Deserializer<'de>,
13273 {
13274 const FIELDS: &[&str] = &[
13275 ];
13276
13277 #[allow(clippy::enum_variant_names)]
13278 enum GeneratedField {
13279 }
13280 impl<'de> serde::Deserialize<'de> for GeneratedField {
13281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13282 where
13283 D: serde::Deserializer<'de>,
13284 {
13285 struct GeneratedVisitor;
13286
13287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13288 type Value = GeneratedField;
13289
13290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13291 write!(formatter, "expected one of: {:?}", &FIELDS)
13292 }
13293
13294 #[allow(unused_variables)]
13295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13296 where
13297 E: serde::de::Error,
13298 {
13299 Err(serde::de::Error::unknown_field(value, FIELDS))
13300 }
13301 }
13302 deserializer.deserialize_identifier(GeneratedVisitor)
13303 }
13304 }
13305 struct GeneratedVisitor;
13306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13307 type Value = ResumeResponse;
13308
13309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13310 formatter.write_str("struct meta.ResumeResponse")
13311 }
13312
13313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13314 where
13315 V: serde::de::MapAccess<'de>,
13316 {
13317 while map_.next_key::<GeneratedField>()?.is_some() {
13318 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13319 }
13320 Ok(ResumeResponse {
13321 })
13322 }
13323 }
13324 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13325 }
13326}
13327impl serde::Serialize for SetSessionParamRequest {
13328 #[allow(deprecated)]
13329 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13330 where
13331 S: serde::Serializer,
13332 {
13333 use serde::ser::SerializeStruct;
13334 let mut len = 0;
13335 if !self.param.is_empty() {
13336 len += 1;
13337 }
13338 if self.value.is_some() {
13339 len += 1;
13340 }
13341 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13342 if !self.param.is_empty() {
13343 struct_ser.serialize_field("param", &self.param)?;
13344 }
13345 if let Some(v) = self.value.as_ref() {
13346 struct_ser.serialize_field("value", v)?;
13347 }
13348 struct_ser.end()
13349 }
13350}
13351impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13352 #[allow(deprecated)]
13353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13354 where
13355 D: serde::Deserializer<'de>,
13356 {
13357 const FIELDS: &[&str] = &[
13358 "param",
13359 "value",
13360 ];
13361
13362 #[allow(clippy::enum_variant_names)]
13363 enum GeneratedField {
13364 Param,
13365 Value,
13366 }
13367 impl<'de> serde::Deserialize<'de> for GeneratedField {
13368 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13369 where
13370 D: serde::Deserializer<'de>,
13371 {
13372 struct GeneratedVisitor;
13373
13374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13375 type Value = GeneratedField;
13376
13377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13378 write!(formatter, "expected one of: {:?}", &FIELDS)
13379 }
13380
13381 #[allow(unused_variables)]
13382 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13383 where
13384 E: serde::de::Error,
13385 {
13386 match value {
13387 "param" => Ok(GeneratedField::Param),
13388 "value" => Ok(GeneratedField::Value),
13389 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13390 }
13391 }
13392 }
13393 deserializer.deserialize_identifier(GeneratedVisitor)
13394 }
13395 }
13396 struct GeneratedVisitor;
13397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13398 type Value = SetSessionParamRequest;
13399
13400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13401 formatter.write_str("struct meta.SetSessionParamRequest")
13402 }
13403
13404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13405 where
13406 V: serde::de::MapAccess<'de>,
13407 {
13408 let mut param__ = None;
13409 let mut value__ = None;
13410 while let Some(k) = map_.next_key()? {
13411 match k {
13412 GeneratedField::Param => {
13413 if param__.is_some() {
13414 return Err(serde::de::Error::duplicate_field("param"));
13415 }
13416 param__ = Some(map_.next_value()?);
13417 }
13418 GeneratedField::Value => {
13419 if value__.is_some() {
13420 return Err(serde::de::Error::duplicate_field("value"));
13421 }
13422 value__ = map_.next_value()?;
13423 }
13424 }
13425 }
13426 Ok(SetSessionParamRequest {
13427 param: param__.unwrap_or_default(),
13428 value: value__,
13429 })
13430 }
13431 }
13432 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13433 }
13434}
13435impl serde::Serialize for SetSessionParamResponse {
13436 #[allow(deprecated)]
13437 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13438 where
13439 S: serde::Serializer,
13440 {
13441 use serde::ser::SerializeStruct;
13442 let mut len = 0;
13443 if !self.param.is_empty() {
13444 len += 1;
13445 }
13446 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13447 if !self.param.is_empty() {
13448 struct_ser.serialize_field("param", &self.param)?;
13449 }
13450 struct_ser.end()
13451 }
13452}
13453impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13454 #[allow(deprecated)]
13455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13456 where
13457 D: serde::Deserializer<'de>,
13458 {
13459 const FIELDS: &[&str] = &[
13460 "param",
13461 ];
13462
13463 #[allow(clippy::enum_variant_names)]
13464 enum GeneratedField {
13465 Param,
13466 }
13467 impl<'de> serde::Deserialize<'de> for GeneratedField {
13468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13469 where
13470 D: serde::Deserializer<'de>,
13471 {
13472 struct GeneratedVisitor;
13473
13474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13475 type Value = GeneratedField;
13476
13477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13478 write!(formatter, "expected one of: {:?}", &FIELDS)
13479 }
13480
13481 #[allow(unused_variables)]
13482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13483 where
13484 E: serde::de::Error,
13485 {
13486 match value {
13487 "param" => Ok(GeneratedField::Param),
13488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13489 }
13490 }
13491 }
13492 deserializer.deserialize_identifier(GeneratedVisitor)
13493 }
13494 }
13495 struct GeneratedVisitor;
13496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13497 type Value = SetSessionParamResponse;
13498
13499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13500 formatter.write_str("struct meta.SetSessionParamResponse")
13501 }
13502
13503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13504 where
13505 V: serde::de::MapAccess<'de>,
13506 {
13507 let mut param__ = None;
13508 while let Some(k) = map_.next_key()? {
13509 match k {
13510 GeneratedField::Param => {
13511 if param__.is_some() {
13512 return Err(serde::de::Error::duplicate_field("param"));
13513 }
13514 param__ = Some(map_.next_value()?);
13515 }
13516 }
13517 }
13518 Ok(SetSessionParamResponse {
13519 param: param__.unwrap_or_default(),
13520 })
13521 }
13522 }
13523 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13524 }
13525}
13526impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13527 #[allow(deprecated)]
13528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13529 where
13530 S: serde::Serializer,
13531 {
13532 use serde::ser::SerializeStruct;
13533 let mut len = 0;
13534 if self.job_id != 0 {
13535 len += 1;
13536 }
13537 if self.aligned {
13538 len += 1;
13539 }
13540 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13541 if self.job_id != 0 {
13542 struct_ser.serialize_field("jobId", &self.job_id)?;
13543 }
13544 if self.aligned {
13545 struct_ser.serialize_field("aligned", &self.aligned)?;
13546 }
13547 struct_ser.end()
13548 }
13549}
13550impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
13551 #[allow(deprecated)]
13552 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13553 where
13554 D: serde::Deserializer<'de>,
13555 {
13556 const FIELDS: &[&str] = &[
13557 "job_id",
13558 "jobId",
13559 "aligned",
13560 ];
13561
13562 #[allow(clippy::enum_variant_names)]
13563 enum GeneratedField {
13564 JobId,
13565 Aligned,
13566 }
13567 impl<'de> serde::Deserialize<'de> for GeneratedField {
13568 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13569 where
13570 D: serde::Deserializer<'de>,
13571 {
13572 struct GeneratedVisitor;
13573
13574 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13575 type Value = GeneratedField;
13576
13577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13578 write!(formatter, "expected one of: {:?}", &FIELDS)
13579 }
13580
13581 #[allow(unused_variables)]
13582 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13583 where
13584 E: serde::de::Error,
13585 {
13586 match value {
13587 "jobId" | "job_id" => Ok(GeneratedField::JobId),
13588 "aligned" => Ok(GeneratedField::Aligned),
13589 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13590 }
13591 }
13592 }
13593 deserializer.deserialize_identifier(GeneratedVisitor)
13594 }
13595 }
13596 struct GeneratedVisitor;
13597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13598 type Value = SetSyncLogStoreAlignedRequest;
13599
13600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13601 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
13602 }
13603
13604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
13605 where
13606 V: serde::de::MapAccess<'de>,
13607 {
13608 let mut job_id__ = None;
13609 let mut aligned__ = None;
13610 while let Some(k) = map_.next_key()? {
13611 match k {
13612 GeneratedField::JobId => {
13613 if job_id__.is_some() {
13614 return Err(serde::de::Error::duplicate_field("jobId"));
13615 }
13616 job_id__ =
13617 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13618 ;
13619 }
13620 GeneratedField::Aligned => {
13621 if aligned__.is_some() {
13622 return Err(serde::de::Error::duplicate_field("aligned"));
13623 }
13624 aligned__ = Some(map_.next_value()?);
13625 }
13626 }
13627 }
13628 Ok(SetSyncLogStoreAlignedRequest {
13629 job_id: job_id__.unwrap_or_default(),
13630 aligned: aligned__.unwrap_or_default(),
13631 })
13632 }
13633 }
13634 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
13635 }
13636}
13637impl serde::Serialize for SetSyncLogStoreAlignedResponse {
13638 #[allow(deprecated)]
13639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13640 where
13641 S: serde::Serializer,
13642 {
13643 use serde::ser::SerializeStruct;
13644 let len = 0;
13645 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
13646 struct_ser.end()
13647 }
13648}
13649impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
13650 #[allow(deprecated)]
13651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13652 where
13653 D: serde::Deserializer<'de>,
13654 {
13655 const FIELDS: &[&str] = &[
13656 ];
13657
13658 #[allow(clippy::enum_variant_names)]
13659 enum GeneratedField {
13660 }
13661 impl<'de> serde::Deserialize<'de> for GeneratedField {
13662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13663 where
13664 D: serde::Deserializer<'de>,
13665 {
13666 struct GeneratedVisitor;
13667
13668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13669 type Value = GeneratedField;
13670
13671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13672 write!(formatter, "expected one of: {:?}", &FIELDS)
13673 }
13674
13675 #[allow(unused_variables)]
13676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13677 where
13678 E: serde::de::Error,
13679 {
13680 Err(serde::de::Error::unknown_field(value, FIELDS))
13681 }
13682 }
13683 deserializer.deserialize_identifier(GeneratedVisitor)
13684 }
13685 }
13686 struct GeneratedVisitor;
13687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13688 type Value = SetSyncLogStoreAlignedResponse;
13689
13690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13691 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
13692 }
13693
13694 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
13695 where
13696 V: serde::de::MapAccess<'de>,
13697 {
13698 while map_.next_key::<GeneratedField>()?.is_some() {
13699 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13700 }
13701 Ok(SetSyncLogStoreAlignedResponse {
13702 })
13703 }
13704 }
13705 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
13706 }
13707}
13708impl serde::Serialize for SetSystemParamRequest {
13709 #[allow(deprecated)]
13710 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13711 where
13712 S: serde::Serializer,
13713 {
13714 use serde::ser::SerializeStruct;
13715 let mut len = 0;
13716 if !self.param.is_empty() {
13717 len += 1;
13718 }
13719 if self.value.is_some() {
13720 len += 1;
13721 }
13722 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
13723 if !self.param.is_empty() {
13724 struct_ser.serialize_field("param", &self.param)?;
13725 }
13726 if let Some(v) = self.value.as_ref() {
13727 struct_ser.serialize_field("value", v)?;
13728 }
13729 struct_ser.end()
13730 }
13731}
13732impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
13733 #[allow(deprecated)]
13734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13735 where
13736 D: serde::Deserializer<'de>,
13737 {
13738 const FIELDS: &[&str] = &[
13739 "param",
13740 "value",
13741 ];
13742
13743 #[allow(clippy::enum_variant_names)]
13744 enum GeneratedField {
13745 Param,
13746 Value,
13747 }
13748 impl<'de> serde::Deserialize<'de> for GeneratedField {
13749 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13750 where
13751 D: serde::Deserializer<'de>,
13752 {
13753 struct GeneratedVisitor;
13754
13755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13756 type Value = GeneratedField;
13757
13758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13759 write!(formatter, "expected one of: {:?}", &FIELDS)
13760 }
13761
13762 #[allow(unused_variables)]
13763 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13764 where
13765 E: serde::de::Error,
13766 {
13767 match value {
13768 "param" => Ok(GeneratedField::Param),
13769 "value" => Ok(GeneratedField::Value),
13770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13771 }
13772 }
13773 }
13774 deserializer.deserialize_identifier(GeneratedVisitor)
13775 }
13776 }
13777 struct GeneratedVisitor;
13778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13779 type Value = SetSystemParamRequest;
13780
13781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13782 formatter.write_str("struct meta.SetSystemParamRequest")
13783 }
13784
13785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
13786 where
13787 V: serde::de::MapAccess<'de>,
13788 {
13789 let mut param__ = None;
13790 let mut value__ = None;
13791 while let Some(k) = map_.next_key()? {
13792 match k {
13793 GeneratedField::Param => {
13794 if param__.is_some() {
13795 return Err(serde::de::Error::duplicate_field("param"));
13796 }
13797 param__ = Some(map_.next_value()?);
13798 }
13799 GeneratedField::Value => {
13800 if value__.is_some() {
13801 return Err(serde::de::Error::duplicate_field("value"));
13802 }
13803 value__ = map_.next_value()?;
13804 }
13805 }
13806 }
13807 Ok(SetSystemParamRequest {
13808 param: param__.unwrap_or_default(),
13809 value: value__,
13810 })
13811 }
13812 }
13813 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
13814 }
13815}
13816impl serde::Serialize for SetSystemParamResponse {
13817 #[allow(deprecated)]
13818 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13819 where
13820 S: serde::Serializer,
13821 {
13822 use serde::ser::SerializeStruct;
13823 let mut len = 0;
13824 if self.params.is_some() {
13825 len += 1;
13826 }
13827 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
13828 if let Some(v) = self.params.as_ref() {
13829 struct_ser.serialize_field("params", v)?;
13830 }
13831 struct_ser.end()
13832 }
13833}
13834impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
13835 #[allow(deprecated)]
13836 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13837 where
13838 D: serde::Deserializer<'de>,
13839 {
13840 const FIELDS: &[&str] = &[
13841 "params",
13842 ];
13843
13844 #[allow(clippy::enum_variant_names)]
13845 enum GeneratedField {
13846 Params,
13847 }
13848 impl<'de> serde::Deserialize<'de> for GeneratedField {
13849 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13850 where
13851 D: serde::Deserializer<'de>,
13852 {
13853 struct GeneratedVisitor;
13854
13855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13856 type Value = GeneratedField;
13857
13858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13859 write!(formatter, "expected one of: {:?}", &FIELDS)
13860 }
13861
13862 #[allow(unused_variables)]
13863 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13864 where
13865 E: serde::de::Error,
13866 {
13867 match value {
13868 "params" => Ok(GeneratedField::Params),
13869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13870 }
13871 }
13872 }
13873 deserializer.deserialize_identifier(GeneratedVisitor)
13874 }
13875 }
13876 struct GeneratedVisitor;
13877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13878 type Value = SetSystemParamResponse;
13879
13880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13881 formatter.write_str("struct meta.SetSystemParamResponse")
13882 }
13883
13884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
13885 where
13886 V: serde::de::MapAccess<'de>,
13887 {
13888 let mut params__ = None;
13889 while let Some(k) = map_.next_key()? {
13890 match k {
13891 GeneratedField::Params => {
13892 if params__.is_some() {
13893 return Err(serde::de::Error::duplicate_field("params"));
13894 }
13895 params__ = map_.next_value()?;
13896 }
13897 }
13898 }
13899 Ok(SetSystemParamResponse {
13900 params: params__,
13901 })
13902 }
13903 }
13904 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
13905 }
13906}
13907impl serde::Serialize for SubscribeRequest {
13908 #[allow(deprecated)]
13909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13910 where
13911 S: serde::Serializer,
13912 {
13913 use serde::ser::SerializeStruct;
13914 let mut len = 0;
13915 if self.subscribe_type != 0 {
13916 len += 1;
13917 }
13918 if self.host.is_some() {
13919 len += 1;
13920 }
13921 if self.worker_id != 0 {
13922 len += 1;
13923 }
13924 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
13925 if self.subscribe_type != 0 {
13926 let v = SubscribeType::try_from(self.subscribe_type)
13927 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
13928 struct_ser.serialize_field("subscribeType", &v)?;
13929 }
13930 if let Some(v) = self.host.as_ref() {
13931 struct_ser.serialize_field("host", v)?;
13932 }
13933 if self.worker_id != 0 {
13934 struct_ser.serialize_field("workerId", &self.worker_id)?;
13935 }
13936 struct_ser.end()
13937 }
13938}
13939impl<'de> serde::Deserialize<'de> for SubscribeRequest {
13940 #[allow(deprecated)]
13941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13942 where
13943 D: serde::Deserializer<'de>,
13944 {
13945 const FIELDS: &[&str] = &[
13946 "subscribe_type",
13947 "subscribeType",
13948 "host",
13949 "worker_id",
13950 "workerId",
13951 ];
13952
13953 #[allow(clippy::enum_variant_names)]
13954 enum GeneratedField {
13955 SubscribeType,
13956 Host,
13957 WorkerId,
13958 }
13959 impl<'de> serde::Deserialize<'de> for GeneratedField {
13960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13961 where
13962 D: serde::Deserializer<'de>,
13963 {
13964 struct GeneratedVisitor;
13965
13966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13967 type Value = GeneratedField;
13968
13969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13970 write!(formatter, "expected one of: {:?}", &FIELDS)
13971 }
13972
13973 #[allow(unused_variables)]
13974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13975 where
13976 E: serde::de::Error,
13977 {
13978 match value {
13979 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
13980 "host" => Ok(GeneratedField::Host),
13981 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
13982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13983 }
13984 }
13985 }
13986 deserializer.deserialize_identifier(GeneratedVisitor)
13987 }
13988 }
13989 struct GeneratedVisitor;
13990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13991 type Value = SubscribeRequest;
13992
13993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13994 formatter.write_str("struct meta.SubscribeRequest")
13995 }
13996
13997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
13998 where
13999 V: serde::de::MapAccess<'de>,
14000 {
14001 let mut subscribe_type__ = None;
14002 let mut host__ = None;
14003 let mut worker_id__ = None;
14004 while let Some(k) = map_.next_key()? {
14005 match k {
14006 GeneratedField::SubscribeType => {
14007 if subscribe_type__.is_some() {
14008 return Err(serde::de::Error::duplicate_field("subscribeType"));
14009 }
14010 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
14011 }
14012 GeneratedField::Host => {
14013 if host__.is_some() {
14014 return Err(serde::de::Error::duplicate_field("host"));
14015 }
14016 host__ = map_.next_value()?;
14017 }
14018 GeneratedField::WorkerId => {
14019 if worker_id__.is_some() {
14020 return Err(serde::de::Error::duplicate_field("workerId"));
14021 }
14022 worker_id__ =
14023 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14024 ;
14025 }
14026 }
14027 }
14028 Ok(SubscribeRequest {
14029 subscribe_type: subscribe_type__.unwrap_or_default(),
14030 host: host__,
14031 worker_id: worker_id__.unwrap_or_default(),
14032 })
14033 }
14034 }
14035 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
14036 }
14037}
14038impl serde::Serialize for SubscribeResponse {
14039 #[allow(deprecated)]
14040 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14041 where
14042 S: serde::Serializer,
14043 {
14044 use serde::ser::SerializeStruct;
14045 let mut len = 0;
14046 if self.status.is_some() {
14047 len += 1;
14048 }
14049 if self.operation != 0 {
14050 len += 1;
14051 }
14052 if self.version != 0 {
14053 len += 1;
14054 }
14055 if self.info.is_some() {
14056 len += 1;
14057 }
14058 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
14059 if let Some(v) = self.status.as_ref() {
14060 struct_ser.serialize_field("status", v)?;
14061 }
14062 if self.operation != 0 {
14063 let v = subscribe_response::Operation::try_from(self.operation)
14064 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
14065 struct_ser.serialize_field("operation", &v)?;
14066 }
14067 if self.version != 0 {
14068 #[allow(clippy::needless_borrow)]
14069 #[allow(clippy::needless_borrows_for_generic_args)]
14070 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
14071 }
14072 if let Some(v) = self.info.as_ref() {
14073 match v {
14074 subscribe_response::Info::Database(v) => {
14075 struct_ser.serialize_field("database", v)?;
14076 }
14077 subscribe_response::Info::Schema(v) => {
14078 struct_ser.serialize_field("schema", v)?;
14079 }
14080 subscribe_response::Info::Function(v) => {
14081 struct_ser.serialize_field("function", v)?;
14082 }
14083 subscribe_response::Info::User(v) => {
14084 struct_ser.serialize_field("user", v)?;
14085 }
14086 subscribe_response::Info::SessionParam(v) => {
14087 struct_ser.serialize_field("sessionParam", v)?;
14088 }
14089 subscribe_response::Info::Node(v) => {
14090 struct_ser.serialize_field("node", v)?;
14091 }
14092 subscribe_response::Info::HummockVersionDeltas(v) => {
14093 struct_ser.serialize_field("hummockVersionDeltas", v)?;
14094 }
14095 subscribe_response::Info::Snapshot(v) => {
14096 struct_ser.serialize_field("snapshot", v)?;
14097 }
14098 subscribe_response::Info::MetaBackupManifestId(v) => {
14099 struct_ser.serialize_field("metaBackupManifestId", v)?;
14100 }
14101 subscribe_response::Info::SystemParams(v) => {
14102 struct_ser.serialize_field("systemParams", v)?;
14103 }
14104 subscribe_response::Info::HummockWriteLimits(v) => {
14105 struct_ser.serialize_field("hummockWriteLimits", v)?;
14106 }
14107 subscribe_response::Info::ObjectGroup(v) => {
14108 struct_ser.serialize_field("objectGroup", v)?;
14109 }
14110 subscribe_response::Info::Connection(v) => {
14111 struct_ser.serialize_field("connection", v)?;
14112 }
14113 subscribe_response::Info::HummockStats(v) => {
14114 struct_ser.serialize_field("hummockStats", v)?;
14115 }
14116 subscribe_response::Info::Recovery(v) => {
14117 struct_ser.serialize_field("recovery", v)?;
14118 }
14119 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
14120 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
14121 }
14122 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
14123 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
14124 }
14125 subscribe_response::Info::Secret(v) => {
14126 struct_ser.serialize_field("secret", v)?;
14127 }
14128 subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
14129 #[allow(clippy::needless_borrow)]
14130 #[allow(clippy::needless_borrows_for_generic_args)]
14131 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
14132 }
14133 }
14134 }
14135 struct_ser.end()
14136 }
14137}
14138impl<'de> serde::Deserialize<'de> for SubscribeResponse {
14139 #[allow(deprecated)]
14140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14141 where
14142 D: serde::Deserializer<'de>,
14143 {
14144 const FIELDS: &[&str] = &[
14145 "status",
14146 "operation",
14147 "version",
14148 "database",
14149 "schema",
14150 "function",
14151 "user",
14152 "session_param",
14153 "sessionParam",
14154 "node",
14155 "hummock_version_deltas",
14156 "hummockVersionDeltas",
14157 "snapshot",
14158 "meta_backup_manifest_id",
14159 "metaBackupManifestId",
14160 "system_params",
14161 "systemParams",
14162 "hummock_write_limits",
14163 "hummockWriteLimits",
14164 "object_group",
14165 "objectGroup",
14166 "connection",
14167 "hummock_stats",
14168 "hummockStats",
14169 "recovery",
14170 "streaming_worker_slot_mapping",
14171 "streamingWorkerSlotMapping",
14172 "serving_worker_slot_mappings",
14173 "servingWorkerSlotMappings",
14174 "secret",
14175 "compute_node_total_cpu_count",
14176 "computeNodeTotalCpuCount",
14177 ];
14178
14179 #[allow(clippy::enum_variant_names)]
14180 enum GeneratedField {
14181 Status,
14182 Operation,
14183 Version,
14184 Database,
14185 Schema,
14186 Function,
14187 User,
14188 SessionParam,
14189 Node,
14190 HummockVersionDeltas,
14191 Snapshot,
14192 MetaBackupManifestId,
14193 SystemParams,
14194 HummockWriteLimits,
14195 ObjectGroup,
14196 Connection,
14197 HummockStats,
14198 Recovery,
14199 StreamingWorkerSlotMapping,
14200 ServingWorkerSlotMappings,
14201 Secret,
14202 ComputeNodeTotalCpuCount,
14203 }
14204 impl<'de> serde::Deserialize<'de> for GeneratedField {
14205 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14206 where
14207 D: serde::Deserializer<'de>,
14208 {
14209 struct GeneratedVisitor;
14210
14211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14212 type Value = GeneratedField;
14213
14214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14215 write!(formatter, "expected one of: {:?}", &FIELDS)
14216 }
14217
14218 #[allow(unused_variables)]
14219 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14220 where
14221 E: serde::de::Error,
14222 {
14223 match value {
14224 "status" => Ok(GeneratedField::Status),
14225 "operation" => Ok(GeneratedField::Operation),
14226 "version" => Ok(GeneratedField::Version),
14227 "database" => Ok(GeneratedField::Database),
14228 "schema" => Ok(GeneratedField::Schema),
14229 "function" => Ok(GeneratedField::Function),
14230 "user" => Ok(GeneratedField::User),
14231 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14232 "node" => Ok(GeneratedField::Node),
14233 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14234 "snapshot" => Ok(GeneratedField::Snapshot),
14235 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14236 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14237 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14238 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14239 "connection" => Ok(GeneratedField::Connection),
14240 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14241 "recovery" => Ok(GeneratedField::Recovery),
14242 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14243 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14244 "secret" => Ok(GeneratedField::Secret),
14245 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
14246 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14247 }
14248 }
14249 }
14250 deserializer.deserialize_identifier(GeneratedVisitor)
14251 }
14252 }
14253 struct GeneratedVisitor;
14254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14255 type Value = SubscribeResponse;
14256
14257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14258 formatter.write_str("struct meta.SubscribeResponse")
14259 }
14260
14261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14262 where
14263 V: serde::de::MapAccess<'de>,
14264 {
14265 let mut status__ = None;
14266 let mut operation__ = None;
14267 let mut version__ = None;
14268 let mut info__ = None;
14269 while let Some(k) = map_.next_key()? {
14270 match k {
14271 GeneratedField::Status => {
14272 if status__.is_some() {
14273 return Err(serde::de::Error::duplicate_field("status"));
14274 }
14275 status__ = map_.next_value()?;
14276 }
14277 GeneratedField::Operation => {
14278 if operation__.is_some() {
14279 return Err(serde::de::Error::duplicate_field("operation"));
14280 }
14281 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14282 }
14283 GeneratedField::Version => {
14284 if version__.is_some() {
14285 return Err(serde::de::Error::duplicate_field("version"));
14286 }
14287 version__ =
14288 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14289 ;
14290 }
14291 GeneratedField::Database => {
14292 if info__.is_some() {
14293 return Err(serde::de::Error::duplicate_field("database"));
14294 }
14295 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14296;
14297 }
14298 GeneratedField::Schema => {
14299 if info__.is_some() {
14300 return Err(serde::de::Error::duplicate_field("schema"));
14301 }
14302 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14303;
14304 }
14305 GeneratedField::Function => {
14306 if info__.is_some() {
14307 return Err(serde::de::Error::duplicate_field("function"));
14308 }
14309 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14310;
14311 }
14312 GeneratedField::User => {
14313 if info__.is_some() {
14314 return Err(serde::de::Error::duplicate_field("user"));
14315 }
14316 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14317;
14318 }
14319 GeneratedField::SessionParam => {
14320 if info__.is_some() {
14321 return Err(serde::de::Error::duplicate_field("sessionParam"));
14322 }
14323 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14324;
14325 }
14326 GeneratedField::Node => {
14327 if info__.is_some() {
14328 return Err(serde::de::Error::duplicate_field("node"));
14329 }
14330 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14331;
14332 }
14333 GeneratedField::HummockVersionDeltas => {
14334 if info__.is_some() {
14335 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14336 }
14337 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14338;
14339 }
14340 GeneratedField::Snapshot => {
14341 if info__.is_some() {
14342 return Err(serde::de::Error::duplicate_field("snapshot"));
14343 }
14344 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14345;
14346 }
14347 GeneratedField::MetaBackupManifestId => {
14348 if info__.is_some() {
14349 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14350 }
14351 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14352;
14353 }
14354 GeneratedField::SystemParams => {
14355 if info__.is_some() {
14356 return Err(serde::de::Error::duplicate_field("systemParams"));
14357 }
14358 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14359;
14360 }
14361 GeneratedField::HummockWriteLimits => {
14362 if info__.is_some() {
14363 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14364 }
14365 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14366;
14367 }
14368 GeneratedField::ObjectGroup => {
14369 if info__.is_some() {
14370 return Err(serde::de::Error::duplicate_field("objectGroup"));
14371 }
14372 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14373;
14374 }
14375 GeneratedField::Connection => {
14376 if info__.is_some() {
14377 return Err(serde::de::Error::duplicate_field("connection"));
14378 }
14379 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14380;
14381 }
14382 GeneratedField::HummockStats => {
14383 if info__.is_some() {
14384 return Err(serde::de::Error::duplicate_field("hummockStats"));
14385 }
14386 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14387;
14388 }
14389 GeneratedField::Recovery => {
14390 if info__.is_some() {
14391 return Err(serde::de::Error::duplicate_field("recovery"));
14392 }
14393 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14394;
14395 }
14396 GeneratedField::StreamingWorkerSlotMapping => {
14397 if info__.is_some() {
14398 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14399 }
14400 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14401;
14402 }
14403 GeneratedField::ServingWorkerSlotMappings => {
14404 if info__.is_some() {
14405 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14406 }
14407 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14408;
14409 }
14410 GeneratedField::Secret => {
14411 if info__.is_some() {
14412 return Err(serde::de::Error::duplicate_field("secret"));
14413 }
14414 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14415;
14416 }
14417 GeneratedField::ComputeNodeTotalCpuCount => {
14418 if info__.is_some() {
14419 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
14420 }
14421 info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
14422 }
14423 }
14424 }
14425 Ok(SubscribeResponse {
14426 status: status__,
14427 operation: operation__.unwrap_or_default(),
14428 version: version__.unwrap_or_default(),
14429 info: info__,
14430 })
14431 }
14432 }
14433 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14434 }
14435}
14436impl serde::Serialize for subscribe_response::Operation {
14437 #[allow(deprecated)]
14438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14439 where
14440 S: serde::Serializer,
14441 {
14442 let variant = match self {
14443 Self::Unspecified => "UNSPECIFIED",
14444 Self::Add => "ADD",
14445 Self::Delete => "DELETE",
14446 Self::Update => "UPDATE",
14447 Self::Snapshot => "SNAPSHOT",
14448 };
14449 serializer.serialize_str(variant)
14450 }
14451}
14452impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14453 #[allow(deprecated)]
14454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14455 where
14456 D: serde::Deserializer<'de>,
14457 {
14458 const FIELDS: &[&str] = &[
14459 "UNSPECIFIED",
14460 "ADD",
14461 "DELETE",
14462 "UPDATE",
14463 "SNAPSHOT",
14464 ];
14465
14466 struct GeneratedVisitor;
14467
14468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14469 type Value = subscribe_response::Operation;
14470
14471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14472 write!(formatter, "expected one of: {:?}", &FIELDS)
14473 }
14474
14475 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14476 where
14477 E: serde::de::Error,
14478 {
14479 i32::try_from(v)
14480 .ok()
14481 .and_then(|x| x.try_into().ok())
14482 .ok_or_else(|| {
14483 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14484 })
14485 }
14486
14487 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14488 where
14489 E: serde::de::Error,
14490 {
14491 i32::try_from(v)
14492 .ok()
14493 .and_then(|x| x.try_into().ok())
14494 .ok_or_else(|| {
14495 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14496 })
14497 }
14498
14499 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14500 where
14501 E: serde::de::Error,
14502 {
14503 match value {
14504 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14505 "ADD" => Ok(subscribe_response::Operation::Add),
14506 "DELETE" => Ok(subscribe_response::Operation::Delete),
14507 "UPDATE" => Ok(subscribe_response::Operation::Update),
14508 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14509 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14510 }
14511 }
14512 }
14513 deserializer.deserialize_any(GeneratedVisitor)
14514 }
14515}
14516impl serde::Serialize for SubscribeType {
14517 #[allow(deprecated)]
14518 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14519 where
14520 S: serde::Serializer,
14521 {
14522 let variant = match self {
14523 Self::Unspecified => "UNSPECIFIED",
14524 Self::Frontend => "FRONTEND",
14525 Self::Hummock => "HUMMOCK",
14526 Self::Compactor => "COMPACTOR",
14527 Self::Compute => "COMPUTE",
14528 };
14529 serializer.serialize_str(variant)
14530 }
14531}
14532impl<'de> serde::Deserialize<'de> for SubscribeType {
14533 #[allow(deprecated)]
14534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14535 where
14536 D: serde::Deserializer<'de>,
14537 {
14538 const FIELDS: &[&str] = &[
14539 "UNSPECIFIED",
14540 "FRONTEND",
14541 "HUMMOCK",
14542 "COMPACTOR",
14543 "COMPUTE",
14544 ];
14545
14546 struct GeneratedVisitor;
14547
14548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14549 type Value = SubscribeType;
14550
14551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14552 write!(formatter, "expected one of: {:?}", &FIELDS)
14553 }
14554
14555 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14556 where
14557 E: serde::de::Error,
14558 {
14559 i32::try_from(v)
14560 .ok()
14561 .and_then(|x| x.try_into().ok())
14562 .ok_or_else(|| {
14563 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14564 })
14565 }
14566
14567 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14568 where
14569 E: serde::de::Error,
14570 {
14571 i32::try_from(v)
14572 .ok()
14573 .and_then(|x| x.try_into().ok())
14574 .ok_or_else(|| {
14575 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14576 })
14577 }
14578
14579 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14580 where
14581 E: serde::de::Error,
14582 {
14583 match value {
14584 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
14585 "FRONTEND" => Ok(SubscribeType::Frontend),
14586 "HUMMOCK" => Ok(SubscribeType::Hummock),
14587 "COMPACTOR" => Ok(SubscribeType::Compactor),
14588 "COMPUTE" => Ok(SubscribeType::Compute),
14589 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14590 }
14591 }
14592 }
14593 deserializer.deserialize_any(GeneratedVisitor)
14594 }
14595}
14596impl serde::Serialize for SystemParams {
14597 #[allow(deprecated)]
14598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14599 where
14600 S: serde::Serializer,
14601 {
14602 use serde::ser::SerializeStruct;
14603 let mut len = 0;
14604 if self.barrier_interval_ms.is_some() {
14605 len += 1;
14606 }
14607 if self.checkpoint_frequency.is_some() {
14608 len += 1;
14609 }
14610 if self.sstable_size_mb.is_some() {
14611 len += 1;
14612 }
14613 if self.block_size_kb.is_some() {
14614 len += 1;
14615 }
14616 if self.bloom_false_positive.is_some() {
14617 len += 1;
14618 }
14619 if self.state_store.is_some() {
14620 len += 1;
14621 }
14622 if self.data_directory.is_some() {
14623 len += 1;
14624 }
14625 if self.backup_storage_url.is_some() {
14626 len += 1;
14627 }
14628 if self.backup_storage_directory.is_some() {
14629 len += 1;
14630 }
14631 if self.telemetry_enabled.is_some() {
14632 len += 1;
14633 }
14634 if self.parallel_compact_size_mb.is_some() {
14635 len += 1;
14636 }
14637 if self.max_concurrent_creating_streaming_jobs.is_some() {
14638 len += 1;
14639 }
14640 if self.pause_on_next_bootstrap.is_some() {
14641 len += 1;
14642 }
14643 if self.wasm_storage_url.is_some() {
14644 len += 1;
14645 }
14646 if self.enable_tracing.is_some() {
14647 len += 1;
14648 }
14649 if self.use_new_object_prefix_strategy.is_some() {
14650 len += 1;
14651 }
14652 if self.license_key.is_some() {
14653 len += 1;
14654 }
14655 if self.time_travel_retention_ms.is_some() {
14656 len += 1;
14657 }
14658 if self.adaptive_parallelism_strategy.is_some() {
14659 len += 1;
14660 }
14661 if self.per_database_isolation.is_some() {
14662 len += 1;
14663 }
14664 if self.enforce_secret.is_some() {
14665 len += 1;
14666 }
14667 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
14668 if let Some(v) = self.barrier_interval_ms.as_ref() {
14669 struct_ser.serialize_field("barrierIntervalMs", v)?;
14670 }
14671 if let Some(v) = self.checkpoint_frequency.as_ref() {
14672 #[allow(clippy::needless_borrow)]
14673 #[allow(clippy::needless_borrows_for_generic_args)]
14674 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
14675 }
14676 if let Some(v) = self.sstable_size_mb.as_ref() {
14677 struct_ser.serialize_field("sstableSizeMb", v)?;
14678 }
14679 if let Some(v) = self.block_size_kb.as_ref() {
14680 struct_ser.serialize_field("blockSizeKb", v)?;
14681 }
14682 if let Some(v) = self.bloom_false_positive.as_ref() {
14683 struct_ser.serialize_field("bloomFalsePositive", v)?;
14684 }
14685 if let Some(v) = self.state_store.as_ref() {
14686 struct_ser.serialize_field("stateStore", v)?;
14687 }
14688 if let Some(v) = self.data_directory.as_ref() {
14689 struct_ser.serialize_field("dataDirectory", v)?;
14690 }
14691 if let Some(v) = self.backup_storage_url.as_ref() {
14692 struct_ser.serialize_field("backupStorageUrl", v)?;
14693 }
14694 if let Some(v) = self.backup_storage_directory.as_ref() {
14695 struct_ser.serialize_field("backupStorageDirectory", v)?;
14696 }
14697 if let Some(v) = self.telemetry_enabled.as_ref() {
14698 struct_ser.serialize_field("telemetryEnabled", v)?;
14699 }
14700 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
14701 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
14702 }
14703 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
14704 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
14705 }
14706 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
14707 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
14708 }
14709 if let Some(v) = self.wasm_storage_url.as_ref() {
14710 struct_ser.serialize_field("wasmStorageUrl", v)?;
14711 }
14712 if let Some(v) = self.enable_tracing.as_ref() {
14713 struct_ser.serialize_field("enableTracing", v)?;
14714 }
14715 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
14716 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
14717 }
14718 if let Some(v) = self.license_key.as_ref() {
14719 struct_ser.serialize_field("licenseKey", v)?;
14720 }
14721 if let Some(v) = self.time_travel_retention_ms.as_ref() {
14722 #[allow(clippy::needless_borrow)]
14723 #[allow(clippy::needless_borrows_for_generic_args)]
14724 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
14725 }
14726 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
14727 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
14728 }
14729 if let Some(v) = self.per_database_isolation.as_ref() {
14730 struct_ser.serialize_field("perDatabaseIsolation", v)?;
14731 }
14732 if let Some(v) = self.enforce_secret.as_ref() {
14733 struct_ser.serialize_field("enforceSecret", v)?;
14734 }
14735 struct_ser.end()
14736 }
14737}
14738impl<'de> serde::Deserialize<'de> for SystemParams {
14739 #[allow(deprecated)]
14740 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14741 where
14742 D: serde::Deserializer<'de>,
14743 {
14744 const FIELDS: &[&str] = &[
14745 "barrier_interval_ms",
14746 "barrierIntervalMs",
14747 "checkpoint_frequency",
14748 "checkpointFrequency",
14749 "sstable_size_mb",
14750 "sstableSizeMb",
14751 "block_size_kb",
14752 "blockSizeKb",
14753 "bloom_false_positive",
14754 "bloomFalsePositive",
14755 "state_store",
14756 "stateStore",
14757 "data_directory",
14758 "dataDirectory",
14759 "backup_storage_url",
14760 "backupStorageUrl",
14761 "backup_storage_directory",
14762 "backupStorageDirectory",
14763 "telemetry_enabled",
14764 "telemetryEnabled",
14765 "parallel_compact_size_mb",
14766 "parallelCompactSizeMb",
14767 "max_concurrent_creating_streaming_jobs",
14768 "maxConcurrentCreatingStreamingJobs",
14769 "pause_on_next_bootstrap",
14770 "pauseOnNextBootstrap",
14771 "wasm_storage_url",
14772 "wasmStorageUrl",
14773 "enable_tracing",
14774 "enableTracing",
14775 "use_new_object_prefix_strategy",
14776 "useNewObjectPrefixStrategy",
14777 "license_key",
14778 "licenseKey",
14779 "time_travel_retention_ms",
14780 "timeTravelRetentionMs",
14781 "adaptive_parallelism_strategy",
14782 "adaptiveParallelismStrategy",
14783 "per_database_isolation",
14784 "perDatabaseIsolation",
14785 "enforce_secret",
14786 "enforceSecret",
14787 ];
14788
14789 #[allow(clippy::enum_variant_names)]
14790 enum GeneratedField {
14791 BarrierIntervalMs,
14792 CheckpointFrequency,
14793 SstableSizeMb,
14794 BlockSizeKb,
14795 BloomFalsePositive,
14796 StateStore,
14797 DataDirectory,
14798 BackupStorageUrl,
14799 BackupStorageDirectory,
14800 TelemetryEnabled,
14801 ParallelCompactSizeMb,
14802 MaxConcurrentCreatingStreamingJobs,
14803 PauseOnNextBootstrap,
14804 WasmStorageUrl,
14805 EnableTracing,
14806 UseNewObjectPrefixStrategy,
14807 LicenseKey,
14808 TimeTravelRetentionMs,
14809 AdaptiveParallelismStrategy,
14810 PerDatabaseIsolation,
14811 EnforceSecret,
14812 }
14813 impl<'de> serde::Deserialize<'de> for GeneratedField {
14814 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14815 where
14816 D: serde::Deserializer<'de>,
14817 {
14818 struct GeneratedVisitor;
14819
14820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14821 type Value = GeneratedField;
14822
14823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14824 write!(formatter, "expected one of: {:?}", &FIELDS)
14825 }
14826
14827 #[allow(unused_variables)]
14828 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14829 where
14830 E: serde::de::Error,
14831 {
14832 match value {
14833 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
14834 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
14835 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
14836 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
14837 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
14838 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
14839 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
14840 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
14841 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
14842 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
14843 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
14844 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
14845 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
14846 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
14847 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
14848 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
14849 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
14850 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
14851 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
14852 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
14853 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
14854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14855 }
14856 }
14857 }
14858 deserializer.deserialize_identifier(GeneratedVisitor)
14859 }
14860 }
14861 struct GeneratedVisitor;
14862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14863 type Value = SystemParams;
14864
14865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14866 formatter.write_str("struct meta.SystemParams")
14867 }
14868
14869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
14870 where
14871 V: serde::de::MapAccess<'de>,
14872 {
14873 let mut barrier_interval_ms__ = None;
14874 let mut checkpoint_frequency__ = None;
14875 let mut sstable_size_mb__ = None;
14876 let mut block_size_kb__ = None;
14877 let mut bloom_false_positive__ = None;
14878 let mut state_store__ = None;
14879 let mut data_directory__ = None;
14880 let mut backup_storage_url__ = None;
14881 let mut backup_storage_directory__ = None;
14882 let mut telemetry_enabled__ = None;
14883 let mut parallel_compact_size_mb__ = None;
14884 let mut max_concurrent_creating_streaming_jobs__ = None;
14885 let mut pause_on_next_bootstrap__ = None;
14886 let mut wasm_storage_url__ = None;
14887 let mut enable_tracing__ = None;
14888 let mut use_new_object_prefix_strategy__ = None;
14889 let mut license_key__ = None;
14890 let mut time_travel_retention_ms__ = None;
14891 let mut adaptive_parallelism_strategy__ = None;
14892 let mut per_database_isolation__ = None;
14893 let mut enforce_secret__ = None;
14894 while let Some(k) = map_.next_key()? {
14895 match k {
14896 GeneratedField::BarrierIntervalMs => {
14897 if barrier_interval_ms__.is_some() {
14898 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
14899 }
14900 barrier_interval_ms__ =
14901 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14902 ;
14903 }
14904 GeneratedField::CheckpointFrequency => {
14905 if checkpoint_frequency__.is_some() {
14906 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
14907 }
14908 checkpoint_frequency__ =
14909 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14910 ;
14911 }
14912 GeneratedField::SstableSizeMb => {
14913 if sstable_size_mb__.is_some() {
14914 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
14915 }
14916 sstable_size_mb__ =
14917 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14918 ;
14919 }
14920 GeneratedField::BlockSizeKb => {
14921 if block_size_kb__.is_some() {
14922 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
14923 }
14924 block_size_kb__ =
14925 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14926 ;
14927 }
14928 GeneratedField::BloomFalsePositive => {
14929 if bloom_false_positive__.is_some() {
14930 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
14931 }
14932 bloom_false_positive__ =
14933 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14934 ;
14935 }
14936 GeneratedField::StateStore => {
14937 if state_store__.is_some() {
14938 return Err(serde::de::Error::duplicate_field("stateStore"));
14939 }
14940 state_store__ = map_.next_value()?;
14941 }
14942 GeneratedField::DataDirectory => {
14943 if data_directory__.is_some() {
14944 return Err(serde::de::Error::duplicate_field("dataDirectory"));
14945 }
14946 data_directory__ = map_.next_value()?;
14947 }
14948 GeneratedField::BackupStorageUrl => {
14949 if backup_storage_url__.is_some() {
14950 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
14951 }
14952 backup_storage_url__ = map_.next_value()?;
14953 }
14954 GeneratedField::BackupStorageDirectory => {
14955 if backup_storage_directory__.is_some() {
14956 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
14957 }
14958 backup_storage_directory__ = map_.next_value()?;
14959 }
14960 GeneratedField::TelemetryEnabled => {
14961 if telemetry_enabled__.is_some() {
14962 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
14963 }
14964 telemetry_enabled__ = map_.next_value()?;
14965 }
14966 GeneratedField::ParallelCompactSizeMb => {
14967 if parallel_compact_size_mb__.is_some() {
14968 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
14969 }
14970 parallel_compact_size_mb__ =
14971 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14972 ;
14973 }
14974 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
14975 if max_concurrent_creating_streaming_jobs__.is_some() {
14976 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
14977 }
14978 max_concurrent_creating_streaming_jobs__ =
14979 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14980 ;
14981 }
14982 GeneratedField::PauseOnNextBootstrap => {
14983 if pause_on_next_bootstrap__.is_some() {
14984 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
14985 }
14986 pause_on_next_bootstrap__ = map_.next_value()?;
14987 }
14988 GeneratedField::WasmStorageUrl => {
14989 if wasm_storage_url__.is_some() {
14990 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
14991 }
14992 wasm_storage_url__ = map_.next_value()?;
14993 }
14994 GeneratedField::EnableTracing => {
14995 if enable_tracing__.is_some() {
14996 return Err(serde::de::Error::duplicate_field("enableTracing"));
14997 }
14998 enable_tracing__ = map_.next_value()?;
14999 }
15000 GeneratedField::UseNewObjectPrefixStrategy => {
15001 if use_new_object_prefix_strategy__.is_some() {
15002 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
15003 }
15004 use_new_object_prefix_strategy__ = map_.next_value()?;
15005 }
15006 GeneratedField::LicenseKey => {
15007 if license_key__.is_some() {
15008 return Err(serde::de::Error::duplicate_field("licenseKey"));
15009 }
15010 license_key__ = map_.next_value()?;
15011 }
15012 GeneratedField::TimeTravelRetentionMs => {
15013 if time_travel_retention_ms__.is_some() {
15014 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
15015 }
15016 time_travel_retention_ms__ =
15017 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15018 ;
15019 }
15020 GeneratedField::AdaptiveParallelismStrategy => {
15021 if adaptive_parallelism_strategy__.is_some() {
15022 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15023 }
15024 adaptive_parallelism_strategy__ = map_.next_value()?;
15025 }
15026 GeneratedField::PerDatabaseIsolation => {
15027 if per_database_isolation__.is_some() {
15028 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
15029 }
15030 per_database_isolation__ = map_.next_value()?;
15031 }
15032 GeneratedField::EnforceSecret => {
15033 if enforce_secret__.is_some() {
15034 return Err(serde::de::Error::duplicate_field("enforceSecret"));
15035 }
15036 enforce_secret__ = map_.next_value()?;
15037 }
15038 }
15039 }
15040 Ok(SystemParams {
15041 barrier_interval_ms: barrier_interval_ms__,
15042 checkpoint_frequency: checkpoint_frequency__,
15043 sstable_size_mb: sstable_size_mb__,
15044 block_size_kb: block_size_kb__,
15045 bloom_false_positive: bloom_false_positive__,
15046 state_store: state_store__,
15047 data_directory: data_directory__,
15048 backup_storage_url: backup_storage_url__,
15049 backup_storage_directory: backup_storage_directory__,
15050 telemetry_enabled: telemetry_enabled__,
15051 parallel_compact_size_mb: parallel_compact_size_mb__,
15052 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
15053 pause_on_next_bootstrap: pause_on_next_bootstrap__,
15054 wasm_storage_url: wasm_storage_url__,
15055 enable_tracing: enable_tracing__,
15056 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
15057 license_key: license_key__,
15058 time_travel_retention_ms: time_travel_retention_ms__,
15059 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
15060 per_database_isolation: per_database_isolation__,
15061 enforce_secret: enforce_secret__,
15062 })
15063 }
15064 }
15065 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
15066 }
15067}
15068impl serde::Serialize for TableFragments {
15069 #[allow(deprecated)]
15070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15071 where
15072 S: serde::Serializer,
15073 {
15074 use serde::ser::SerializeStruct;
15075 let mut len = 0;
15076 if self.table_id != 0 {
15077 len += 1;
15078 }
15079 if self.state != 0 {
15080 len += 1;
15081 }
15082 if !self.fragments.is_empty() {
15083 len += 1;
15084 }
15085 if !self.actor_status.is_empty() {
15086 len += 1;
15087 }
15088 if !self.actor_splits.is_empty() {
15089 len += 1;
15090 }
15091 if self.ctx.is_some() {
15092 len += 1;
15093 }
15094 if self.parallelism.is_some() {
15095 len += 1;
15096 }
15097 if self.max_parallelism.is_some() {
15098 len += 1;
15099 }
15100 if !self.node_label.is_empty() {
15101 len += 1;
15102 }
15103 if self.backfill_done {
15104 len += 1;
15105 }
15106 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
15107 if self.table_id != 0 {
15108 struct_ser.serialize_field("tableId", &self.table_id)?;
15109 }
15110 if self.state != 0 {
15111 let v = table_fragments::State::try_from(self.state)
15112 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15113 struct_ser.serialize_field("state", &v)?;
15114 }
15115 if !self.fragments.is_empty() {
15116 struct_ser.serialize_field("fragments", &self.fragments)?;
15117 }
15118 if !self.actor_status.is_empty() {
15119 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
15120 }
15121 if !self.actor_splits.is_empty() {
15122 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
15123 }
15124 if let Some(v) = self.ctx.as_ref() {
15125 struct_ser.serialize_field("ctx", v)?;
15126 }
15127 if let Some(v) = self.parallelism.as_ref() {
15128 struct_ser.serialize_field("parallelism", v)?;
15129 }
15130 if let Some(v) = self.max_parallelism.as_ref() {
15131 struct_ser.serialize_field("maxParallelism", v)?;
15132 }
15133 if !self.node_label.is_empty() {
15134 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15135 }
15136 if self.backfill_done {
15137 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
15138 }
15139 struct_ser.end()
15140 }
15141}
15142impl<'de> serde::Deserialize<'de> for TableFragments {
15143 #[allow(deprecated)]
15144 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15145 where
15146 D: serde::Deserializer<'de>,
15147 {
15148 const FIELDS: &[&str] = &[
15149 "table_id",
15150 "tableId",
15151 "state",
15152 "fragments",
15153 "actor_status",
15154 "actorStatus",
15155 "actor_splits",
15156 "actorSplits",
15157 "ctx",
15158 "parallelism",
15159 "max_parallelism",
15160 "maxParallelism",
15161 "node_label",
15162 "nodeLabel",
15163 "backfill_done",
15164 "backfillDone",
15165 ];
15166
15167 #[allow(clippy::enum_variant_names)]
15168 enum GeneratedField {
15169 TableId,
15170 State,
15171 Fragments,
15172 ActorStatus,
15173 ActorSplits,
15174 Ctx,
15175 Parallelism,
15176 MaxParallelism,
15177 NodeLabel,
15178 BackfillDone,
15179 }
15180 impl<'de> serde::Deserialize<'de> for GeneratedField {
15181 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15182 where
15183 D: serde::Deserializer<'de>,
15184 {
15185 struct GeneratedVisitor;
15186
15187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15188 type Value = GeneratedField;
15189
15190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15191 write!(formatter, "expected one of: {:?}", &FIELDS)
15192 }
15193
15194 #[allow(unused_variables)]
15195 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15196 where
15197 E: serde::de::Error,
15198 {
15199 match value {
15200 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15201 "state" => Ok(GeneratedField::State),
15202 "fragments" => Ok(GeneratedField::Fragments),
15203 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
15204 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15205 "ctx" => Ok(GeneratedField::Ctx),
15206 "parallelism" => Ok(GeneratedField::Parallelism),
15207 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15208 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15209 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15211 }
15212 }
15213 }
15214 deserializer.deserialize_identifier(GeneratedVisitor)
15215 }
15216 }
15217 struct GeneratedVisitor;
15218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15219 type Value = TableFragments;
15220
15221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15222 formatter.write_str("struct meta.TableFragments")
15223 }
15224
15225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15226 where
15227 V: serde::de::MapAccess<'de>,
15228 {
15229 let mut table_id__ = None;
15230 let mut state__ = None;
15231 let mut fragments__ = None;
15232 let mut actor_status__ = None;
15233 let mut actor_splits__ = None;
15234 let mut ctx__ = None;
15235 let mut parallelism__ = None;
15236 let mut max_parallelism__ = None;
15237 let mut node_label__ = None;
15238 let mut backfill_done__ = None;
15239 while let Some(k) = map_.next_key()? {
15240 match k {
15241 GeneratedField::TableId => {
15242 if table_id__.is_some() {
15243 return Err(serde::de::Error::duplicate_field("tableId"));
15244 }
15245 table_id__ =
15246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15247 ;
15248 }
15249 GeneratedField::State => {
15250 if state__.is_some() {
15251 return Err(serde::de::Error::duplicate_field("state"));
15252 }
15253 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15254 }
15255 GeneratedField::Fragments => {
15256 if fragments__.is_some() {
15257 return Err(serde::de::Error::duplicate_field("fragments"));
15258 }
15259 fragments__ = Some(
15260 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15261 .into_iter().map(|(k,v)| (k.0, v)).collect()
15262 );
15263 }
15264 GeneratedField::ActorStatus => {
15265 if actor_status__.is_some() {
15266 return Err(serde::de::Error::duplicate_field("actorStatus"));
15267 }
15268 actor_status__ = Some(
15269 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15270 .into_iter().map(|(k,v)| (k.0, v)).collect()
15271 );
15272 }
15273 GeneratedField::ActorSplits => {
15274 if actor_splits__.is_some() {
15275 return Err(serde::de::Error::duplicate_field("actorSplits"));
15276 }
15277 actor_splits__ = Some(
15278 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15279 .into_iter().map(|(k,v)| (k.0, v)).collect()
15280 );
15281 }
15282 GeneratedField::Ctx => {
15283 if ctx__.is_some() {
15284 return Err(serde::de::Error::duplicate_field("ctx"));
15285 }
15286 ctx__ = map_.next_value()?;
15287 }
15288 GeneratedField::Parallelism => {
15289 if parallelism__.is_some() {
15290 return Err(serde::de::Error::duplicate_field("parallelism"));
15291 }
15292 parallelism__ = map_.next_value()?;
15293 }
15294 GeneratedField::MaxParallelism => {
15295 if max_parallelism__.is_some() {
15296 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15297 }
15298 max_parallelism__ =
15299 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15300 ;
15301 }
15302 GeneratedField::NodeLabel => {
15303 if node_label__.is_some() {
15304 return Err(serde::de::Error::duplicate_field("nodeLabel"));
15305 }
15306 node_label__ = Some(map_.next_value()?);
15307 }
15308 GeneratedField::BackfillDone => {
15309 if backfill_done__.is_some() {
15310 return Err(serde::de::Error::duplicate_field("backfillDone"));
15311 }
15312 backfill_done__ = Some(map_.next_value()?);
15313 }
15314 }
15315 }
15316 Ok(TableFragments {
15317 table_id: table_id__.unwrap_or_default(),
15318 state: state__.unwrap_or_default(),
15319 fragments: fragments__.unwrap_or_default(),
15320 actor_status: actor_status__.unwrap_or_default(),
15321 actor_splits: actor_splits__.unwrap_or_default(),
15322 ctx: ctx__,
15323 parallelism: parallelism__,
15324 max_parallelism: max_parallelism__,
15325 node_label: node_label__.unwrap_or_default(),
15326 backfill_done: backfill_done__.unwrap_or_default(),
15327 })
15328 }
15329 }
15330 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15331 }
15332}
15333impl serde::Serialize for table_fragments::ActorStatus {
15334 #[allow(deprecated)]
15335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15336 where
15337 S: serde::Serializer,
15338 {
15339 use serde::ser::SerializeStruct;
15340 let mut len = 0;
15341 if self.location.is_some() {
15342 len += 1;
15343 }
15344 if self.state != 0 {
15345 len += 1;
15346 }
15347 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15348 if let Some(v) = self.location.as_ref() {
15349 struct_ser.serialize_field("location", v)?;
15350 }
15351 if self.state != 0 {
15352 let v = table_fragments::actor_status::ActorState::try_from(self.state)
15353 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15354 struct_ser.serialize_field("state", &v)?;
15355 }
15356 struct_ser.end()
15357 }
15358}
15359impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15360 #[allow(deprecated)]
15361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15362 where
15363 D: serde::Deserializer<'de>,
15364 {
15365 const FIELDS: &[&str] = &[
15366 "location",
15367 "state",
15368 ];
15369
15370 #[allow(clippy::enum_variant_names)]
15371 enum GeneratedField {
15372 Location,
15373 State,
15374 }
15375 impl<'de> serde::Deserialize<'de> for GeneratedField {
15376 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15377 where
15378 D: serde::Deserializer<'de>,
15379 {
15380 struct GeneratedVisitor;
15381
15382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15383 type Value = GeneratedField;
15384
15385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15386 write!(formatter, "expected one of: {:?}", &FIELDS)
15387 }
15388
15389 #[allow(unused_variables)]
15390 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15391 where
15392 E: serde::de::Error,
15393 {
15394 match value {
15395 "location" => Ok(GeneratedField::Location),
15396 "state" => Ok(GeneratedField::State),
15397 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15398 }
15399 }
15400 }
15401 deserializer.deserialize_identifier(GeneratedVisitor)
15402 }
15403 }
15404 struct GeneratedVisitor;
15405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15406 type Value = table_fragments::ActorStatus;
15407
15408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15409 formatter.write_str("struct meta.TableFragments.ActorStatus")
15410 }
15411
15412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15413 where
15414 V: serde::de::MapAccess<'de>,
15415 {
15416 let mut location__ = None;
15417 let mut state__ = None;
15418 while let Some(k) = map_.next_key()? {
15419 match k {
15420 GeneratedField::Location => {
15421 if location__.is_some() {
15422 return Err(serde::de::Error::duplicate_field("location"));
15423 }
15424 location__ = map_.next_value()?;
15425 }
15426 GeneratedField::State => {
15427 if state__.is_some() {
15428 return Err(serde::de::Error::duplicate_field("state"));
15429 }
15430 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15431 }
15432 }
15433 }
15434 Ok(table_fragments::ActorStatus {
15435 location: location__,
15436 state: state__.unwrap_or_default(),
15437 })
15438 }
15439 }
15440 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15441 }
15442}
15443impl serde::Serialize for table_fragments::actor_status::ActorState {
15444 #[allow(deprecated)]
15445 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15446 where
15447 S: serde::Serializer,
15448 {
15449 let variant = match self {
15450 Self::Unspecified => "UNSPECIFIED",
15451 Self::Inactive => "INACTIVE",
15452 Self::Running => "RUNNING",
15453 };
15454 serializer.serialize_str(variant)
15455 }
15456}
15457impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15458 #[allow(deprecated)]
15459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15460 where
15461 D: serde::Deserializer<'de>,
15462 {
15463 const FIELDS: &[&str] = &[
15464 "UNSPECIFIED",
15465 "INACTIVE",
15466 "RUNNING",
15467 ];
15468
15469 struct GeneratedVisitor;
15470
15471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15472 type Value = table_fragments::actor_status::ActorState;
15473
15474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15475 write!(formatter, "expected one of: {:?}", &FIELDS)
15476 }
15477
15478 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15479 where
15480 E: serde::de::Error,
15481 {
15482 i32::try_from(v)
15483 .ok()
15484 .and_then(|x| x.try_into().ok())
15485 .ok_or_else(|| {
15486 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15487 })
15488 }
15489
15490 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15491 where
15492 E: serde::de::Error,
15493 {
15494 i32::try_from(v)
15495 .ok()
15496 .and_then(|x| x.try_into().ok())
15497 .ok_or_else(|| {
15498 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15499 })
15500 }
15501
15502 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15503 where
15504 E: serde::de::Error,
15505 {
15506 match value {
15507 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15508 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15509 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15510 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15511 }
15512 }
15513 }
15514 deserializer.deserialize_any(GeneratedVisitor)
15515 }
15516}
15517impl serde::Serialize for table_fragments::Fragment {
15518 #[allow(deprecated)]
15519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15520 where
15521 S: serde::Serializer,
15522 {
15523 use serde::ser::SerializeStruct;
15524 let mut len = 0;
15525 if self.fragment_id != 0 {
15526 len += 1;
15527 }
15528 if self.fragment_type_mask != 0 {
15529 len += 1;
15530 }
15531 if self.distribution_type != 0 {
15532 len += 1;
15533 }
15534 if !self.actors.is_empty() {
15535 len += 1;
15536 }
15537 if !self.state_table_ids.is_empty() {
15538 len += 1;
15539 }
15540 if !self.upstream_fragment_ids.is_empty() {
15541 len += 1;
15542 }
15543 if self.maybe_vnode_count.is_some() {
15544 len += 1;
15545 }
15546 if self.nodes.is_some() {
15547 len += 1;
15548 }
15549 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15550 if self.fragment_id != 0 {
15551 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15552 }
15553 if self.fragment_type_mask != 0 {
15554 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15555 }
15556 if self.distribution_type != 0 {
15557 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15558 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15559 struct_ser.serialize_field("distributionType", &v)?;
15560 }
15561 if !self.actors.is_empty() {
15562 struct_ser.serialize_field("actors", &self.actors)?;
15563 }
15564 if !self.state_table_ids.is_empty() {
15565 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
15566 }
15567 if !self.upstream_fragment_ids.is_empty() {
15568 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
15569 }
15570 if let Some(v) = self.maybe_vnode_count.as_ref() {
15571 struct_ser.serialize_field("maybeVnodeCount", v)?;
15572 }
15573 if let Some(v) = self.nodes.as_ref() {
15574 struct_ser.serialize_field("nodes", v)?;
15575 }
15576 struct_ser.end()
15577 }
15578}
15579impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
15580 #[allow(deprecated)]
15581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15582 where
15583 D: serde::Deserializer<'de>,
15584 {
15585 const FIELDS: &[&str] = &[
15586 "fragment_id",
15587 "fragmentId",
15588 "fragment_type_mask",
15589 "fragmentTypeMask",
15590 "distribution_type",
15591 "distributionType",
15592 "actors",
15593 "state_table_ids",
15594 "stateTableIds",
15595 "upstream_fragment_ids",
15596 "upstreamFragmentIds",
15597 "maybe_vnode_count",
15598 "maybeVnodeCount",
15599 "nodes",
15600 ];
15601
15602 #[allow(clippy::enum_variant_names)]
15603 enum GeneratedField {
15604 FragmentId,
15605 FragmentTypeMask,
15606 DistributionType,
15607 Actors,
15608 StateTableIds,
15609 UpstreamFragmentIds,
15610 MaybeVnodeCount,
15611 Nodes,
15612 }
15613 impl<'de> serde::Deserialize<'de> for GeneratedField {
15614 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15615 where
15616 D: serde::Deserializer<'de>,
15617 {
15618 struct GeneratedVisitor;
15619
15620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15621 type Value = GeneratedField;
15622
15623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15624 write!(formatter, "expected one of: {:?}", &FIELDS)
15625 }
15626
15627 #[allow(unused_variables)]
15628 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15629 where
15630 E: serde::de::Error,
15631 {
15632 match value {
15633 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15634 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15635 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
15636 "actors" => Ok(GeneratedField::Actors),
15637 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
15638 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
15639 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
15640 "nodes" => Ok(GeneratedField::Nodes),
15641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15642 }
15643 }
15644 }
15645 deserializer.deserialize_identifier(GeneratedVisitor)
15646 }
15647 }
15648 struct GeneratedVisitor;
15649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15650 type Value = table_fragments::Fragment;
15651
15652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15653 formatter.write_str("struct meta.TableFragments.Fragment")
15654 }
15655
15656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
15657 where
15658 V: serde::de::MapAccess<'de>,
15659 {
15660 let mut fragment_id__ = None;
15661 let mut fragment_type_mask__ = None;
15662 let mut distribution_type__ = None;
15663 let mut actors__ = None;
15664 let mut state_table_ids__ = None;
15665 let mut upstream_fragment_ids__ = None;
15666 let mut maybe_vnode_count__ = None;
15667 let mut nodes__ = None;
15668 while let Some(k) = map_.next_key()? {
15669 match k {
15670 GeneratedField::FragmentId => {
15671 if fragment_id__.is_some() {
15672 return Err(serde::de::Error::duplicate_field("fragmentId"));
15673 }
15674 fragment_id__ =
15675 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15676 ;
15677 }
15678 GeneratedField::FragmentTypeMask => {
15679 if fragment_type_mask__.is_some() {
15680 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
15681 }
15682 fragment_type_mask__ =
15683 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15684 ;
15685 }
15686 GeneratedField::DistributionType => {
15687 if distribution_type__.is_some() {
15688 return Err(serde::de::Error::duplicate_field("distributionType"));
15689 }
15690 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
15691 }
15692 GeneratedField::Actors => {
15693 if actors__.is_some() {
15694 return Err(serde::de::Error::duplicate_field("actors"));
15695 }
15696 actors__ = Some(map_.next_value()?);
15697 }
15698 GeneratedField::StateTableIds => {
15699 if state_table_ids__.is_some() {
15700 return Err(serde::de::Error::duplicate_field("stateTableIds"));
15701 }
15702 state_table_ids__ =
15703 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15704 .into_iter().map(|x| x.0).collect())
15705 ;
15706 }
15707 GeneratedField::UpstreamFragmentIds => {
15708 if upstream_fragment_ids__.is_some() {
15709 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
15710 }
15711 upstream_fragment_ids__ =
15712 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15713 .into_iter().map(|x| x.0).collect())
15714 ;
15715 }
15716 GeneratedField::MaybeVnodeCount => {
15717 if maybe_vnode_count__.is_some() {
15718 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
15719 }
15720 maybe_vnode_count__ =
15721 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15722 ;
15723 }
15724 GeneratedField::Nodes => {
15725 if nodes__.is_some() {
15726 return Err(serde::de::Error::duplicate_field("nodes"));
15727 }
15728 nodes__ = map_.next_value()?;
15729 }
15730 }
15731 }
15732 Ok(table_fragments::Fragment {
15733 fragment_id: fragment_id__.unwrap_or_default(),
15734 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
15735 distribution_type: distribution_type__.unwrap_or_default(),
15736 actors: actors__.unwrap_or_default(),
15737 state_table_ids: state_table_ids__.unwrap_or_default(),
15738 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
15739 maybe_vnode_count: maybe_vnode_count__,
15740 nodes: nodes__,
15741 })
15742 }
15743 }
15744 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
15745 }
15746}
15747impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
15748 #[allow(deprecated)]
15749 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15750 where
15751 S: serde::Serializer,
15752 {
15753 let variant = match self {
15754 Self::Unspecified => "UNSPECIFIED",
15755 Self::Single => "SINGLE",
15756 Self::Hash => "HASH",
15757 };
15758 serializer.serialize_str(variant)
15759 }
15760}
15761impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
15762 #[allow(deprecated)]
15763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15764 where
15765 D: serde::Deserializer<'de>,
15766 {
15767 const FIELDS: &[&str] = &[
15768 "UNSPECIFIED",
15769 "SINGLE",
15770 "HASH",
15771 ];
15772
15773 struct GeneratedVisitor;
15774
15775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15776 type Value = table_fragments::fragment::FragmentDistributionType;
15777
15778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15779 write!(formatter, "expected one of: {:?}", &FIELDS)
15780 }
15781
15782 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15783 where
15784 E: serde::de::Error,
15785 {
15786 i32::try_from(v)
15787 .ok()
15788 .and_then(|x| x.try_into().ok())
15789 .ok_or_else(|| {
15790 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15791 })
15792 }
15793
15794 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15795 where
15796 E: serde::de::Error,
15797 {
15798 i32::try_from(v)
15799 .ok()
15800 .and_then(|x| x.try_into().ok())
15801 .ok_or_else(|| {
15802 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15803 })
15804 }
15805
15806 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15807 where
15808 E: serde::de::Error,
15809 {
15810 match value {
15811 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
15812 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
15813 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
15814 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15815 }
15816 }
15817 }
15818 deserializer.deserialize_any(GeneratedVisitor)
15819 }
15820}
15821impl serde::Serialize for table_fragments::State {
15822 #[allow(deprecated)]
15823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15824 where
15825 S: serde::Serializer,
15826 {
15827 let variant = match self {
15828 Self::Unspecified => "UNSPECIFIED",
15829 Self::Initial => "INITIAL",
15830 Self::Creating => "CREATING",
15831 Self::Created => "CREATED",
15832 };
15833 serializer.serialize_str(variant)
15834 }
15835}
15836impl<'de> serde::Deserialize<'de> for table_fragments::State {
15837 #[allow(deprecated)]
15838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15839 where
15840 D: serde::Deserializer<'de>,
15841 {
15842 const FIELDS: &[&str] = &[
15843 "UNSPECIFIED",
15844 "INITIAL",
15845 "CREATING",
15846 "CREATED",
15847 ];
15848
15849 struct GeneratedVisitor;
15850
15851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15852 type Value = table_fragments::State;
15853
15854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15855 write!(formatter, "expected one of: {:?}", &FIELDS)
15856 }
15857
15858 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15859 where
15860 E: serde::de::Error,
15861 {
15862 i32::try_from(v)
15863 .ok()
15864 .and_then(|x| x.try_into().ok())
15865 .ok_or_else(|| {
15866 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15867 })
15868 }
15869
15870 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15871 where
15872 E: serde::de::Error,
15873 {
15874 i32::try_from(v)
15875 .ok()
15876 .and_then(|x| x.try_into().ok())
15877 .ok_or_else(|| {
15878 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15879 })
15880 }
15881
15882 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15883 where
15884 E: serde::de::Error,
15885 {
15886 match value {
15887 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
15888 "INITIAL" => Ok(table_fragments::State::Initial),
15889 "CREATING" => Ok(table_fragments::State::Creating),
15890 "CREATED" => Ok(table_fragments::State::Created),
15891 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15892 }
15893 }
15894 }
15895 deserializer.deserialize_any(GeneratedVisitor)
15896 }
15897}
15898impl serde::Serialize for TableParallelism {
15899 #[allow(deprecated)]
15900 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15901 where
15902 S: serde::Serializer,
15903 {
15904 use serde::ser::SerializeStruct;
15905 let mut len = 0;
15906 if self.parallelism.is_some() {
15907 len += 1;
15908 }
15909 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
15910 if let Some(v) = self.parallelism.as_ref() {
15911 match v {
15912 table_parallelism::Parallelism::Fixed(v) => {
15913 struct_ser.serialize_field("fixed", v)?;
15914 }
15915 table_parallelism::Parallelism::Auto(v) => {
15916 struct_ser.serialize_field("auto", v)?;
15917 }
15918 table_parallelism::Parallelism::Custom(v) => {
15919 struct_ser.serialize_field("custom", v)?;
15920 }
15921 table_parallelism::Parallelism::Adaptive(v) => {
15922 struct_ser.serialize_field("adaptive", v)?;
15923 }
15924 }
15925 }
15926 struct_ser.end()
15927 }
15928}
15929impl<'de> serde::Deserialize<'de> for TableParallelism {
15930 #[allow(deprecated)]
15931 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15932 where
15933 D: serde::Deserializer<'de>,
15934 {
15935 const FIELDS: &[&str] = &[
15936 "fixed",
15937 "auto",
15938 "custom",
15939 "adaptive",
15940 ];
15941
15942 #[allow(clippy::enum_variant_names)]
15943 enum GeneratedField {
15944 Fixed,
15945 Auto,
15946 Custom,
15947 Adaptive,
15948 }
15949 impl<'de> serde::Deserialize<'de> for GeneratedField {
15950 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15951 where
15952 D: serde::Deserializer<'de>,
15953 {
15954 struct GeneratedVisitor;
15955
15956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15957 type Value = GeneratedField;
15958
15959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15960 write!(formatter, "expected one of: {:?}", &FIELDS)
15961 }
15962
15963 #[allow(unused_variables)]
15964 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15965 where
15966 E: serde::de::Error,
15967 {
15968 match value {
15969 "fixed" => Ok(GeneratedField::Fixed),
15970 "auto" => Ok(GeneratedField::Auto),
15971 "custom" => Ok(GeneratedField::Custom),
15972 "adaptive" => Ok(GeneratedField::Adaptive),
15973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15974 }
15975 }
15976 }
15977 deserializer.deserialize_identifier(GeneratedVisitor)
15978 }
15979 }
15980 struct GeneratedVisitor;
15981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15982 type Value = TableParallelism;
15983
15984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15985 formatter.write_str("struct meta.TableParallelism")
15986 }
15987
15988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
15989 where
15990 V: serde::de::MapAccess<'de>,
15991 {
15992 let mut parallelism__ = None;
15993 while let Some(k) = map_.next_key()? {
15994 match k {
15995 GeneratedField::Fixed => {
15996 if parallelism__.is_some() {
15997 return Err(serde::de::Error::duplicate_field("fixed"));
15998 }
15999 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
16000;
16001 }
16002 GeneratedField::Auto => {
16003 if parallelism__.is_some() {
16004 return Err(serde::de::Error::duplicate_field("auto"));
16005 }
16006 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
16007;
16008 }
16009 GeneratedField::Custom => {
16010 if parallelism__.is_some() {
16011 return Err(serde::de::Error::duplicate_field("custom"));
16012 }
16013 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
16014;
16015 }
16016 GeneratedField::Adaptive => {
16017 if parallelism__.is_some() {
16018 return Err(serde::de::Error::duplicate_field("adaptive"));
16019 }
16020 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
16021;
16022 }
16023 }
16024 }
16025 Ok(TableParallelism {
16026 parallelism: parallelism__,
16027 })
16028 }
16029 }
16030 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
16031 }
16032}
16033impl serde::Serialize for table_parallelism::AdaptiveParallelism {
16034 #[allow(deprecated)]
16035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16036 where
16037 S: serde::Serializer,
16038 {
16039 use serde::ser::SerializeStruct;
16040 let len = 0;
16041 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
16042 struct_ser.end()
16043 }
16044}
16045impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
16046 #[allow(deprecated)]
16047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16048 where
16049 D: serde::Deserializer<'de>,
16050 {
16051 const FIELDS: &[&str] = &[
16052 ];
16053
16054 #[allow(clippy::enum_variant_names)]
16055 enum GeneratedField {
16056 }
16057 impl<'de> serde::Deserialize<'de> for GeneratedField {
16058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16059 where
16060 D: serde::Deserializer<'de>,
16061 {
16062 struct GeneratedVisitor;
16063
16064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16065 type Value = GeneratedField;
16066
16067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16068 write!(formatter, "expected one of: {:?}", &FIELDS)
16069 }
16070
16071 #[allow(unused_variables)]
16072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16073 where
16074 E: serde::de::Error,
16075 {
16076 Err(serde::de::Error::unknown_field(value, FIELDS))
16077 }
16078 }
16079 deserializer.deserialize_identifier(GeneratedVisitor)
16080 }
16081 }
16082 struct GeneratedVisitor;
16083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16084 type Value = table_parallelism::AdaptiveParallelism;
16085
16086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16087 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
16088 }
16089
16090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
16091 where
16092 V: serde::de::MapAccess<'de>,
16093 {
16094 while map_.next_key::<GeneratedField>()?.is_some() {
16095 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16096 }
16097 Ok(table_parallelism::AdaptiveParallelism {
16098 })
16099 }
16100 }
16101 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
16102 }
16103}
16104impl serde::Serialize for table_parallelism::AutoParallelism {
16105 #[allow(deprecated)]
16106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16107 where
16108 S: serde::Serializer,
16109 {
16110 use serde::ser::SerializeStruct;
16111 let len = 0;
16112 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
16113 struct_ser.end()
16114 }
16115}
16116impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
16117 #[allow(deprecated)]
16118 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16119 where
16120 D: serde::Deserializer<'de>,
16121 {
16122 const FIELDS: &[&str] = &[
16123 ];
16124
16125 #[allow(clippy::enum_variant_names)]
16126 enum GeneratedField {
16127 }
16128 impl<'de> serde::Deserialize<'de> for GeneratedField {
16129 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16130 where
16131 D: serde::Deserializer<'de>,
16132 {
16133 struct GeneratedVisitor;
16134
16135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16136 type Value = GeneratedField;
16137
16138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16139 write!(formatter, "expected one of: {:?}", &FIELDS)
16140 }
16141
16142 #[allow(unused_variables)]
16143 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16144 where
16145 E: serde::de::Error,
16146 {
16147 Err(serde::de::Error::unknown_field(value, FIELDS))
16148 }
16149 }
16150 deserializer.deserialize_identifier(GeneratedVisitor)
16151 }
16152 }
16153 struct GeneratedVisitor;
16154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16155 type Value = table_parallelism::AutoParallelism;
16156
16157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16158 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
16159 }
16160
16161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
16162 where
16163 V: serde::de::MapAccess<'de>,
16164 {
16165 while map_.next_key::<GeneratedField>()?.is_some() {
16166 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16167 }
16168 Ok(table_parallelism::AutoParallelism {
16169 })
16170 }
16171 }
16172 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
16173 }
16174}
16175impl serde::Serialize for table_parallelism::CustomParallelism {
16176 #[allow(deprecated)]
16177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16178 where
16179 S: serde::Serializer,
16180 {
16181 use serde::ser::SerializeStruct;
16182 let len = 0;
16183 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
16184 struct_ser.end()
16185 }
16186}
16187impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
16188 #[allow(deprecated)]
16189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16190 where
16191 D: serde::Deserializer<'de>,
16192 {
16193 const FIELDS: &[&str] = &[
16194 ];
16195
16196 #[allow(clippy::enum_variant_names)]
16197 enum GeneratedField {
16198 }
16199 impl<'de> serde::Deserialize<'de> for GeneratedField {
16200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16201 where
16202 D: serde::Deserializer<'de>,
16203 {
16204 struct GeneratedVisitor;
16205
16206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16207 type Value = GeneratedField;
16208
16209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16210 write!(formatter, "expected one of: {:?}", &FIELDS)
16211 }
16212
16213 #[allow(unused_variables)]
16214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16215 where
16216 E: serde::de::Error,
16217 {
16218 Err(serde::de::Error::unknown_field(value, FIELDS))
16219 }
16220 }
16221 deserializer.deserialize_identifier(GeneratedVisitor)
16222 }
16223 }
16224 struct GeneratedVisitor;
16225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16226 type Value = table_parallelism::CustomParallelism;
16227
16228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16229 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16230 }
16231
16232 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16233 where
16234 V: serde::de::MapAccess<'de>,
16235 {
16236 while map_.next_key::<GeneratedField>()?.is_some() {
16237 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16238 }
16239 Ok(table_parallelism::CustomParallelism {
16240 })
16241 }
16242 }
16243 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16244 }
16245}
16246impl serde::Serialize for table_parallelism::FixedParallelism {
16247 #[allow(deprecated)]
16248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16249 where
16250 S: serde::Serializer,
16251 {
16252 use serde::ser::SerializeStruct;
16253 let mut len = 0;
16254 if self.parallelism != 0 {
16255 len += 1;
16256 }
16257 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16258 if self.parallelism != 0 {
16259 struct_ser.serialize_field("parallelism", &self.parallelism)?;
16260 }
16261 struct_ser.end()
16262 }
16263}
16264impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16265 #[allow(deprecated)]
16266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16267 where
16268 D: serde::Deserializer<'de>,
16269 {
16270 const FIELDS: &[&str] = &[
16271 "parallelism",
16272 ];
16273
16274 #[allow(clippy::enum_variant_names)]
16275 enum GeneratedField {
16276 Parallelism,
16277 }
16278 impl<'de> serde::Deserialize<'de> for GeneratedField {
16279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16280 where
16281 D: serde::Deserializer<'de>,
16282 {
16283 struct GeneratedVisitor;
16284
16285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16286 type Value = GeneratedField;
16287
16288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16289 write!(formatter, "expected one of: {:?}", &FIELDS)
16290 }
16291
16292 #[allow(unused_variables)]
16293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16294 where
16295 E: serde::de::Error,
16296 {
16297 match value {
16298 "parallelism" => Ok(GeneratedField::Parallelism),
16299 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16300 }
16301 }
16302 }
16303 deserializer.deserialize_identifier(GeneratedVisitor)
16304 }
16305 }
16306 struct GeneratedVisitor;
16307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16308 type Value = table_parallelism::FixedParallelism;
16309
16310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16311 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16312 }
16313
16314 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16315 where
16316 V: serde::de::MapAccess<'de>,
16317 {
16318 let mut parallelism__ = None;
16319 while let Some(k) = map_.next_key()? {
16320 match k {
16321 GeneratedField::Parallelism => {
16322 if parallelism__.is_some() {
16323 return Err(serde::de::Error::duplicate_field("parallelism"));
16324 }
16325 parallelism__ =
16326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16327 ;
16328 }
16329 }
16330 }
16331 Ok(table_parallelism::FixedParallelism {
16332 parallelism: parallelism__.unwrap_or_default(),
16333 })
16334 }
16335 }
16336 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16337 }
16338}
16339impl serde::Serialize for TelemetryInfoResponse {
16340 #[allow(deprecated)]
16341 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16342 where
16343 S: serde::Serializer,
16344 {
16345 use serde::ser::SerializeStruct;
16346 let mut len = 0;
16347 if self.tracking_id.is_some() {
16348 len += 1;
16349 }
16350 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16351 if let Some(v) = self.tracking_id.as_ref() {
16352 struct_ser.serialize_field("trackingId", v)?;
16353 }
16354 struct_ser.end()
16355 }
16356}
16357impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16358 #[allow(deprecated)]
16359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16360 where
16361 D: serde::Deserializer<'de>,
16362 {
16363 const FIELDS: &[&str] = &[
16364 "tracking_id",
16365 "trackingId",
16366 ];
16367
16368 #[allow(clippy::enum_variant_names)]
16369 enum GeneratedField {
16370 TrackingId,
16371 }
16372 impl<'de> serde::Deserialize<'de> for GeneratedField {
16373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16374 where
16375 D: serde::Deserializer<'de>,
16376 {
16377 struct GeneratedVisitor;
16378
16379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16380 type Value = GeneratedField;
16381
16382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16383 write!(formatter, "expected one of: {:?}", &FIELDS)
16384 }
16385
16386 #[allow(unused_variables)]
16387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16388 where
16389 E: serde::de::Error,
16390 {
16391 match value {
16392 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16393 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16394 }
16395 }
16396 }
16397 deserializer.deserialize_identifier(GeneratedVisitor)
16398 }
16399 }
16400 struct GeneratedVisitor;
16401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16402 type Value = TelemetryInfoResponse;
16403
16404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16405 formatter.write_str("struct meta.TelemetryInfoResponse")
16406 }
16407
16408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16409 where
16410 V: serde::de::MapAccess<'de>,
16411 {
16412 let mut tracking_id__ = None;
16413 while let Some(k) = map_.next_key()? {
16414 match k {
16415 GeneratedField::TrackingId => {
16416 if tracking_id__.is_some() {
16417 return Err(serde::de::Error::duplicate_field("trackingId"));
16418 }
16419 tracking_id__ = map_.next_value()?;
16420 }
16421 }
16422 }
16423 Ok(TelemetryInfoResponse {
16424 tracking_id: tracking_id__,
16425 })
16426 }
16427 }
16428 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16429 }
16430}
16431impl serde::Serialize for ThrottleTarget {
16432 #[allow(deprecated)]
16433 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16434 where
16435 S: serde::Serializer,
16436 {
16437 let variant = match self {
16438 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16439 Self::Source => "SOURCE",
16440 Self::Mv => "MV",
16441 Self::TableWithSource => "TABLE_WITH_SOURCE",
16442 Self::CdcTable => "CDC_TABLE",
16443 Self::TableDml => "TABLE_DML",
16444 Self::Sink => "SINK",
16445 Self::Fragment => "FRAGMENT",
16446 };
16447 serializer.serialize_str(variant)
16448 }
16449}
16450impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16451 #[allow(deprecated)]
16452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16453 where
16454 D: serde::Deserializer<'de>,
16455 {
16456 const FIELDS: &[&str] = &[
16457 "THROTTLE_TARGET_UNSPECIFIED",
16458 "SOURCE",
16459 "MV",
16460 "TABLE_WITH_SOURCE",
16461 "CDC_TABLE",
16462 "TABLE_DML",
16463 "SINK",
16464 "FRAGMENT",
16465 ];
16466
16467 struct GeneratedVisitor;
16468
16469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16470 type Value = ThrottleTarget;
16471
16472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16473 write!(formatter, "expected one of: {:?}", &FIELDS)
16474 }
16475
16476 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16477 where
16478 E: serde::de::Error,
16479 {
16480 i32::try_from(v)
16481 .ok()
16482 .and_then(|x| x.try_into().ok())
16483 .ok_or_else(|| {
16484 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16485 })
16486 }
16487
16488 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16489 where
16490 E: serde::de::Error,
16491 {
16492 i32::try_from(v)
16493 .ok()
16494 .and_then(|x| x.try_into().ok())
16495 .ok_or_else(|| {
16496 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16497 })
16498 }
16499
16500 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16501 where
16502 E: serde::de::Error,
16503 {
16504 match value {
16505 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16506 "SOURCE" => Ok(ThrottleTarget::Source),
16507 "MV" => Ok(ThrottleTarget::Mv),
16508 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16509 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16510 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16511 "SINK" => Ok(ThrottleTarget::Sink),
16512 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16513 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16514 }
16515 }
16516 }
16517 deserializer.deserialize_any(GeneratedVisitor)
16518 }
16519}
16520impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16521 #[allow(deprecated)]
16522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16523 where
16524 S: serde::Serializer,
16525 {
16526 use serde::ser::SerializeStruct;
16527 let mut len = 0;
16528 if self.id != 0 {
16529 len += 1;
16530 }
16531 if !self.node_label.is_empty() {
16532 len += 1;
16533 }
16534 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16535 if self.id != 0 {
16536 struct_ser.serialize_field("id", &self.id)?;
16537 }
16538 if !self.node_label.is_empty() {
16539 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16540 }
16541 struct_ser.end()
16542 }
16543}
16544impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16545 #[allow(deprecated)]
16546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16547 where
16548 D: serde::Deserializer<'de>,
16549 {
16550 const FIELDS: &[&str] = &[
16551 "id",
16552 "node_label",
16553 "nodeLabel",
16554 ];
16555
16556 #[allow(clippy::enum_variant_names)]
16557 enum GeneratedField {
16558 Id,
16559 NodeLabel,
16560 }
16561 impl<'de> serde::Deserialize<'de> for GeneratedField {
16562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16563 where
16564 D: serde::Deserializer<'de>,
16565 {
16566 struct GeneratedVisitor;
16567
16568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16569 type Value = GeneratedField;
16570
16571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16572 write!(formatter, "expected one of: {:?}", &FIELDS)
16573 }
16574
16575 #[allow(unused_variables)]
16576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16577 where
16578 E: serde::de::Error,
16579 {
16580 match value {
16581 "id" => Ok(GeneratedField::Id),
16582 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16583 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16584 }
16585 }
16586 }
16587 deserializer.deserialize_identifier(GeneratedVisitor)
16588 }
16589 }
16590 struct GeneratedVisitor;
16591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16592 type Value = UpdateStreamingJobNodeLabelsRequest;
16593
16594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16595 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
16596 }
16597
16598 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
16599 where
16600 V: serde::de::MapAccess<'de>,
16601 {
16602 let mut id__ = None;
16603 let mut node_label__ = None;
16604 while let Some(k) = map_.next_key()? {
16605 match k {
16606 GeneratedField::Id => {
16607 if id__.is_some() {
16608 return Err(serde::de::Error::duplicate_field("id"));
16609 }
16610 id__ =
16611 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16612 ;
16613 }
16614 GeneratedField::NodeLabel => {
16615 if node_label__.is_some() {
16616 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16617 }
16618 node_label__ = Some(map_.next_value()?);
16619 }
16620 }
16621 }
16622 Ok(UpdateStreamingJobNodeLabelsRequest {
16623 id: id__.unwrap_or_default(),
16624 node_label: node_label__.unwrap_or_default(),
16625 })
16626 }
16627 }
16628 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
16629 }
16630}
16631impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
16632 #[allow(deprecated)]
16633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16634 where
16635 S: serde::Serializer,
16636 {
16637 use serde::ser::SerializeStruct;
16638 let len = 0;
16639 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
16640 struct_ser.end()
16641 }
16642}
16643impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
16644 #[allow(deprecated)]
16645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16646 where
16647 D: serde::Deserializer<'de>,
16648 {
16649 const FIELDS: &[&str] = &[
16650 ];
16651
16652 #[allow(clippy::enum_variant_names)]
16653 enum GeneratedField {
16654 }
16655 impl<'de> serde::Deserialize<'de> for GeneratedField {
16656 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16657 where
16658 D: serde::Deserializer<'de>,
16659 {
16660 struct GeneratedVisitor;
16661
16662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16663 type Value = GeneratedField;
16664
16665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16666 write!(formatter, "expected one of: {:?}", &FIELDS)
16667 }
16668
16669 #[allow(unused_variables)]
16670 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16671 where
16672 E: serde::de::Error,
16673 {
16674 Err(serde::de::Error::unknown_field(value, FIELDS))
16675 }
16676 }
16677 deserializer.deserialize_identifier(GeneratedVisitor)
16678 }
16679 }
16680 struct GeneratedVisitor;
16681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16682 type Value = UpdateStreamingJobNodeLabelsResponse;
16683
16684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16685 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
16686 }
16687
16688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
16689 where
16690 V: serde::de::MapAccess<'de>,
16691 {
16692 while map_.next_key::<GeneratedField>()?.is_some() {
16693 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16694 }
16695 Ok(UpdateStreamingJobNodeLabelsResponse {
16696 })
16697 }
16698 }
16699 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
16700 }
16701}
16702impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
16703 #[allow(deprecated)]
16704 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16705 where
16706 S: serde::Serializer,
16707 {
16708 use serde::ser::SerializeStruct;
16709 let mut len = 0;
16710 if !self.worker_ids.is_empty() {
16711 len += 1;
16712 }
16713 if self.schedulability != 0 {
16714 len += 1;
16715 }
16716 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
16717 if !self.worker_ids.is_empty() {
16718 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
16719 }
16720 if self.schedulability != 0 {
16721 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
16722 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
16723 struct_ser.serialize_field("schedulability", &v)?;
16724 }
16725 struct_ser.end()
16726 }
16727}
16728impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
16729 #[allow(deprecated)]
16730 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16731 where
16732 D: serde::Deserializer<'de>,
16733 {
16734 const FIELDS: &[&str] = &[
16735 "worker_ids",
16736 "workerIds",
16737 "schedulability",
16738 ];
16739
16740 #[allow(clippy::enum_variant_names)]
16741 enum GeneratedField {
16742 WorkerIds,
16743 Schedulability,
16744 }
16745 impl<'de> serde::Deserialize<'de> for GeneratedField {
16746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16747 where
16748 D: serde::Deserializer<'de>,
16749 {
16750 struct GeneratedVisitor;
16751
16752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16753 type Value = GeneratedField;
16754
16755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16756 write!(formatter, "expected one of: {:?}", &FIELDS)
16757 }
16758
16759 #[allow(unused_variables)]
16760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16761 where
16762 E: serde::de::Error,
16763 {
16764 match value {
16765 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
16766 "schedulability" => Ok(GeneratedField::Schedulability),
16767 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16768 }
16769 }
16770 }
16771 deserializer.deserialize_identifier(GeneratedVisitor)
16772 }
16773 }
16774 struct GeneratedVisitor;
16775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16776 type Value = UpdateWorkerNodeSchedulabilityRequest;
16777
16778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16779 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
16780 }
16781
16782 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
16783 where
16784 V: serde::de::MapAccess<'de>,
16785 {
16786 let mut worker_ids__ = None;
16787 let mut schedulability__ = None;
16788 while let Some(k) = map_.next_key()? {
16789 match k {
16790 GeneratedField::WorkerIds => {
16791 if worker_ids__.is_some() {
16792 return Err(serde::de::Error::duplicate_field("workerIds"));
16793 }
16794 worker_ids__ =
16795 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16796 .into_iter().map(|x| x.0).collect())
16797 ;
16798 }
16799 GeneratedField::Schedulability => {
16800 if schedulability__.is_some() {
16801 return Err(serde::de::Error::duplicate_field("schedulability"));
16802 }
16803 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
16804 }
16805 }
16806 }
16807 Ok(UpdateWorkerNodeSchedulabilityRequest {
16808 worker_ids: worker_ids__.unwrap_or_default(),
16809 schedulability: schedulability__.unwrap_or_default(),
16810 })
16811 }
16812 }
16813 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
16814 }
16815}
16816impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
16817 #[allow(deprecated)]
16818 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16819 where
16820 S: serde::Serializer,
16821 {
16822 let variant = match self {
16823 Self::Unspecified => "UNSPECIFIED",
16824 Self::Schedulable => "SCHEDULABLE",
16825 Self::Unschedulable => "UNSCHEDULABLE",
16826 };
16827 serializer.serialize_str(variant)
16828 }
16829}
16830impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
16831 #[allow(deprecated)]
16832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16833 where
16834 D: serde::Deserializer<'de>,
16835 {
16836 const FIELDS: &[&str] = &[
16837 "UNSPECIFIED",
16838 "SCHEDULABLE",
16839 "UNSCHEDULABLE",
16840 ];
16841
16842 struct GeneratedVisitor;
16843
16844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16845 type Value = update_worker_node_schedulability_request::Schedulability;
16846
16847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16848 write!(formatter, "expected one of: {:?}", &FIELDS)
16849 }
16850
16851 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16852 where
16853 E: serde::de::Error,
16854 {
16855 i32::try_from(v)
16856 .ok()
16857 .and_then(|x| x.try_into().ok())
16858 .ok_or_else(|| {
16859 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16860 })
16861 }
16862
16863 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16864 where
16865 E: serde::de::Error,
16866 {
16867 i32::try_from(v)
16868 .ok()
16869 .and_then(|x| x.try_into().ok())
16870 .ok_or_else(|| {
16871 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16872 })
16873 }
16874
16875 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16876 where
16877 E: serde::de::Error,
16878 {
16879 match value {
16880 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
16881 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
16882 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
16883 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16884 }
16885 }
16886 }
16887 deserializer.deserialize_any(GeneratedVisitor)
16888 }
16889}
16890impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
16891 #[allow(deprecated)]
16892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16893 where
16894 S: serde::Serializer,
16895 {
16896 use serde::ser::SerializeStruct;
16897 let mut len = 0;
16898 if self.status.is_some() {
16899 len += 1;
16900 }
16901 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
16902 if let Some(v) = self.status.as_ref() {
16903 struct_ser.serialize_field("status", v)?;
16904 }
16905 struct_ser.end()
16906 }
16907}
16908impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
16909 #[allow(deprecated)]
16910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16911 where
16912 D: serde::Deserializer<'de>,
16913 {
16914 const FIELDS: &[&str] = &[
16915 "status",
16916 ];
16917
16918 #[allow(clippy::enum_variant_names)]
16919 enum GeneratedField {
16920 Status,
16921 }
16922 impl<'de> serde::Deserialize<'de> for GeneratedField {
16923 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16924 where
16925 D: serde::Deserializer<'de>,
16926 {
16927 struct GeneratedVisitor;
16928
16929 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16930 type Value = GeneratedField;
16931
16932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16933 write!(formatter, "expected one of: {:?}", &FIELDS)
16934 }
16935
16936 #[allow(unused_variables)]
16937 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16938 where
16939 E: serde::de::Error,
16940 {
16941 match value {
16942 "status" => Ok(GeneratedField::Status),
16943 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16944 }
16945 }
16946 }
16947 deserializer.deserialize_identifier(GeneratedVisitor)
16948 }
16949 }
16950 struct GeneratedVisitor;
16951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16952 type Value = UpdateWorkerNodeSchedulabilityResponse;
16953
16954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16955 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
16956 }
16957
16958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
16959 where
16960 V: serde::de::MapAccess<'de>,
16961 {
16962 let mut status__ = None;
16963 while let Some(k) = map_.next_key()? {
16964 match k {
16965 GeneratedField::Status => {
16966 if status__.is_some() {
16967 return Err(serde::de::Error::duplicate_field("status"));
16968 }
16969 status__ = map_.next_value()?;
16970 }
16971 }
16972 }
16973 Ok(UpdateWorkerNodeSchedulabilityResponse {
16974 status: status__,
16975 })
16976 }
16977 }
16978 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
16979 }
16980}
16981impl serde::Serialize for WorkerReschedule {
16982 #[allow(deprecated)]
16983 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16984 where
16985 S: serde::Serializer,
16986 {
16987 use serde::ser::SerializeStruct;
16988 let mut len = 0;
16989 if !self.worker_actor_diff.is_empty() {
16990 len += 1;
16991 }
16992 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
16993 if !self.worker_actor_diff.is_empty() {
16994 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
16995 }
16996 struct_ser.end()
16997 }
16998}
16999impl<'de> serde::Deserialize<'de> for WorkerReschedule {
17000 #[allow(deprecated)]
17001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17002 where
17003 D: serde::Deserializer<'de>,
17004 {
17005 const FIELDS: &[&str] = &[
17006 "worker_actor_diff",
17007 "workerActorDiff",
17008 ];
17009
17010 #[allow(clippy::enum_variant_names)]
17011 enum GeneratedField {
17012 WorkerActorDiff,
17013 }
17014 impl<'de> serde::Deserialize<'de> for GeneratedField {
17015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17016 where
17017 D: serde::Deserializer<'de>,
17018 {
17019 struct GeneratedVisitor;
17020
17021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17022 type Value = GeneratedField;
17023
17024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17025 write!(formatter, "expected one of: {:?}", &FIELDS)
17026 }
17027
17028 #[allow(unused_variables)]
17029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17030 where
17031 E: serde::de::Error,
17032 {
17033 match value {
17034 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
17035 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17036 }
17037 }
17038 }
17039 deserializer.deserialize_identifier(GeneratedVisitor)
17040 }
17041 }
17042 struct GeneratedVisitor;
17043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17044 type Value = WorkerReschedule;
17045
17046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17047 formatter.write_str("struct meta.WorkerReschedule")
17048 }
17049
17050 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
17051 where
17052 V: serde::de::MapAccess<'de>,
17053 {
17054 let mut worker_actor_diff__ = None;
17055 while let Some(k) = map_.next_key()? {
17056 match k {
17057 GeneratedField::WorkerActorDiff => {
17058 if worker_actor_diff__.is_some() {
17059 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
17060 }
17061 worker_actor_diff__ = Some(
17062 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
17063 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17064 );
17065 }
17066 }
17067 }
17068 Ok(WorkerReschedule {
17069 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
17070 })
17071 }
17072 }
17073 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
17074 }
17075}