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 add_event_log_request::Event::AutoSchemaChangeFail(v) => {
683 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
684 }
685 }
686 }
687 struct_ser.end()
688 }
689}
690impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
691 #[allow(deprecated)]
692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
693 where
694 D: serde::Deserializer<'de>,
695 {
696 const FIELDS: &[&str] = &[
697 "worker_node_panic",
698 "workerNodePanic",
699 "sink_fail",
700 "sinkFail",
701 "auto_schema_change_fail",
702 "autoSchemaChangeFail",
703 ];
704
705 #[allow(clippy::enum_variant_names)]
706 enum GeneratedField {
707 WorkerNodePanic,
708 SinkFail,
709 AutoSchemaChangeFail,
710 }
711 impl<'de> serde::Deserialize<'de> for GeneratedField {
712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
713 where
714 D: serde::Deserializer<'de>,
715 {
716 struct GeneratedVisitor;
717
718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
719 type Value = GeneratedField;
720
721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
722 write!(formatter, "expected one of: {:?}", &FIELDS)
723 }
724
725 #[allow(unused_variables)]
726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
727 where
728 E: serde::de::Error,
729 {
730 match value {
731 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
732 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
733 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
734 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
735 }
736 }
737 }
738 deserializer.deserialize_identifier(GeneratedVisitor)
739 }
740 }
741 struct GeneratedVisitor;
742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
743 type Value = AddEventLogRequest;
744
745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
746 formatter.write_str("struct meta.AddEventLogRequest")
747 }
748
749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
750 where
751 V: serde::de::MapAccess<'de>,
752 {
753 let mut event__ = None;
754 while let Some(k) = map_.next_key()? {
755 match k {
756 GeneratedField::WorkerNodePanic => {
757 if event__.is_some() {
758 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
759 }
760 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
761;
762 }
763 GeneratedField::SinkFail => {
764 if event__.is_some() {
765 return Err(serde::de::Error::duplicate_field("sinkFail"));
766 }
767 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
768;
769 }
770 GeneratedField::AutoSchemaChangeFail => {
771 if event__.is_some() {
772 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
773 }
774 event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::AutoSchemaChangeFail)
775;
776 }
777 }
778 }
779 Ok(AddEventLogRequest {
780 event: event__,
781 })
782 }
783 }
784 deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
785 }
786}
787impl serde::Serialize for AddEventLogResponse {
788 #[allow(deprecated)]
789 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
790 where
791 S: serde::Serializer,
792 {
793 use serde::ser::SerializeStruct;
794 let len = 0;
795 let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
796 struct_ser.end()
797 }
798}
799impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
800 #[allow(deprecated)]
801 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
802 where
803 D: serde::Deserializer<'de>,
804 {
805 const FIELDS: &[&str] = &[
806 ];
807
808 #[allow(clippy::enum_variant_names)]
809 enum GeneratedField {
810 }
811 impl<'de> serde::Deserialize<'de> for GeneratedField {
812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
813 where
814 D: serde::Deserializer<'de>,
815 {
816 struct GeneratedVisitor;
817
818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
819 type Value = GeneratedField;
820
821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
822 write!(formatter, "expected one of: {:?}", &FIELDS)
823 }
824
825 #[allow(unused_variables)]
826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
827 where
828 E: serde::de::Error,
829 {
830 Err(serde::de::Error::unknown_field(value, FIELDS))
831 }
832 }
833 deserializer.deserialize_identifier(GeneratedVisitor)
834 }
835 }
836 struct GeneratedVisitor;
837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
838 type Value = AddEventLogResponse;
839
840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
841 formatter.write_str("struct meta.AddEventLogResponse")
842 }
843
844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
845 where
846 V: serde::de::MapAccess<'de>,
847 {
848 while map_.next_key::<GeneratedField>()?.is_some() {
849 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
850 }
851 Ok(AddEventLogResponse {
852 })
853 }
854 }
855 deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
856 }
857}
858impl serde::Serialize for AddWorkerNodeRequest {
859 #[allow(deprecated)]
860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
861 where
862 S: serde::Serializer,
863 {
864 use serde::ser::SerializeStruct;
865 let mut len = 0;
866 if self.worker_type != 0 {
867 len += 1;
868 }
869 if self.host.is_some() {
870 len += 1;
871 }
872 if self.resource.is_some() {
873 len += 1;
874 }
875 if self.property.is_some() {
876 len += 1;
877 }
878 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
879 if self.worker_type != 0 {
880 let v = super::common::WorkerType::try_from(self.worker_type)
881 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
882 struct_ser.serialize_field("workerType", &v)?;
883 }
884 if let Some(v) = self.host.as_ref() {
885 struct_ser.serialize_field("host", v)?;
886 }
887 if let Some(v) = self.resource.as_ref() {
888 struct_ser.serialize_field("resource", v)?;
889 }
890 if let Some(v) = self.property.as_ref() {
891 struct_ser.serialize_field("property", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "worker_type",
904 "workerType",
905 "host",
906 "resource",
907 "property",
908 ];
909
910 #[allow(clippy::enum_variant_names)]
911 enum GeneratedField {
912 WorkerType,
913 Host,
914 Resource,
915 Property,
916 }
917 impl<'de> serde::Deserialize<'de> for GeneratedField {
918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
919 where
920 D: serde::Deserializer<'de>,
921 {
922 struct GeneratedVisitor;
923
924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
925 type Value = GeneratedField;
926
927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
928 write!(formatter, "expected one of: {:?}", &FIELDS)
929 }
930
931 #[allow(unused_variables)]
932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
933 where
934 E: serde::de::Error,
935 {
936 match value {
937 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
938 "host" => Ok(GeneratedField::Host),
939 "resource" => Ok(GeneratedField::Resource),
940 "property" => Ok(GeneratedField::Property),
941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
942 }
943 }
944 }
945 deserializer.deserialize_identifier(GeneratedVisitor)
946 }
947 }
948 struct GeneratedVisitor;
949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
950 type Value = AddWorkerNodeRequest;
951
952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
953 formatter.write_str("struct meta.AddWorkerNodeRequest")
954 }
955
956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
957 where
958 V: serde::de::MapAccess<'de>,
959 {
960 let mut worker_type__ = None;
961 let mut host__ = None;
962 let mut resource__ = None;
963 let mut property__ = None;
964 while let Some(k) = map_.next_key()? {
965 match k {
966 GeneratedField::WorkerType => {
967 if worker_type__.is_some() {
968 return Err(serde::de::Error::duplicate_field("workerType"));
969 }
970 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
971 }
972 GeneratedField::Host => {
973 if host__.is_some() {
974 return Err(serde::de::Error::duplicate_field("host"));
975 }
976 host__ = map_.next_value()?;
977 }
978 GeneratedField::Resource => {
979 if resource__.is_some() {
980 return Err(serde::de::Error::duplicate_field("resource"));
981 }
982 resource__ = map_.next_value()?;
983 }
984 GeneratedField::Property => {
985 if property__.is_some() {
986 return Err(serde::de::Error::duplicate_field("property"));
987 }
988 property__ = map_.next_value()?;
989 }
990 }
991 }
992 Ok(AddWorkerNodeRequest {
993 worker_type: worker_type__.unwrap_or_default(),
994 host: host__,
995 resource: resource__,
996 property: property__,
997 })
998 }
999 }
1000 deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
1001 }
1002}
1003impl serde::Serialize for AddWorkerNodeResponse {
1004 #[allow(deprecated)]
1005 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1006 where
1007 S: serde::Serializer,
1008 {
1009 use serde::ser::SerializeStruct;
1010 let mut len = 0;
1011 if self.node_id.is_some() {
1012 len += 1;
1013 }
1014 if !self.cluster_id.is_empty() {
1015 len += 1;
1016 }
1017 let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1018 if let Some(v) = self.node_id.as_ref() {
1019 struct_ser.serialize_field("nodeId", v)?;
1020 }
1021 if !self.cluster_id.is_empty() {
1022 struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1023 }
1024 struct_ser.end()
1025 }
1026}
1027impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1028 #[allow(deprecated)]
1029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1030 where
1031 D: serde::Deserializer<'de>,
1032 {
1033 const FIELDS: &[&str] = &[
1034 "node_id",
1035 "nodeId",
1036 "cluster_id",
1037 "clusterId",
1038 ];
1039
1040 #[allow(clippy::enum_variant_names)]
1041 enum GeneratedField {
1042 NodeId,
1043 ClusterId,
1044 }
1045 impl<'de> serde::Deserialize<'de> for GeneratedField {
1046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1047 where
1048 D: serde::Deserializer<'de>,
1049 {
1050 struct GeneratedVisitor;
1051
1052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1053 type Value = GeneratedField;
1054
1055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1056 write!(formatter, "expected one of: {:?}", &FIELDS)
1057 }
1058
1059 #[allow(unused_variables)]
1060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1061 where
1062 E: serde::de::Error,
1063 {
1064 match value {
1065 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1066 "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1067 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1068 }
1069 }
1070 }
1071 deserializer.deserialize_identifier(GeneratedVisitor)
1072 }
1073 }
1074 struct GeneratedVisitor;
1075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1076 type Value = AddWorkerNodeResponse;
1077
1078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1079 formatter.write_str("struct meta.AddWorkerNodeResponse")
1080 }
1081
1082 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1083 where
1084 V: serde::de::MapAccess<'de>,
1085 {
1086 let mut node_id__ = None;
1087 let mut cluster_id__ = None;
1088 while let Some(k) = map_.next_key()? {
1089 match k {
1090 GeneratedField::NodeId => {
1091 if node_id__.is_some() {
1092 return Err(serde::de::Error::duplicate_field("nodeId"));
1093 }
1094 node_id__ =
1095 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1096 ;
1097 }
1098 GeneratedField::ClusterId => {
1099 if cluster_id__.is_some() {
1100 return Err(serde::de::Error::duplicate_field("clusterId"));
1101 }
1102 cluster_id__ = Some(map_.next_value()?);
1103 }
1104 }
1105 }
1106 Ok(AddWorkerNodeResponse {
1107 node_id: node_id__,
1108 cluster_id: cluster_id__.unwrap_or_default(),
1109 })
1110 }
1111 }
1112 deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1113 }
1114}
1115impl serde::Serialize for AlterConnectorPropsRequest {
1116 #[allow(deprecated)]
1117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1118 where
1119 S: serde::Serializer,
1120 {
1121 use serde::ser::SerializeStruct;
1122 let mut len = 0;
1123 if self.object_id != 0 {
1124 len += 1;
1125 }
1126 if !self.changed_props.is_empty() {
1127 len += 1;
1128 }
1129 if !self.changed_secret_refs.is_empty() {
1130 len += 1;
1131 }
1132 if self.connector_conn_ref.is_some() {
1133 len += 1;
1134 }
1135 if self.object_type != 0 {
1136 len += 1;
1137 }
1138 if self.extra_options.is_some() {
1139 len += 1;
1140 }
1141 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1142 if self.object_id != 0 {
1143 struct_ser.serialize_field("objectId", &self.object_id)?;
1144 }
1145 if !self.changed_props.is_empty() {
1146 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1147 }
1148 if !self.changed_secret_refs.is_empty() {
1149 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1150 }
1151 if let Some(v) = self.connector_conn_ref.as_ref() {
1152 struct_ser.serialize_field("connectorConnRef", v)?;
1153 }
1154 if self.object_type != 0 {
1155 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1156 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1157 struct_ser.serialize_field("objectType", &v)?;
1158 }
1159 if let Some(v) = self.extra_options.as_ref() {
1160 match v {
1161 alter_connector_props_request::ExtraOptions::AlterIcebergTableIds(v) => {
1162 struct_ser.serialize_field("alterIcebergTableIds", v)?;
1163 }
1164 }
1165 }
1166 struct_ser.end()
1167 }
1168}
1169impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1170 #[allow(deprecated)]
1171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1172 where
1173 D: serde::Deserializer<'de>,
1174 {
1175 const FIELDS: &[&str] = &[
1176 "object_id",
1177 "objectId",
1178 "changed_props",
1179 "changedProps",
1180 "changed_secret_refs",
1181 "changedSecretRefs",
1182 "connector_conn_ref",
1183 "connectorConnRef",
1184 "object_type",
1185 "objectType",
1186 "alter_iceberg_table_ids",
1187 "alterIcebergTableIds",
1188 ];
1189
1190 #[allow(clippy::enum_variant_names)]
1191 enum GeneratedField {
1192 ObjectId,
1193 ChangedProps,
1194 ChangedSecretRefs,
1195 ConnectorConnRef,
1196 ObjectType,
1197 AlterIcebergTableIds,
1198 }
1199 impl<'de> serde::Deserialize<'de> for GeneratedField {
1200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1201 where
1202 D: serde::Deserializer<'de>,
1203 {
1204 struct GeneratedVisitor;
1205
1206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1207 type Value = GeneratedField;
1208
1209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1210 write!(formatter, "expected one of: {:?}", &FIELDS)
1211 }
1212
1213 #[allow(unused_variables)]
1214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1215 where
1216 E: serde::de::Error,
1217 {
1218 match value {
1219 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1220 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1221 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1222 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1223 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1224 "alterIcebergTableIds" | "alter_iceberg_table_ids" => Ok(GeneratedField::AlterIcebergTableIds),
1225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1226 }
1227 }
1228 }
1229 deserializer.deserialize_identifier(GeneratedVisitor)
1230 }
1231 }
1232 struct GeneratedVisitor;
1233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1234 type Value = AlterConnectorPropsRequest;
1235
1236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1237 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1238 }
1239
1240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1241 where
1242 V: serde::de::MapAccess<'de>,
1243 {
1244 let mut object_id__ = None;
1245 let mut changed_props__ = None;
1246 let mut changed_secret_refs__ = None;
1247 let mut connector_conn_ref__ = None;
1248 let mut object_type__ = None;
1249 let mut extra_options__ = None;
1250 while let Some(k) = map_.next_key()? {
1251 match k {
1252 GeneratedField::ObjectId => {
1253 if object_id__.is_some() {
1254 return Err(serde::de::Error::duplicate_field("objectId"));
1255 }
1256 object_id__ =
1257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1258 ;
1259 }
1260 GeneratedField::ChangedProps => {
1261 if changed_props__.is_some() {
1262 return Err(serde::de::Error::duplicate_field("changedProps"));
1263 }
1264 changed_props__ = Some(
1265 map_.next_value::<std::collections::HashMap<_, _>>()?
1266 );
1267 }
1268 GeneratedField::ChangedSecretRefs => {
1269 if changed_secret_refs__.is_some() {
1270 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1271 }
1272 changed_secret_refs__ = Some(
1273 map_.next_value::<std::collections::HashMap<_, _>>()?
1274 );
1275 }
1276 GeneratedField::ConnectorConnRef => {
1277 if connector_conn_ref__.is_some() {
1278 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1279 }
1280 connector_conn_ref__ =
1281 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1282 ;
1283 }
1284 GeneratedField::ObjectType => {
1285 if object_type__.is_some() {
1286 return Err(serde::de::Error::duplicate_field("objectType"));
1287 }
1288 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1289 }
1290 GeneratedField::AlterIcebergTableIds => {
1291 if extra_options__.is_some() {
1292 return Err(serde::de::Error::duplicate_field("alterIcebergTableIds"));
1293 }
1294 extra_options__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_connector_props_request::ExtraOptions::AlterIcebergTableIds)
1295;
1296 }
1297 }
1298 }
1299 Ok(AlterConnectorPropsRequest {
1300 object_id: object_id__.unwrap_or_default(),
1301 changed_props: changed_props__.unwrap_or_default(),
1302 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1303 connector_conn_ref: connector_conn_ref__,
1304 object_type: object_type__.unwrap_or_default(),
1305 extra_options: extra_options__,
1306 })
1307 }
1308 }
1309 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1310 }
1311}
1312impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1313 #[allow(deprecated)]
1314 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1315 where
1316 S: serde::Serializer,
1317 {
1318 let variant = match self {
1319 Self::Unspecified => "UNSPECIFIED",
1320 Self::Source => "SOURCE",
1321 Self::Sink => "SINK",
1322 Self::Connection => "CONNECTION",
1323 Self::IcebergTable => "ICEBERG_TABLE",
1324 };
1325 serializer.serialize_str(variant)
1326 }
1327}
1328impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1329 #[allow(deprecated)]
1330 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1331 where
1332 D: serde::Deserializer<'de>,
1333 {
1334 const FIELDS: &[&str] = &[
1335 "UNSPECIFIED",
1336 "SOURCE",
1337 "SINK",
1338 "CONNECTION",
1339 "ICEBERG_TABLE",
1340 ];
1341
1342 struct GeneratedVisitor;
1343
1344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1345 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1346
1347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1348 write!(formatter, "expected one of: {:?}", &FIELDS)
1349 }
1350
1351 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1352 where
1353 E: serde::de::Error,
1354 {
1355 i32::try_from(v)
1356 .ok()
1357 .and_then(|x| x.try_into().ok())
1358 .ok_or_else(|| {
1359 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1360 })
1361 }
1362
1363 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1364 where
1365 E: serde::de::Error,
1366 {
1367 i32::try_from(v)
1368 .ok()
1369 .and_then(|x| x.try_into().ok())
1370 .ok_or_else(|| {
1371 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1372 })
1373 }
1374
1375 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1376 where
1377 E: serde::de::Error,
1378 {
1379 match value {
1380 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1381 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1382 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1383 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1384 "ICEBERG_TABLE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::IcebergTable),
1385 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1386 }
1387 }
1388 }
1389 deserializer.deserialize_any(GeneratedVisitor)
1390 }
1391}
1392impl serde::Serialize for alter_connector_props_request::AlterIcebergTableIds {
1393 #[allow(deprecated)]
1394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1395 where
1396 S: serde::Serializer,
1397 {
1398 use serde::ser::SerializeStruct;
1399 let mut len = 0;
1400 if self.source_id != 0 {
1401 len += 1;
1402 }
1403 if self.sink_id != 0 {
1404 len += 1;
1405 }
1406 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", len)?;
1407 if self.source_id != 0 {
1408 struct_ser.serialize_field("sourceId", &self.source_id)?;
1409 }
1410 if self.sink_id != 0 {
1411 struct_ser.serialize_field("sinkId", &self.sink_id)?;
1412 }
1413 struct_ser.end()
1414 }
1415}
1416impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterIcebergTableIds {
1417 #[allow(deprecated)]
1418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1419 where
1420 D: serde::Deserializer<'de>,
1421 {
1422 const FIELDS: &[&str] = &[
1423 "source_id",
1424 "sourceId",
1425 "sink_id",
1426 "sinkId",
1427 ];
1428
1429 #[allow(clippy::enum_variant_names)]
1430 enum GeneratedField {
1431 SourceId,
1432 SinkId,
1433 }
1434 impl<'de> serde::Deserialize<'de> for GeneratedField {
1435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1436 where
1437 D: serde::Deserializer<'de>,
1438 {
1439 struct GeneratedVisitor;
1440
1441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1442 type Value = GeneratedField;
1443
1444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1445 write!(formatter, "expected one of: {:?}", &FIELDS)
1446 }
1447
1448 #[allow(unused_variables)]
1449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1450 where
1451 E: serde::de::Error,
1452 {
1453 match value {
1454 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1455 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1457 }
1458 }
1459 }
1460 deserializer.deserialize_identifier(GeneratedVisitor)
1461 }
1462 }
1463 struct GeneratedVisitor;
1464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1465 type Value = alter_connector_props_request::AlterIcebergTableIds;
1466
1467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1468 formatter.write_str("struct meta.AlterConnectorPropsRequest.AlterIcebergTableIds")
1469 }
1470
1471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_connector_props_request::AlterIcebergTableIds, V::Error>
1472 where
1473 V: serde::de::MapAccess<'de>,
1474 {
1475 let mut source_id__ = None;
1476 let mut sink_id__ = None;
1477 while let Some(k) = map_.next_key()? {
1478 match k {
1479 GeneratedField::SourceId => {
1480 if source_id__.is_some() {
1481 return Err(serde::de::Error::duplicate_field("sourceId"));
1482 }
1483 source_id__ =
1484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1485 ;
1486 }
1487 GeneratedField::SinkId => {
1488 if sink_id__.is_some() {
1489 return Err(serde::de::Error::duplicate_field("sinkId"));
1490 }
1491 sink_id__ =
1492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1493 ;
1494 }
1495 }
1496 }
1497 Ok(alter_connector_props_request::AlterIcebergTableIds {
1498 source_id: source_id__.unwrap_or_default(),
1499 sink_id: sink_id__.unwrap_or_default(),
1500 })
1501 }
1502 }
1503 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", FIELDS, GeneratedVisitor)
1504 }
1505}
1506impl serde::Serialize for AlterConnectorPropsResponse {
1507 #[allow(deprecated)]
1508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1509 where
1510 S: serde::Serializer,
1511 {
1512 use serde::ser::SerializeStruct;
1513 let len = 0;
1514 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1515 struct_ser.end()
1516 }
1517}
1518impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1519 #[allow(deprecated)]
1520 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1521 where
1522 D: serde::Deserializer<'de>,
1523 {
1524 const FIELDS: &[&str] = &[
1525 ];
1526
1527 #[allow(clippy::enum_variant_names)]
1528 enum GeneratedField {
1529 }
1530 impl<'de> serde::Deserialize<'de> for GeneratedField {
1531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1532 where
1533 D: serde::Deserializer<'de>,
1534 {
1535 struct GeneratedVisitor;
1536
1537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1538 type Value = GeneratedField;
1539
1540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1541 write!(formatter, "expected one of: {:?}", &FIELDS)
1542 }
1543
1544 #[allow(unused_variables)]
1545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1546 where
1547 E: serde::de::Error,
1548 {
1549 Err(serde::de::Error::unknown_field(value, FIELDS))
1550 }
1551 }
1552 deserializer.deserialize_identifier(GeneratedVisitor)
1553 }
1554 }
1555 struct GeneratedVisitor;
1556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1557 type Value = AlterConnectorPropsResponse;
1558
1559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1560 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1561 }
1562
1563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1564 where
1565 V: serde::de::MapAccess<'de>,
1566 {
1567 while map_.next_key::<GeneratedField>()?.is_some() {
1568 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1569 }
1570 Ok(AlterConnectorPropsResponse {
1571 })
1572 }
1573 }
1574 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1575 }
1576}
1577impl serde::Serialize for ApplyThrottleRequest {
1578 #[allow(deprecated)]
1579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1580 where
1581 S: serde::Serializer,
1582 {
1583 use serde::ser::SerializeStruct;
1584 let mut len = 0;
1585 if self.kind != 0 {
1586 len += 1;
1587 }
1588 if self.id != 0 {
1589 len += 1;
1590 }
1591 if self.rate.is_some() {
1592 len += 1;
1593 }
1594 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1595 if self.kind != 0 {
1596 let v = ThrottleTarget::try_from(self.kind)
1597 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1598 struct_ser.serialize_field("kind", &v)?;
1599 }
1600 if self.id != 0 {
1601 struct_ser.serialize_field("id", &self.id)?;
1602 }
1603 if let Some(v) = self.rate.as_ref() {
1604 struct_ser.serialize_field("rate", v)?;
1605 }
1606 struct_ser.end()
1607 }
1608}
1609impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1610 #[allow(deprecated)]
1611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1612 where
1613 D: serde::Deserializer<'de>,
1614 {
1615 const FIELDS: &[&str] = &[
1616 "kind",
1617 "id",
1618 "rate",
1619 ];
1620
1621 #[allow(clippy::enum_variant_names)]
1622 enum GeneratedField {
1623 Kind,
1624 Id,
1625 Rate,
1626 }
1627 impl<'de> serde::Deserialize<'de> for GeneratedField {
1628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1629 where
1630 D: serde::Deserializer<'de>,
1631 {
1632 struct GeneratedVisitor;
1633
1634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1635 type Value = GeneratedField;
1636
1637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1638 write!(formatter, "expected one of: {:?}", &FIELDS)
1639 }
1640
1641 #[allow(unused_variables)]
1642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1643 where
1644 E: serde::de::Error,
1645 {
1646 match value {
1647 "kind" => Ok(GeneratedField::Kind),
1648 "id" => Ok(GeneratedField::Id),
1649 "rate" => Ok(GeneratedField::Rate),
1650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1651 }
1652 }
1653 }
1654 deserializer.deserialize_identifier(GeneratedVisitor)
1655 }
1656 }
1657 struct GeneratedVisitor;
1658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1659 type Value = ApplyThrottleRequest;
1660
1661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1662 formatter.write_str("struct meta.ApplyThrottleRequest")
1663 }
1664
1665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1666 where
1667 V: serde::de::MapAccess<'de>,
1668 {
1669 let mut kind__ = None;
1670 let mut id__ = None;
1671 let mut rate__ = None;
1672 while let Some(k) = map_.next_key()? {
1673 match k {
1674 GeneratedField::Kind => {
1675 if kind__.is_some() {
1676 return Err(serde::de::Error::duplicate_field("kind"));
1677 }
1678 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1679 }
1680 GeneratedField::Id => {
1681 if id__.is_some() {
1682 return Err(serde::de::Error::duplicate_field("id"));
1683 }
1684 id__ =
1685 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1686 ;
1687 }
1688 GeneratedField::Rate => {
1689 if rate__.is_some() {
1690 return Err(serde::de::Error::duplicate_field("rate"));
1691 }
1692 rate__ =
1693 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1694 ;
1695 }
1696 }
1697 }
1698 Ok(ApplyThrottleRequest {
1699 kind: kind__.unwrap_or_default(),
1700 id: id__.unwrap_or_default(),
1701 rate: rate__,
1702 })
1703 }
1704 }
1705 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1706 }
1707}
1708impl serde::Serialize for ApplyThrottleResponse {
1709 #[allow(deprecated)]
1710 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1711 where
1712 S: serde::Serializer,
1713 {
1714 use serde::ser::SerializeStruct;
1715 let mut len = 0;
1716 if self.status.is_some() {
1717 len += 1;
1718 }
1719 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1720 if let Some(v) = self.status.as_ref() {
1721 struct_ser.serialize_field("status", v)?;
1722 }
1723 struct_ser.end()
1724 }
1725}
1726impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1727 #[allow(deprecated)]
1728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1729 where
1730 D: serde::Deserializer<'de>,
1731 {
1732 const FIELDS: &[&str] = &[
1733 "status",
1734 ];
1735
1736 #[allow(clippy::enum_variant_names)]
1737 enum GeneratedField {
1738 Status,
1739 }
1740 impl<'de> serde::Deserialize<'de> for GeneratedField {
1741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1742 where
1743 D: serde::Deserializer<'de>,
1744 {
1745 struct GeneratedVisitor;
1746
1747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1748 type Value = GeneratedField;
1749
1750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1751 write!(formatter, "expected one of: {:?}", &FIELDS)
1752 }
1753
1754 #[allow(unused_variables)]
1755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1756 where
1757 E: serde::de::Error,
1758 {
1759 match value {
1760 "status" => Ok(GeneratedField::Status),
1761 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1762 }
1763 }
1764 }
1765 deserializer.deserialize_identifier(GeneratedVisitor)
1766 }
1767 }
1768 struct GeneratedVisitor;
1769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1770 type Value = ApplyThrottleResponse;
1771
1772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1773 formatter.write_str("struct meta.ApplyThrottleResponse")
1774 }
1775
1776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1777 where
1778 V: serde::de::MapAccess<'de>,
1779 {
1780 let mut status__ = None;
1781 while let Some(k) = map_.next_key()? {
1782 match k {
1783 GeneratedField::Status => {
1784 if status__.is_some() {
1785 return Err(serde::de::Error::duplicate_field("status"));
1786 }
1787 status__ = map_.next_value()?;
1788 }
1789 }
1790 }
1791 Ok(ApplyThrottleResponse {
1792 status: status__,
1793 })
1794 }
1795 }
1796 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1797 }
1798}
1799impl serde::Serialize for CancelCreatingJobsRequest {
1800 #[allow(deprecated)]
1801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1802 where
1803 S: serde::Serializer,
1804 {
1805 use serde::ser::SerializeStruct;
1806 let mut len = 0;
1807 if self.jobs.is_some() {
1808 len += 1;
1809 }
1810 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1811 if let Some(v) = self.jobs.as_ref() {
1812 match v {
1813 cancel_creating_jobs_request::Jobs::Infos(v) => {
1814 struct_ser.serialize_field("infos", v)?;
1815 }
1816 cancel_creating_jobs_request::Jobs::Ids(v) => {
1817 struct_ser.serialize_field("ids", v)?;
1818 }
1819 }
1820 }
1821 struct_ser.end()
1822 }
1823}
1824impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1825 #[allow(deprecated)]
1826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1827 where
1828 D: serde::Deserializer<'de>,
1829 {
1830 const FIELDS: &[&str] = &[
1831 "infos",
1832 "ids",
1833 ];
1834
1835 #[allow(clippy::enum_variant_names)]
1836 enum GeneratedField {
1837 Infos,
1838 Ids,
1839 }
1840 impl<'de> serde::Deserialize<'de> for GeneratedField {
1841 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1842 where
1843 D: serde::Deserializer<'de>,
1844 {
1845 struct GeneratedVisitor;
1846
1847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1848 type Value = GeneratedField;
1849
1850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1851 write!(formatter, "expected one of: {:?}", &FIELDS)
1852 }
1853
1854 #[allow(unused_variables)]
1855 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1856 where
1857 E: serde::de::Error,
1858 {
1859 match value {
1860 "infos" => Ok(GeneratedField::Infos),
1861 "ids" => Ok(GeneratedField::Ids),
1862 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1863 }
1864 }
1865 }
1866 deserializer.deserialize_identifier(GeneratedVisitor)
1867 }
1868 }
1869 struct GeneratedVisitor;
1870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1871 type Value = CancelCreatingJobsRequest;
1872
1873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1874 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1875 }
1876
1877 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1878 where
1879 V: serde::de::MapAccess<'de>,
1880 {
1881 let mut jobs__ = None;
1882 while let Some(k) = map_.next_key()? {
1883 match k {
1884 GeneratedField::Infos => {
1885 if jobs__.is_some() {
1886 return Err(serde::de::Error::duplicate_field("infos"));
1887 }
1888 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1889;
1890 }
1891 GeneratedField::Ids => {
1892 if jobs__.is_some() {
1893 return Err(serde::de::Error::duplicate_field("ids"));
1894 }
1895 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1896;
1897 }
1898 }
1899 }
1900 Ok(CancelCreatingJobsRequest {
1901 jobs: jobs__,
1902 })
1903 }
1904 }
1905 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1906 }
1907}
1908impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1909 #[allow(deprecated)]
1910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1911 where
1912 S: serde::Serializer,
1913 {
1914 use serde::ser::SerializeStruct;
1915 let mut len = 0;
1916 if !self.job_ids.is_empty() {
1917 len += 1;
1918 }
1919 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1920 if !self.job_ids.is_empty() {
1921 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1922 }
1923 struct_ser.end()
1924 }
1925}
1926impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1927 #[allow(deprecated)]
1928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1929 where
1930 D: serde::Deserializer<'de>,
1931 {
1932 const FIELDS: &[&str] = &[
1933 "job_ids",
1934 "jobIds",
1935 ];
1936
1937 #[allow(clippy::enum_variant_names)]
1938 enum GeneratedField {
1939 JobIds,
1940 }
1941 impl<'de> serde::Deserialize<'de> for GeneratedField {
1942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1943 where
1944 D: serde::Deserializer<'de>,
1945 {
1946 struct GeneratedVisitor;
1947
1948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1949 type Value = GeneratedField;
1950
1951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1952 write!(formatter, "expected one of: {:?}", &FIELDS)
1953 }
1954
1955 #[allow(unused_variables)]
1956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1957 where
1958 E: serde::de::Error,
1959 {
1960 match value {
1961 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1963 }
1964 }
1965 }
1966 deserializer.deserialize_identifier(GeneratedVisitor)
1967 }
1968 }
1969 struct GeneratedVisitor;
1970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1971 type Value = cancel_creating_jobs_request::CreatingJobIds;
1972
1973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1974 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1975 }
1976
1977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1978 where
1979 V: serde::de::MapAccess<'de>,
1980 {
1981 let mut job_ids__ = None;
1982 while let Some(k) = map_.next_key()? {
1983 match k {
1984 GeneratedField::JobIds => {
1985 if job_ids__.is_some() {
1986 return Err(serde::de::Error::duplicate_field("jobIds"));
1987 }
1988 job_ids__ =
1989 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1990 .into_iter().map(|x| x.0).collect())
1991 ;
1992 }
1993 }
1994 }
1995 Ok(cancel_creating_jobs_request::CreatingJobIds {
1996 job_ids: job_ids__.unwrap_or_default(),
1997 })
1998 }
1999 }
2000 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2001 }
2002}
2003impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
2004 #[allow(deprecated)]
2005 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2006 where
2007 S: serde::Serializer,
2008 {
2009 use serde::ser::SerializeStruct;
2010 let mut len = 0;
2011 if self.database_id != 0 {
2012 len += 1;
2013 }
2014 if self.schema_id != 0 {
2015 len += 1;
2016 }
2017 if !self.name.is_empty() {
2018 len += 1;
2019 }
2020 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2021 if self.database_id != 0 {
2022 struct_ser.serialize_field("databaseId", &self.database_id)?;
2023 }
2024 if self.schema_id != 0 {
2025 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2026 }
2027 if !self.name.is_empty() {
2028 struct_ser.serialize_field("name", &self.name)?;
2029 }
2030 struct_ser.end()
2031 }
2032}
2033impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2034 #[allow(deprecated)]
2035 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2036 where
2037 D: serde::Deserializer<'de>,
2038 {
2039 const FIELDS: &[&str] = &[
2040 "database_id",
2041 "databaseId",
2042 "schema_id",
2043 "schemaId",
2044 "name",
2045 ];
2046
2047 #[allow(clippy::enum_variant_names)]
2048 enum GeneratedField {
2049 DatabaseId,
2050 SchemaId,
2051 Name,
2052 }
2053 impl<'de> serde::Deserialize<'de> for GeneratedField {
2054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2055 where
2056 D: serde::Deserializer<'de>,
2057 {
2058 struct GeneratedVisitor;
2059
2060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2061 type Value = GeneratedField;
2062
2063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2064 write!(formatter, "expected one of: {:?}", &FIELDS)
2065 }
2066
2067 #[allow(unused_variables)]
2068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2069 where
2070 E: serde::de::Error,
2071 {
2072 match value {
2073 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2074 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2075 "name" => Ok(GeneratedField::Name),
2076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2077 }
2078 }
2079 }
2080 deserializer.deserialize_identifier(GeneratedVisitor)
2081 }
2082 }
2083 struct GeneratedVisitor;
2084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2085 type Value = cancel_creating_jobs_request::CreatingJobInfo;
2086
2087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2088 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2089 }
2090
2091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2092 where
2093 V: serde::de::MapAccess<'de>,
2094 {
2095 let mut database_id__ = None;
2096 let mut schema_id__ = None;
2097 let mut name__ = None;
2098 while let Some(k) = map_.next_key()? {
2099 match k {
2100 GeneratedField::DatabaseId => {
2101 if database_id__.is_some() {
2102 return Err(serde::de::Error::duplicate_field("databaseId"));
2103 }
2104 database_id__ =
2105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2106 ;
2107 }
2108 GeneratedField::SchemaId => {
2109 if schema_id__.is_some() {
2110 return Err(serde::de::Error::duplicate_field("schemaId"));
2111 }
2112 schema_id__ =
2113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2114 ;
2115 }
2116 GeneratedField::Name => {
2117 if name__.is_some() {
2118 return Err(serde::de::Error::duplicate_field("name"));
2119 }
2120 name__ = Some(map_.next_value()?);
2121 }
2122 }
2123 }
2124 Ok(cancel_creating_jobs_request::CreatingJobInfo {
2125 database_id: database_id__.unwrap_or_default(),
2126 schema_id: schema_id__.unwrap_or_default(),
2127 name: name__.unwrap_or_default(),
2128 })
2129 }
2130 }
2131 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2132 }
2133}
2134impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2135 #[allow(deprecated)]
2136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2137 where
2138 S: serde::Serializer,
2139 {
2140 use serde::ser::SerializeStruct;
2141 let mut len = 0;
2142 if !self.infos.is_empty() {
2143 len += 1;
2144 }
2145 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2146 if !self.infos.is_empty() {
2147 struct_ser.serialize_field("infos", &self.infos)?;
2148 }
2149 struct_ser.end()
2150 }
2151}
2152impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2153 #[allow(deprecated)]
2154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2155 where
2156 D: serde::Deserializer<'de>,
2157 {
2158 const FIELDS: &[&str] = &[
2159 "infos",
2160 ];
2161
2162 #[allow(clippy::enum_variant_names)]
2163 enum GeneratedField {
2164 Infos,
2165 }
2166 impl<'de> serde::Deserialize<'de> for GeneratedField {
2167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2168 where
2169 D: serde::Deserializer<'de>,
2170 {
2171 struct GeneratedVisitor;
2172
2173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2174 type Value = GeneratedField;
2175
2176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2177 write!(formatter, "expected one of: {:?}", &FIELDS)
2178 }
2179
2180 #[allow(unused_variables)]
2181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2182 where
2183 E: serde::de::Error,
2184 {
2185 match value {
2186 "infos" => Ok(GeneratedField::Infos),
2187 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2188 }
2189 }
2190 }
2191 deserializer.deserialize_identifier(GeneratedVisitor)
2192 }
2193 }
2194 struct GeneratedVisitor;
2195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2196 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2197
2198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2199 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2200 }
2201
2202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2203 where
2204 V: serde::de::MapAccess<'de>,
2205 {
2206 let mut infos__ = None;
2207 while let Some(k) = map_.next_key()? {
2208 match k {
2209 GeneratedField::Infos => {
2210 if infos__.is_some() {
2211 return Err(serde::de::Error::duplicate_field("infos"));
2212 }
2213 infos__ = Some(map_.next_value()?);
2214 }
2215 }
2216 }
2217 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2218 infos: infos__.unwrap_or_default(),
2219 })
2220 }
2221 }
2222 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2223 }
2224}
2225impl serde::Serialize for CancelCreatingJobsResponse {
2226 #[allow(deprecated)]
2227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2228 where
2229 S: serde::Serializer,
2230 {
2231 use serde::ser::SerializeStruct;
2232 let mut len = 0;
2233 if self.status.is_some() {
2234 len += 1;
2235 }
2236 if !self.canceled_jobs.is_empty() {
2237 len += 1;
2238 }
2239 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2240 if let Some(v) = self.status.as_ref() {
2241 struct_ser.serialize_field("status", v)?;
2242 }
2243 if !self.canceled_jobs.is_empty() {
2244 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2245 }
2246 struct_ser.end()
2247 }
2248}
2249impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2250 #[allow(deprecated)]
2251 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2252 where
2253 D: serde::Deserializer<'de>,
2254 {
2255 const FIELDS: &[&str] = &[
2256 "status",
2257 "canceled_jobs",
2258 "canceledJobs",
2259 ];
2260
2261 #[allow(clippy::enum_variant_names)]
2262 enum GeneratedField {
2263 Status,
2264 CanceledJobs,
2265 }
2266 impl<'de> serde::Deserialize<'de> for GeneratedField {
2267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2268 where
2269 D: serde::Deserializer<'de>,
2270 {
2271 struct GeneratedVisitor;
2272
2273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2274 type Value = GeneratedField;
2275
2276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2277 write!(formatter, "expected one of: {:?}", &FIELDS)
2278 }
2279
2280 #[allow(unused_variables)]
2281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2282 where
2283 E: serde::de::Error,
2284 {
2285 match value {
2286 "status" => Ok(GeneratedField::Status),
2287 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2289 }
2290 }
2291 }
2292 deserializer.deserialize_identifier(GeneratedVisitor)
2293 }
2294 }
2295 struct GeneratedVisitor;
2296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2297 type Value = CancelCreatingJobsResponse;
2298
2299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2301 }
2302
2303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2304 where
2305 V: serde::de::MapAccess<'de>,
2306 {
2307 let mut status__ = None;
2308 let mut canceled_jobs__ = None;
2309 while let Some(k) = map_.next_key()? {
2310 match k {
2311 GeneratedField::Status => {
2312 if status__.is_some() {
2313 return Err(serde::de::Error::duplicate_field("status"));
2314 }
2315 status__ = map_.next_value()?;
2316 }
2317 GeneratedField::CanceledJobs => {
2318 if canceled_jobs__.is_some() {
2319 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2320 }
2321 canceled_jobs__ =
2322 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2323 .into_iter().map(|x| x.0).collect())
2324 ;
2325 }
2326 }
2327 }
2328 Ok(CancelCreatingJobsResponse {
2329 status: status__,
2330 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2331 })
2332 }
2333 }
2334 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2335 }
2336}
2337impl serde::Serialize for ClusterLimit {
2338 #[allow(deprecated)]
2339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2340 where
2341 S: serde::Serializer,
2342 {
2343 use serde::ser::SerializeStruct;
2344 let mut len = 0;
2345 if self.limit.is_some() {
2346 len += 1;
2347 }
2348 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2349 if let Some(v) = self.limit.as_ref() {
2350 match v {
2351 cluster_limit::Limit::ActorCount(v) => {
2352 struct_ser.serialize_field("actorCount", v)?;
2353 }
2354 }
2355 }
2356 struct_ser.end()
2357 }
2358}
2359impl<'de> serde::Deserialize<'de> for ClusterLimit {
2360 #[allow(deprecated)]
2361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2362 where
2363 D: serde::Deserializer<'de>,
2364 {
2365 const FIELDS: &[&str] = &[
2366 "actor_count",
2367 "actorCount",
2368 ];
2369
2370 #[allow(clippy::enum_variant_names)]
2371 enum GeneratedField {
2372 ActorCount,
2373 }
2374 impl<'de> serde::Deserialize<'de> for GeneratedField {
2375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2376 where
2377 D: serde::Deserializer<'de>,
2378 {
2379 struct GeneratedVisitor;
2380
2381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2382 type Value = GeneratedField;
2383
2384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2385 write!(formatter, "expected one of: {:?}", &FIELDS)
2386 }
2387
2388 #[allow(unused_variables)]
2389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2390 where
2391 E: serde::de::Error,
2392 {
2393 match value {
2394 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2396 }
2397 }
2398 }
2399 deserializer.deserialize_identifier(GeneratedVisitor)
2400 }
2401 }
2402 struct GeneratedVisitor;
2403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2404 type Value = ClusterLimit;
2405
2406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2407 formatter.write_str("struct meta.ClusterLimit")
2408 }
2409
2410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2411 where
2412 V: serde::de::MapAccess<'de>,
2413 {
2414 let mut limit__ = None;
2415 while let Some(k) = map_.next_key()? {
2416 match k {
2417 GeneratedField::ActorCount => {
2418 if limit__.is_some() {
2419 return Err(serde::de::Error::duplicate_field("actorCount"));
2420 }
2421 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2422;
2423 }
2424 }
2425 }
2426 Ok(ClusterLimit {
2427 limit: limit__,
2428 })
2429 }
2430 }
2431 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2432 }
2433}
2434impl serde::Serialize for DeleteWorkerNodeRequest {
2435 #[allow(deprecated)]
2436 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2437 where
2438 S: serde::Serializer,
2439 {
2440 use serde::ser::SerializeStruct;
2441 let mut len = 0;
2442 if self.host.is_some() {
2443 len += 1;
2444 }
2445 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2446 if let Some(v) = self.host.as_ref() {
2447 struct_ser.serialize_field("host", v)?;
2448 }
2449 struct_ser.end()
2450 }
2451}
2452impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2453 #[allow(deprecated)]
2454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2455 where
2456 D: serde::Deserializer<'de>,
2457 {
2458 const FIELDS: &[&str] = &[
2459 "host",
2460 ];
2461
2462 #[allow(clippy::enum_variant_names)]
2463 enum GeneratedField {
2464 Host,
2465 }
2466 impl<'de> serde::Deserialize<'de> for GeneratedField {
2467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2468 where
2469 D: serde::Deserializer<'de>,
2470 {
2471 struct GeneratedVisitor;
2472
2473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2474 type Value = GeneratedField;
2475
2476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2477 write!(formatter, "expected one of: {:?}", &FIELDS)
2478 }
2479
2480 #[allow(unused_variables)]
2481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2482 where
2483 E: serde::de::Error,
2484 {
2485 match value {
2486 "host" => Ok(GeneratedField::Host),
2487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2488 }
2489 }
2490 }
2491 deserializer.deserialize_identifier(GeneratedVisitor)
2492 }
2493 }
2494 struct GeneratedVisitor;
2495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2496 type Value = DeleteWorkerNodeRequest;
2497
2498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2499 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2500 }
2501
2502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2503 where
2504 V: serde::de::MapAccess<'de>,
2505 {
2506 let mut host__ = None;
2507 while let Some(k) = map_.next_key()? {
2508 match k {
2509 GeneratedField::Host => {
2510 if host__.is_some() {
2511 return Err(serde::de::Error::duplicate_field("host"));
2512 }
2513 host__ = map_.next_value()?;
2514 }
2515 }
2516 }
2517 Ok(DeleteWorkerNodeRequest {
2518 host: host__,
2519 })
2520 }
2521 }
2522 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2523 }
2524}
2525impl serde::Serialize for DeleteWorkerNodeResponse {
2526 #[allow(deprecated)]
2527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2528 where
2529 S: serde::Serializer,
2530 {
2531 use serde::ser::SerializeStruct;
2532 let mut len = 0;
2533 if self.status.is_some() {
2534 len += 1;
2535 }
2536 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2537 if let Some(v) = self.status.as_ref() {
2538 struct_ser.serialize_field("status", v)?;
2539 }
2540 struct_ser.end()
2541 }
2542}
2543impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2544 #[allow(deprecated)]
2545 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2546 where
2547 D: serde::Deserializer<'de>,
2548 {
2549 const FIELDS: &[&str] = &[
2550 "status",
2551 ];
2552
2553 #[allow(clippy::enum_variant_names)]
2554 enum GeneratedField {
2555 Status,
2556 }
2557 impl<'de> serde::Deserialize<'de> for GeneratedField {
2558 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2559 where
2560 D: serde::Deserializer<'de>,
2561 {
2562 struct GeneratedVisitor;
2563
2564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2565 type Value = GeneratedField;
2566
2567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2568 write!(formatter, "expected one of: {:?}", &FIELDS)
2569 }
2570
2571 #[allow(unused_variables)]
2572 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2573 where
2574 E: serde::de::Error,
2575 {
2576 match value {
2577 "status" => Ok(GeneratedField::Status),
2578 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2579 }
2580 }
2581 }
2582 deserializer.deserialize_identifier(GeneratedVisitor)
2583 }
2584 }
2585 struct GeneratedVisitor;
2586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2587 type Value = DeleteWorkerNodeResponse;
2588
2589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2590 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2591 }
2592
2593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2594 where
2595 V: serde::de::MapAccess<'de>,
2596 {
2597 let mut status__ = None;
2598 while let Some(k) = map_.next_key()? {
2599 match k {
2600 GeneratedField::Status => {
2601 if status__.is_some() {
2602 return Err(serde::de::Error::duplicate_field("status"));
2603 }
2604 status__ = map_.next_value()?;
2605 }
2606 }
2607 }
2608 Ok(DeleteWorkerNodeResponse {
2609 status: status__,
2610 })
2611 }
2612 }
2613 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2614 }
2615}
2616impl serde::Serialize for EventLog {
2617 #[allow(deprecated)]
2618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2619 where
2620 S: serde::Serializer,
2621 {
2622 use serde::ser::SerializeStruct;
2623 let mut len = 0;
2624 if self.unique_id.is_some() {
2625 len += 1;
2626 }
2627 if self.timestamp.is_some() {
2628 len += 1;
2629 }
2630 if self.event.is_some() {
2631 len += 1;
2632 }
2633 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2634 if let Some(v) = self.unique_id.as_ref() {
2635 struct_ser.serialize_field("uniqueId", v)?;
2636 }
2637 if let Some(v) = self.timestamp.as_ref() {
2638 #[allow(clippy::needless_borrow)]
2639 #[allow(clippy::needless_borrows_for_generic_args)]
2640 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2641 }
2642 if let Some(v) = self.event.as_ref() {
2643 match v {
2644 event_log::Event::CreateStreamJobFail(v) => {
2645 struct_ser.serialize_field("createStreamJobFail", v)?;
2646 }
2647 event_log::Event::DirtyStreamJobClear(v) => {
2648 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2649 }
2650 event_log::Event::MetaNodeStart(v) => {
2651 struct_ser.serialize_field("metaNodeStart", v)?;
2652 }
2653 event_log::Event::BarrierComplete(v) => {
2654 struct_ser.serialize_field("barrierComplete", v)?;
2655 }
2656 event_log::Event::InjectBarrierFail(v) => {
2657 struct_ser.serialize_field("injectBarrierFail", v)?;
2658 }
2659 event_log::Event::CollectBarrierFail(v) => {
2660 struct_ser.serialize_field("collectBarrierFail", v)?;
2661 }
2662 event_log::Event::WorkerNodePanic(v) => {
2663 struct_ser.serialize_field("workerNodePanic", v)?;
2664 }
2665 event_log::Event::AutoSchemaChangeFail(v) => {
2666 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2667 }
2668 event_log::Event::SinkFail(v) => {
2669 struct_ser.serialize_field("sinkFail", v)?;
2670 }
2671 event_log::Event::Recovery(v) => {
2672 struct_ser.serialize_field("recovery", v)?;
2673 }
2674 }
2675 }
2676 struct_ser.end()
2677 }
2678}
2679impl<'de> serde::Deserialize<'de> for EventLog {
2680 #[allow(deprecated)]
2681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2682 where
2683 D: serde::Deserializer<'de>,
2684 {
2685 const FIELDS: &[&str] = &[
2686 "unique_id",
2687 "uniqueId",
2688 "timestamp",
2689 "create_stream_job_fail",
2690 "createStreamJobFail",
2691 "dirty_stream_job_clear",
2692 "dirtyStreamJobClear",
2693 "meta_node_start",
2694 "metaNodeStart",
2695 "barrier_complete",
2696 "barrierComplete",
2697 "inject_barrier_fail",
2698 "injectBarrierFail",
2699 "collect_barrier_fail",
2700 "collectBarrierFail",
2701 "worker_node_panic",
2702 "workerNodePanic",
2703 "auto_schema_change_fail",
2704 "autoSchemaChangeFail",
2705 "sink_fail",
2706 "sinkFail",
2707 "recovery",
2708 ];
2709
2710 #[allow(clippy::enum_variant_names)]
2711 enum GeneratedField {
2712 UniqueId,
2713 Timestamp,
2714 CreateStreamJobFail,
2715 DirtyStreamJobClear,
2716 MetaNodeStart,
2717 BarrierComplete,
2718 InjectBarrierFail,
2719 CollectBarrierFail,
2720 WorkerNodePanic,
2721 AutoSchemaChangeFail,
2722 SinkFail,
2723 Recovery,
2724 }
2725 impl<'de> serde::Deserialize<'de> for GeneratedField {
2726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2727 where
2728 D: serde::Deserializer<'de>,
2729 {
2730 struct GeneratedVisitor;
2731
2732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2733 type Value = GeneratedField;
2734
2735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2736 write!(formatter, "expected one of: {:?}", &FIELDS)
2737 }
2738
2739 #[allow(unused_variables)]
2740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2741 where
2742 E: serde::de::Error,
2743 {
2744 match value {
2745 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2746 "timestamp" => Ok(GeneratedField::Timestamp),
2747 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2748 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2749 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2750 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2751 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2752 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2753 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2754 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2755 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2756 "recovery" => Ok(GeneratedField::Recovery),
2757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2758 }
2759 }
2760 }
2761 deserializer.deserialize_identifier(GeneratedVisitor)
2762 }
2763 }
2764 struct GeneratedVisitor;
2765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2766 type Value = EventLog;
2767
2768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2769 formatter.write_str("struct meta.EventLog")
2770 }
2771
2772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2773 where
2774 V: serde::de::MapAccess<'de>,
2775 {
2776 let mut unique_id__ = None;
2777 let mut timestamp__ = None;
2778 let mut event__ = None;
2779 while let Some(k) = map_.next_key()? {
2780 match k {
2781 GeneratedField::UniqueId => {
2782 if unique_id__.is_some() {
2783 return Err(serde::de::Error::duplicate_field("uniqueId"));
2784 }
2785 unique_id__ = map_.next_value()?;
2786 }
2787 GeneratedField::Timestamp => {
2788 if timestamp__.is_some() {
2789 return Err(serde::de::Error::duplicate_field("timestamp"));
2790 }
2791 timestamp__ =
2792 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2793 ;
2794 }
2795 GeneratedField::CreateStreamJobFail => {
2796 if event__.is_some() {
2797 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2798 }
2799 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2800;
2801 }
2802 GeneratedField::DirtyStreamJobClear => {
2803 if event__.is_some() {
2804 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2805 }
2806 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2807;
2808 }
2809 GeneratedField::MetaNodeStart => {
2810 if event__.is_some() {
2811 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2812 }
2813 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2814;
2815 }
2816 GeneratedField::BarrierComplete => {
2817 if event__.is_some() {
2818 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2819 }
2820 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2821;
2822 }
2823 GeneratedField::InjectBarrierFail => {
2824 if event__.is_some() {
2825 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2826 }
2827 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2828;
2829 }
2830 GeneratedField::CollectBarrierFail => {
2831 if event__.is_some() {
2832 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2833 }
2834 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2835;
2836 }
2837 GeneratedField::WorkerNodePanic => {
2838 if event__.is_some() {
2839 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2840 }
2841 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2842;
2843 }
2844 GeneratedField::AutoSchemaChangeFail => {
2845 if event__.is_some() {
2846 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2847 }
2848 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2849;
2850 }
2851 GeneratedField::SinkFail => {
2852 if event__.is_some() {
2853 return Err(serde::de::Error::duplicate_field("sinkFail"));
2854 }
2855 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2856;
2857 }
2858 GeneratedField::Recovery => {
2859 if event__.is_some() {
2860 return Err(serde::de::Error::duplicate_field("recovery"));
2861 }
2862 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2863;
2864 }
2865 }
2866 }
2867 Ok(EventLog {
2868 unique_id: unique_id__,
2869 timestamp: timestamp__,
2870 event: event__,
2871 })
2872 }
2873 }
2874 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2875 }
2876}
2877impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2878 #[allow(deprecated)]
2879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2880 where
2881 S: serde::Serializer,
2882 {
2883 use serde::ser::SerializeStruct;
2884 let mut len = 0;
2885 if self.table_id != 0 {
2886 len += 1;
2887 }
2888 if !self.table_name.is_empty() {
2889 len += 1;
2890 }
2891 if !self.cdc_table_id.is_empty() {
2892 len += 1;
2893 }
2894 if !self.upstream_ddl.is_empty() {
2895 len += 1;
2896 }
2897 if !self.fail_info.is_empty() {
2898 len += 1;
2899 }
2900 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2901 if self.table_id != 0 {
2902 struct_ser.serialize_field("tableId", &self.table_id)?;
2903 }
2904 if !self.table_name.is_empty() {
2905 struct_ser.serialize_field("tableName", &self.table_name)?;
2906 }
2907 if !self.cdc_table_id.is_empty() {
2908 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2909 }
2910 if !self.upstream_ddl.is_empty() {
2911 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2912 }
2913 if !self.fail_info.is_empty() {
2914 struct_ser.serialize_field("failInfo", &self.fail_info)?;
2915 }
2916 struct_ser.end()
2917 }
2918}
2919impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2920 #[allow(deprecated)]
2921 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2922 where
2923 D: serde::Deserializer<'de>,
2924 {
2925 const FIELDS: &[&str] = &[
2926 "table_id",
2927 "tableId",
2928 "table_name",
2929 "tableName",
2930 "cdc_table_id",
2931 "cdcTableId",
2932 "upstream_ddl",
2933 "upstreamDdl",
2934 "fail_info",
2935 "failInfo",
2936 ];
2937
2938 #[allow(clippy::enum_variant_names)]
2939 enum GeneratedField {
2940 TableId,
2941 TableName,
2942 CdcTableId,
2943 UpstreamDdl,
2944 FailInfo,
2945 }
2946 impl<'de> serde::Deserialize<'de> for GeneratedField {
2947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2948 where
2949 D: serde::Deserializer<'de>,
2950 {
2951 struct GeneratedVisitor;
2952
2953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2954 type Value = GeneratedField;
2955
2956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2957 write!(formatter, "expected one of: {:?}", &FIELDS)
2958 }
2959
2960 #[allow(unused_variables)]
2961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2962 where
2963 E: serde::de::Error,
2964 {
2965 match value {
2966 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2967 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2968 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2969 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2970 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
2971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2972 }
2973 }
2974 }
2975 deserializer.deserialize_identifier(GeneratedVisitor)
2976 }
2977 }
2978 struct GeneratedVisitor;
2979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2980 type Value = event_log::EventAutoSchemaChangeFail;
2981
2982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2983 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2984 }
2985
2986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2987 where
2988 V: serde::de::MapAccess<'de>,
2989 {
2990 let mut table_id__ = None;
2991 let mut table_name__ = None;
2992 let mut cdc_table_id__ = None;
2993 let mut upstream_ddl__ = None;
2994 let mut fail_info__ = None;
2995 while let Some(k) = map_.next_key()? {
2996 match k {
2997 GeneratedField::TableId => {
2998 if table_id__.is_some() {
2999 return Err(serde::de::Error::duplicate_field("tableId"));
3000 }
3001 table_id__ =
3002 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3003 ;
3004 }
3005 GeneratedField::TableName => {
3006 if table_name__.is_some() {
3007 return Err(serde::de::Error::duplicate_field("tableName"));
3008 }
3009 table_name__ = Some(map_.next_value()?);
3010 }
3011 GeneratedField::CdcTableId => {
3012 if cdc_table_id__.is_some() {
3013 return Err(serde::de::Error::duplicate_field("cdcTableId"));
3014 }
3015 cdc_table_id__ = Some(map_.next_value()?);
3016 }
3017 GeneratedField::UpstreamDdl => {
3018 if upstream_ddl__.is_some() {
3019 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3020 }
3021 upstream_ddl__ = Some(map_.next_value()?);
3022 }
3023 GeneratedField::FailInfo => {
3024 if fail_info__.is_some() {
3025 return Err(serde::de::Error::duplicate_field("failInfo"));
3026 }
3027 fail_info__ = Some(map_.next_value()?);
3028 }
3029 }
3030 }
3031 Ok(event_log::EventAutoSchemaChangeFail {
3032 table_id: table_id__.unwrap_or_default(),
3033 table_name: table_name__.unwrap_or_default(),
3034 cdc_table_id: cdc_table_id__.unwrap_or_default(),
3035 upstream_ddl: upstream_ddl__.unwrap_or_default(),
3036 fail_info: fail_info__.unwrap_or_default(),
3037 })
3038 }
3039 }
3040 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3041 }
3042}
3043impl serde::Serialize for event_log::EventBarrierComplete {
3044 #[allow(deprecated)]
3045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3046 where
3047 S: serde::Serializer,
3048 {
3049 use serde::ser::SerializeStruct;
3050 let mut len = 0;
3051 if self.prev_epoch != 0 {
3052 len += 1;
3053 }
3054 if self.cur_epoch != 0 {
3055 len += 1;
3056 }
3057 if self.duration_sec != 0. {
3058 len += 1;
3059 }
3060 if !self.command.is_empty() {
3061 len += 1;
3062 }
3063 if !self.barrier_kind.is_empty() {
3064 len += 1;
3065 }
3066 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3067 if self.prev_epoch != 0 {
3068 #[allow(clippy::needless_borrow)]
3069 #[allow(clippy::needless_borrows_for_generic_args)]
3070 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3071 }
3072 if self.cur_epoch != 0 {
3073 #[allow(clippy::needless_borrow)]
3074 #[allow(clippy::needless_borrows_for_generic_args)]
3075 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3076 }
3077 if self.duration_sec != 0. {
3078 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3079 }
3080 if !self.command.is_empty() {
3081 struct_ser.serialize_field("command", &self.command)?;
3082 }
3083 if !self.barrier_kind.is_empty() {
3084 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3085 }
3086 struct_ser.end()
3087 }
3088}
3089impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3090 #[allow(deprecated)]
3091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3092 where
3093 D: serde::Deserializer<'de>,
3094 {
3095 const FIELDS: &[&str] = &[
3096 "prev_epoch",
3097 "prevEpoch",
3098 "cur_epoch",
3099 "curEpoch",
3100 "duration_sec",
3101 "durationSec",
3102 "command",
3103 "barrier_kind",
3104 "barrierKind",
3105 ];
3106
3107 #[allow(clippy::enum_variant_names)]
3108 enum GeneratedField {
3109 PrevEpoch,
3110 CurEpoch,
3111 DurationSec,
3112 Command,
3113 BarrierKind,
3114 }
3115 impl<'de> serde::Deserialize<'de> for GeneratedField {
3116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3117 where
3118 D: serde::Deserializer<'de>,
3119 {
3120 struct GeneratedVisitor;
3121
3122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3123 type Value = GeneratedField;
3124
3125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3126 write!(formatter, "expected one of: {:?}", &FIELDS)
3127 }
3128
3129 #[allow(unused_variables)]
3130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3131 where
3132 E: serde::de::Error,
3133 {
3134 match value {
3135 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3136 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3137 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3138 "command" => Ok(GeneratedField::Command),
3139 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3140 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3141 }
3142 }
3143 }
3144 deserializer.deserialize_identifier(GeneratedVisitor)
3145 }
3146 }
3147 struct GeneratedVisitor;
3148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3149 type Value = event_log::EventBarrierComplete;
3150
3151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3152 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3153 }
3154
3155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3156 where
3157 V: serde::de::MapAccess<'de>,
3158 {
3159 let mut prev_epoch__ = None;
3160 let mut cur_epoch__ = None;
3161 let mut duration_sec__ = None;
3162 let mut command__ = None;
3163 let mut barrier_kind__ = None;
3164 while let Some(k) = map_.next_key()? {
3165 match k {
3166 GeneratedField::PrevEpoch => {
3167 if prev_epoch__.is_some() {
3168 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3169 }
3170 prev_epoch__ =
3171 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3172 ;
3173 }
3174 GeneratedField::CurEpoch => {
3175 if cur_epoch__.is_some() {
3176 return Err(serde::de::Error::duplicate_field("curEpoch"));
3177 }
3178 cur_epoch__ =
3179 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3180 ;
3181 }
3182 GeneratedField::DurationSec => {
3183 if duration_sec__.is_some() {
3184 return Err(serde::de::Error::duplicate_field("durationSec"));
3185 }
3186 duration_sec__ =
3187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3188 ;
3189 }
3190 GeneratedField::Command => {
3191 if command__.is_some() {
3192 return Err(serde::de::Error::duplicate_field("command"));
3193 }
3194 command__ = Some(map_.next_value()?);
3195 }
3196 GeneratedField::BarrierKind => {
3197 if barrier_kind__.is_some() {
3198 return Err(serde::de::Error::duplicate_field("barrierKind"));
3199 }
3200 barrier_kind__ = Some(map_.next_value()?);
3201 }
3202 }
3203 }
3204 Ok(event_log::EventBarrierComplete {
3205 prev_epoch: prev_epoch__.unwrap_or_default(),
3206 cur_epoch: cur_epoch__.unwrap_or_default(),
3207 duration_sec: duration_sec__.unwrap_or_default(),
3208 command: command__.unwrap_or_default(),
3209 barrier_kind: barrier_kind__.unwrap_or_default(),
3210 })
3211 }
3212 }
3213 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3214 }
3215}
3216impl serde::Serialize for event_log::EventCollectBarrierFail {
3217 #[allow(deprecated)]
3218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3219 where
3220 S: serde::Serializer,
3221 {
3222 use serde::ser::SerializeStruct;
3223 let mut len = 0;
3224 if !self.error.is_empty() {
3225 len += 1;
3226 }
3227 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3228 if !self.error.is_empty() {
3229 struct_ser.serialize_field("error", &self.error)?;
3230 }
3231 struct_ser.end()
3232 }
3233}
3234impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3235 #[allow(deprecated)]
3236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3237 where
3238 D: serde::Deserializer<'de>,
3239 {
3240 const FIELDS: &[&str] = &[
3241 "error",
3242 ];
3243
3244 #[allow(clippy::enum_variant_names)]
3245 enum GeneratedField {
3246 Error,
3247 }
3248 impl<'de> serde::Deserialize<'de> for GeneratedField {
3249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3250 where
3251 D: serde::Deserializer<'de>,
3252 {
3253 struct GeneratedVisitor;
3254
3255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256 type Value = GeneratedField;
3257
3258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259 write!(formatter, "expected one of: {:?}", &FIELDS)
3260 }
3261
3262 #[allow(unused_variables)]
3263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3264 where
3265 E: serde::de::Error,
3266 {
3267 match value {
3268 "error" => Ok(GeneratedField::Error),
3269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3270 }
3271 }
3272 }
3273 deserializer.deserialize_identifier(GeneratedVisitor)
3274 }
3275 }
3276 struct GeneratedVisitor;
3277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3278 type Value = event_log::EventCollectBarrierFail;
3279
3280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3281 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3282 }
3283
3284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3285 where
3286 V: serde::de::MapAccess<'de>,
3287 {
3288 let mut error__ = None;
3289 while let Some(k) = map_.next_key()? {
3290 match k {
3291 GeneratedField::Error => {
3292 if error__.is_some() {
3293 return Err(serde::de::Error::duplicate_field("error"));
3294 }
3295 error__ = Some(map_.next_value()?);
3296 }
3297 }
3298 }
3299 Ok(event_log::EventCollectBarrierFail {
3300 error: error__.unwrap_or_default(),
3301 })
3302 }
3303 }
3304 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3305 }
3306}
3307impl serde::Serialize for event_log::EventCreateStreamJobFail {
3308 #[allow(deprecated)]
3309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3310 where
3311 S: serde::Serializer,
3312 {
3313 use serde::ser::SerializeStruct;
3314 let mut len = 0;
3315 if self.id != 0 {
3316 len += 1;
3317 }
3318 if !self.name.is_empty() {
3319 len += 1;
3320 }
3321 if !self.definition.is_empty() {
3322 len += 1;
3323 }
3324 if !self.error.is_empty() {
3325 len += 1;
3326 }
3327 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3328 if self.id != 0 {
3329 struct_ser.serialize_field("id", &self.id)?;
3330 }
3331 if !self.name.is_empty() {
3332 struct_ser.serialize_field("name", &self.name)?;
3333 }
3334 if !self.definition.is_empty() {
3335 struct_ser.serialize_field("definition", &self.definition)?;
3336 }
3337 if !self.error.is_empty() {
3338 struct_ser.serialize_field("error", &self.error)?;
3339 }
3340 struct_ser.end()
3341 }
3342}
3343impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3344 #[allow(deprecated)]
3345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3346 where
3347 D: serde::Deserializer<'de>,
3348 {
3349 const FIELDS: &[&str] = &[
3350 "id",
3351 "name",
3352 "definition",
3353 "error",
3354 ];
3355
3356 #[allow(clippy::enum_variant_names)]
3357 enum GeneratedField {
3358 Id,
3359 Name,
3360 Definition,
3361 Error,
3362 }
3363 impl<'de> serde::Deserialize<'de> for GeneratedField {
3364 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3365 where
3366 D: serde::Deserializer<'de>,
3367 {
3368 struct GeneratedVisitor;
3369
3370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3371 type Value = GeneratedField;
3372
3373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3374 write!(formatter, "expected one of: {:?}", &FIELDS)
3375 }
3376
3377 #[allow(unused_variables)]
3378 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3379 where
3380 E: serde::de::Error,
3381 {
3382 match value {
3383 "id" => Ok(GeneratedField::Id),
3384 "name" => Ok(GeneratedField::Name),
3385 "definition" => Ok(GeneratedField::Definition),
3386 "error" => Ok(GeneratedField::Error),
3387 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3388 }
3389 }
3390 }
3391 deserializer.deserialize_identifier(GeneratedVisitor)
3392 }
3393 }
3394 struct GeneratedVisitor;
3395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3396 type Value = event_log::EventCreateStreamJobFail;
3397
3398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3399 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3400 }
3401
3402 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3403 where
3404 V: serde::de::MapAccess<'de>,
3405 {
3406 let mut id__ = None;
3407 let mut name__ = None;
3408 let mut definition__ = None;
3409 let mut error__ = None;
3410 while let Some(k) = map_.next_key()? {
3411 match k {
3412 GeneratedField::Id => {
3413 if id__.is_some() {
3414 return Err(serde::de::Error::duplicate_field("id"));
3415 }
3416 id__ =
3417 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3418 ;
3419 }
3420 GeneratedField::Name => {
3421 if name__.is_some() {
3422 return Err(serde::de::Error::duplicate_field("name"));
3423 }
3424 name__ = Some(map_.next_value()?);
3425 }
3426 GeneratedField::Definition => {
3427 if definition__.is_some() {
3428 return Err(serde::de::Error::duplicate_field("definition"));
3429 }
3430 definition__ = Some(map_.next_value()?);
3431 }
3432 GeneratedField::Error => {
3433 if error__.is_some() {
3434 return Err(serde::de::Error::duplicate_field("error"));
3435 }
3436 error__ = Some(map_.next_value()?);
3437 }
3438 }
3439 }
3440 Ok(event_log::EventCreateStreamJobFail {
3441 id: id__.unwrap_or_default(),
3442 name: name__.unwrap_or_default(),
3443 definition: definition__.unwrap_or_default(),
3444 error: error__.unwrap_or_default(),
3445 })
3446 }
3447 }
3448 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3449 }
3450}
3451impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3452 #[allow(deprecated)]
3453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3454 where
3455 S: serde::Serializer,
3456 {
3457 use serde::ser::SerializeStruct;
3458 let mut len = 0;
3459 if self.id != 0 {
3460 len += 1;
3461 }
3462 if !self.name.is_empty() {
3463 len += 1;
3464 }
3465 if !self.definition.is_empty() {
3466 len += 1;
3467 }
3468 if !self.error.is_empty() {
3469 len += 1;
3470 }
3471 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3472 if self.id != 0 {
3473 struct_ser.serialize_field("id", &self.id)?;
3474 }
3475 if !self.name.is_empty() {
3476 struct_ser.serialize_field("name", &self.name)?;
3477 }
3478 if !self.definition.is_empty() {
3479 struct_ser.serialize_field("definition", &self.definition)?;
3480 }
3481 if !self.error.is_empty() {
3482 struct_ser.serialize_field("error", &self.error)?;
3483 }
3484 struct_ser.end()
3485 }
3486}
3487impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3488 #[allow(deprecated)]
3489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3490 where
3491 D: serde::Deserializer<'de>,
3492 {
3493 const FIELDS: &[&str] = &[
3494 "id",
3495 "name",
3496 "definition",
3497 "error",
3498 ];
3499
3500 #[allow(clippy::enum_variant_names)]
3501 enum GeneratedField {
3502 Id,
3503 Name,
3504 Definition,
3505 Error,
3506 }
3507 impl<'de> serde::Deserialize<'de> for GeneratedField {
3508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3509 where
3510 D: serde::Deserializer<'de>,
3511 {
3512 struct GeneratedVisitor;
3513
3514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3515 type Value = GeneratedField;
3516
3517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3518 write!(formatter, "expected one of: {:?}", &FIELDS)
3519 }
3520
3521 #[allow(unused_variables)]
3522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3523 where
3524 E: serde::de::Error,
3525 {
3526 match value {
3527 "id" => Ok(GeneratedField::Id),
3528 "name" => Ok(GeneratedField::Name),
3529 "definition" => Ok(GeneratedField::Definition),
3530 "error" => Ok(GeneratedField::Error),
3531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3532 }
3533 }
3534 }
3535 deserializer.deserialize_identifier(GeneratedVisitor)
3536 }
3537 }
3538 struct GeneratedVisitor;
3539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3540 type Value = event_log::EventDirtyStreamJobClear;
3541
3542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3543 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3544 }
3545
3546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3547 where
3548 V: serde::de::MapAccess<'de>,
3549 {
3550 let mut id__ = None;
3551 let mut name__ = None;
3552 let mut definition__ = None;
3553 let mut error__ = None;
3554 while let Some(k) = map_.next_key()? {
3555 match k {
3556 GeneratedField::Id => {
3557 if id__.is_some() {
3558 return Err(serde::de::Error::duplicate_field("id"));
3559 }
3560 id__ =
3561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3562 ;
3563 }
3564 GeneratedField::Name => {
3565 if name__.is_some() {
3566 return Err(serde::de::Error::duplicate_field("name"));
3567 }
3568 name__ = Some(map_.next_value()?);
3569 }
3570 GeneratedField::Definition => {
3571 if definition__.is_some() {
3572 return Err(serde::de::Error::duplicate_field("definition"));
3573 }
3574 definition__ = Some(map_.next_value()?);
3575 }
3576 GeneratedField::Error => {
3577 if error__.is_some() {
3578 return Err(serde::de::Error::duplicate_field("error"));
3579 }
3580 error__ = Some(map_.next_value()?);
3581 }
3582 }
3583 }
3584 Ok(event_log::EventDirtyStreamJobClear {
3585 id: id__.unwrap_or_default(),
3586 name: name__.unwrap_or_default(),
3587 definition: definition__.unwrap_or_default(),
3588 error: error__.unwrap_or_default(),
3589 })
3590 }
3591 }
3592 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3593 }
3594}
3595impl serde::Serialize for event_log::EventInjectBarrierFail {
3596 #[allow(deprecated)]
3597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3598 where
3599 S: serde::Serializer,
3600 {
3601 use serde::ser::SerializeStruct;
3602 let mut len = 0;
3603 if self.prev_epoch != 0 {
3604 len += 1;
3605 }
3606 if self.cur_epoch != 0 {
3607 len += 1;
3608 }
3609 if !self.error.is_empty() {
3610 len += 1;
3611 }
3612 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3613 if self.prev_epoch != 0 {
3614 #[allow(clippy::needless_borrow)]
3615 #[allow(clippy::needless_borrows_for_generic_args)]
3616 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3617 }
3618 if self.cur_epoch != 0 {
3619 #[allow(clippy::needless_borrow)]
3620 #[allow(clippy::needless_borrows_for_generic_args)]
3621 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3622 }
3623 if !self.error.is_empty() {
3624 struct_ser.serialize_field("error", &self.error)?;
3625 }
3626 struct_ser.end()
3627 }
3628}
3629impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3630 #[allow(deprecated)]
3631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3632 where
3633 D: serde::Deserializer<'de>,
3634 {
3635 const FIELDS: &[&str] = &[
3636 "prev_epoch",
3637 "prevEpoch",
3638 "cur_epoch",
3639 "curEpoch",
3640 "error",
3641 ];
3642
3643 #[allow(clippy::enum_variant_names)]
3644 enum GeneratedField {
3645 PrevEpoch,
3646 CurEpoch,
3647 Error,
3648 }
3649 impl<'de> serde::Deserialize<'de> for GeneratedField {
3650 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3651 where
3652 D: serde::Deserializer<'de>,
3653 {
3654 struct GeneratedVisitor;
3655
3656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3657 type Value = GeneratedField;
3658
3659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3660 write!(formatter, "expected one of: {:?}", &FIELDS)
3661 }
3662
3663 #[allow(unused_variables)]
3664 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3665 where
3666 E: serde::de::Error,
3667 {
3668 match value {
3669 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3670 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3671 "error" => Ok(GeneratedField::Error),
3672 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3673 }
3674 }
3675 }
3676 deserializer.deserialize_identifier(GeneratedVisitor)
3677 }
3678 }
3679 struct GeneratedVisitor;
3680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3681 type Value = event_log::EventInjectBarrierFail;
3682
3683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3684 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3685 }
3686
3687 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3688 where
3689 V: serde::de::MapAccess<'de>,
3690 {
3691 let mut prev_epoch__ = None;
3692 let mut cur_epoch__ = None;
3693 let mut error__ = None;
3694 while let Some(k) = map_.next_key()? {
3695 match k {
3696 GeneratedField::PrevEpoch => {
3697 if prev_epoch__.is_some() {
3698 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3699 }
3700 prev_epoch__ =
3701 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3702 ;
3703 }
3704 GeneratedField::CurEpoch => {
3705 if cur_epoch__.is_some() {
3706 return Err(serde::de::Error::duplicate_field("curEpoch"));
3707 }
3708 cur_epoch__ =
3709 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3710 ;
3711 }
3712 GeneratedField::Error => {
3713 if error__.is_some() {
3714 return Err(serde::de::Error::duplicate_field("error"));
3715 }
3716 error__ = Some(map_.next_value()?);
3717 }
3718 }
3719 }
3720 Ok(event_log::EventInjectBarrierFail {
3721 prev_epoch: prev_epoch__.unwrap_or_default(),
3722 cur_epoch: cur_epoch__.unwrap_or_default(),
3723 error: error__.unwrap_or_default(),
3724 })
3725 }
3726 }
3727 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3728 }
3729}
3730impl serde::Serialize for event_log::EventMetaNodeStart {
3731 #[allow(deprecated)]
3732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3733 where
3734 S: serde::Serializer,
3735 {
3736 use serde::ser::SerializeStruct;
3737 let mut len = 0;
3738 if !self.advertise_addr.is_empty() {
3739 len += 1;
3740 }
3741 if !self.listen_addr.is_empty() {
3742 len += 1;
3743 }
3744 if !self.opts.is_empty() {
3745 len += 1;
3746 }
3747 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3748 if !self.advertise_addr.is_empty() {
3749 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3750 }
3751 if !self.listen_addr.is_empty() {
3752 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3753 }
3754 if !self.opts.is_empty() {
3755 struct_ser.serialize_field("opts", &self.opts)?;
3756 }
3757 struct_ser.end()
3758 }
3759}
3760impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3761 #[allow(deprecated)]
3762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3763 where
3764 D: serde::Deserializer<'de>,
3765 {
3766 const FIELDS: &[&str] = &[
3767 "advertise_addr",
3768 "advertiseAddr",
3769 "listen_addr",
3770 "listenAddr",
3771 "opts",
3772 ];
3773
3774 #[allow(clippy::enum_variant_names)]
3775 enum GeneratedField {
3776 AdvertiseAddr,
3777 ListenAddr,
3778 Opts,
3779 }
3780 impl<'de> serde::Deserialize<'de> for GeneratedField {
3781 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3782 where
3783 D: serde::Deserializer<'de>,
3784 {
3785 struct GeneratedVisitor;
3786
3787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3788 type Value = GeneratedField;
3789
3790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3791 write!(formatter, "expected one of: {:?}", &FIELDS)
3792 }
3793
3794 #[allow(unused_variables)]
3795 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3796 where
3797 E: serde::de::Error,
3798 {
3799 match value {
3800 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3801 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3802 "opts" => Ok(GeneratedField::Opts),
3803 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3804 }
3805 }
3806 }
3807 deserializer.deserialize_identifier(GeneratedVisitor)
3808 }
3809 }
3810 struct GeneratedVisitor;
3811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3812 type Value = event_log::EventMetaNodeStart;
3813
3814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3815 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3816 }
3817
3818 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3819 where
3820 V: serde::de::MapAccess<'de>,
3821 {
3822 let mut advertise_addr__ = None;
3823 let mut listen_addr__ = None;
3824 let mut opts__ = None;
3825 while let Some(k) = map_.next_key()? {
3826 match k {
3827 GeneratedField::AdvertiseAddr => {
3828 if advertise_addr__.is_some() {
3829 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3830 }
3831 advertise_addr__ = Some(map_.next_value()?);
3832 }
3833 GeneratedField::ListenAddr => {
3834 if listen_addr__.is_some() {
3835 return Err(serde::de::Error::duplicate_field("listenAddr"));
3836 }
3837 listen_addr__ = Some(map_.next_value()?);
3838 }
3839 GeneratedField::Opts => {
3840 if opts__.is_some() {
3841 return Err(serde::de::Error::duplicate_field("opts"));
3842 }
3843 opts__ = Some(map_.next_value()?);
3844 }
3845 }
3846 }
3847 Ok(event_log::EventMetaNodeStart {
3848 advertise_addr: advertise_addr__.unwrap_or_default(),
3849 listen_addr: listen_addr__.unwrap_or_default(),
3850 opts: opts__.unwrap_or_default(),
3851 })
3852 }
3853 }
3854 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3855 }
3856}
3857impl serde::Serialize for event_log::EventRecovery {
3858 #[allow(deprecated)]
3859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3860 where
3861 S: serde::Serializer,
3862 {
3863 use serde::ser::SerializeStruct;
3864 let mut len = 0;
3865 if self.recovery_event.is_some() {
3866 len += 1;
3867 }
3868 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3869 if let Some(v) = self.recovery_event.as_ref() {
3870 match v {
3871 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3872 struct_ser.serialize_field("globalStart", v)?;
3873 }
3874 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3875 struct_ser.serialize_field("globalSuccess", v)?;
3876 }
3877 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3878 struct_ser.serialize_field("globalFailure", v)?;
3879 }
3880 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3881 struct_ser.serialize_field("databaseStart", v)?;
3882 }
3883 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3884 struct_ser.serialize_field("databaseFailure", v)?;
3885 }
3886 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3887 struct_ser.serialize_field("databaseSuccess", v)?;
3888 }
3889 }
3890 }
3891 struct_ser.end()
3892 }
3893}
3894impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3895 #[allow(deprecated)]
3896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3897 where
3898 D: serde::Deserializer<'de>,
3899 {
3900 const FIELDS: &[&str] = &[
3901 "global_start",
3902 "globalStart",
3903 "global_success",
3904 "globalSuccess",
3905 "global_failure",
3906 "globalFailure",
3907 "database_start",
3908 "databaseStart",
3909 "database_failure",
3910 "databaseFailure",
3911 "database_success",
3912 "databaseSuccess",
3913 ];
3914
3915 #[allow(clippy::enum_variant_names)]
3916 enum GeneratedField {
3917 GlobalStart,
3918 GlobalSuccess,
3919 GlobalFailure,
3920 DatabaseStart,
3921 DatabaseFailure,
3922 DatabaseSuccess,
3923 }
3924 impl<'de> serde::Deserialize<'de> for GeneratedField {
3925 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3926 where
3927 D: serde::Deserializer<'de>,
3928 {
3929 struct GeneratedVisitor;
3930
3931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3932 type Value = GeneratedField;
3933
3934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3935 write!(formatter, "expected one of: {:?}", &FIELDS)
3936 }
3937
3938 #[allow(unused_variables)]
3939 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3940 where
3941 E: serde::de::Error,
3942 {
3943 match value {
3944 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3945 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3946 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3947 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3948 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3949 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3950 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3951 }
3952 }
3953 }
3954 deserializer.deserialize_identifier(GeneratedVisitor)
3955 }
3956 }
3957 struct GeneratedVisitor;
3958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3959 type Value = event_log::EventRecovery;
3960
3961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3962 formatter.write_str("struct meta.EventLog.EventRecovery")
3963 }
3964
3965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3966 where
3967 V: serde::de::MapAccess<'de>,
3968 {
3969 let mut recovery_event__ = None;
3970 while let Some(k) = map_.next_key()? {
3971 match k {
3972 GeneratedField::GlobalStart => {
3973 if recovery_event__.is_some() {
3974 return Err(serde::de::Error::duplicate_field("globalStart"));
3975 }
3976 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3977;
3978 }
3979 GeneratedField::GlobalSuccess => {
3980 if recovery_event__.is_some() {
3981 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3982 }
3983 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3984;
3985 }
3986 GeneratedField::GlobalFailure => {
3987 if recovery_event__.is_some() {
3988 return Err(serde::de::Error::duplicate_field("globalFailure"));
3989 }
3990 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3991;
3992 }
3993 GeneratedField::DatabaseStart => {
3994 if recovery_event__.is_some() {
3995 return Err(serde::de::Error::duplicate_field("databaseStart"));
3996 }
3997 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3998;
3999 }
4000 GeneratedField::DatabaseFailure => {
4001 if recovery_event__.is_some() {
4002 return Err(serde::de::Error::duplicate_field("databaseFailure"));
4003 }
4004 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4005;
4006 }
4007 GeneratedField::DatabaseSuccess => {
4008 if recovery_event__.is_some() {
4009 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4010 }
4011 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4012;
4013 }
4014 }
4015 }
4016 Ok(event_log::EventRecovery {
4017 recovery_event: recovery_event__,
4018 })
4019 }
4020 }
4021 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4022 }
4023}
4024impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4025 #[allow(deprecated)]
4026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4027 where
4028 S: serde::Serializer,
4029 {
4030 use serde::ser::SerializeStruct;
4031 let mut len = 0;
4032 if self.database_id != 0 {
4033 len += 1;
4034 }
4035 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4036 if self.database_id != 0 {
4037 struct_ser.serialize_field("databaseId", &self.database_id)?;
4038 }
4039 struct_ser.end()
4040 }
4041}
4042impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4043 #[allow(deprecated)]
4044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4045 where
4046 D: serde::Deserializer<'de>,
4047 {
4048 const FIELDS: &[&str] = &[
4049 "database_id",
4050 "databaseId",
4051 ];
4052
4053 #[allow(clippy::enum_variant_names)]
4054 enum GeneratedField {
4055 DatabaseId,
4056 }
4057 impl<'de> serde::Deserialize<'de> for GeneratedField {
4058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4059 where
4060 D: serde::Deserializer<'de>,
4061 {
4062 struct GeneratedVisitor;
4063
4064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4065 type Value = GeneratedField;
4066
4067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4068 write!(formatter, "expected one of: {:?}", &FIELDS)
4069 }
4070
4071 #[allow(unused_variables)]
4072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4073 where
4074 E: serde::de::Error,
4075 {
4076 match value {
4077 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4078 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4079 }
4080 }
4081 }
4082 deserializer.deserialize_identifier(GeneratedVisitor)
4083 }
4084 }
4085 struct GeneratedVisitor;
4086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4087 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4088
4089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4090 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4091 }
4092
4093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4094 where
4095 V: serde::de::MapAccess<'de>,
4096 {
4097 let mut database_id__ = None;
4098 while let Some(k) = map_.next_key()? {
4099 match k {
4100 GeneratedField::DatabaseId => {
4101 if database_id__.is_some() {
4102 return Err(serde::de::Error::duplicate_field("databaseId"));
4103 }
4104 database_id__ =
4105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4106 ;
4107 }
4108 }
4109 }
4110 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4111 database_id: database_id__.unwrap_or_default(),
4112 })
4113 }
4114 }
4115 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4116 }
4117}
4118impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4119 #[allow(deprecated)]
4120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4121 where
4122 S: serde::Serializer,
4123 {
4124 use serde::ser::SerializeStruct;
4125 let mut len = 0;
4126 if self.database_id != 0 {
4127 len += 1;
4128 }
4129 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4130 if self.database_id != 0 {
4131 struct_ser.serialize_field("databaseId", &self.database_id)?;
4132 }
4133 struct_ser.end()
4134 }
4135}
4136impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4137 #[allow(deprecated)]
4138 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4139 where
4140 D: serde::Deserializer<'de>,
4141 {
4142 const FIELDS: &[&str] = &[
4143 "database_id",
4144 "databaseId",
4145 ];
4146
4147 #[allow(clippy::enum_variant_names)]
4148 enum GeneratedField {
4149 DatabaseId,
4150 }
4151 impl<'de> serde::Deserialize<'de> for GeneratedField {
4152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4153 where
4154 D: serde::Deserializer<'de>,
4155 {
4156 struct GeneratedVisitor;
4157
4158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4159 type Value = GeneratedField;
4160
4161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4162 write!(formatter, "expected one of: {:?}", &FIELDS)
4163 }
4164
4165 #[allow(unused_variables)]
4166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4167 where
4168 E: serde::de::Error,
4169 {
4170 match value {
4171 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4172 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4173 }
4174 }
4175 }
4176 deserializer.deserialize_identifier(GeneratedVisitor)
4177 }
4178 }
4179 struct GeneratedVisitor;
4180 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4181 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4182
4183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4184 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4185 }
4186
4187 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4188 where
4189 V: serde::de::MapAccess<'de>,
4190 {
4191 let mut database_id__ = None;
4192 while let Some(k) = map_.next_key()? {
4193 match k {
4194 GeneratedField::DatabaseId => {
4195 if database_id__.is_some() {
4196 return Err(serde::de::Error::duplicate_field("databaseId"));
4197 }
4198 database_id__ =
4199 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4200 ;
4201 }
4202 }
4203 }
4204 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4205 database_id: database_id__.unwrap_or_default(),
4206 })
4207 }
4208 }
4209 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4210 }
4211}
4212impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4213 #[allow(deprecated)]
4214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4215 where
4216 S: serde::Serializer,
4217 {
4218 use serde::ser::SerializeStruct;
4219 let mut len = 0;
4220 if self.database_id != 0 {
4221 len += 1;
4222 }
4223 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4224 if self.database_id != 0 {
4225 struct_ser.serialize_field("databaseId", &self.database_id)?;
4226 }
4227 struct_ser.end()
4228 }
4229}
4230impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4231 #[allow(deprecated)]
4232 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4233 where
4234 D: serde::Deserializer<'de>,
4235 {
4236 const FIELDS: &[&str] = &[
4237 "database_id",
4238 "databaseId",
4239 ];
4240
4241 #[allow(clippy::enum_variant_names)]
4242 enum GeneratedField {
4243 DatabaseId,
4244 }
4245 impl<'de> serde::Deserialize<'de> for GeneratedField {
4246 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4247 where
4248 D: serde::Deserializer<'de>,
4249 {
4250 struct GeneratedVisitor;
4251
4252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4253 type Value = GeneratedField;
4254
4255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4256 write!(formatter, "expected one of: {:?}", &FIELDS)
4257 }
4258
4259 #[allow(unused_variables)]
4260 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4261 where
4262 E: serde::de::Error,
4263 {
4264 match value {
4265 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4266 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4267 }
4268 }
4269 }
4270 deserializer.deserialize_identifier(GeneratedVisitor)
4271 }
4272 }
4273 struct GeneratedVisitor;
4274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4275 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4276
4277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4278 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4279 }
4280
4281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4282 where
4283 V: serde::de::MapAccess<'de>,
4284 {
4285 let mut database_id__ = None;
4286 while let Some(k) = map_.next_key()? {
4287 match k {
4288 GeneratedField::DatabaseId => {
4289 if database_id__.is_some() {
4290 return Err(serde::de::Error::duplicate_field("databaseId"));
4291 }
4292 database_id__ =
4293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4294 ;
4295 }
4296 }
4297 }
4298 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4299 database_id: database_id__.unwrap_or_default(),
4300 })
4301 }
4302 }
4303 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4304 }
4305}
4306impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4307 #[allow(deprecated)]
4308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4309 where
4310 S: serde::Serializer,
4311 {
4312 use serde::ser::SerializeStruct;
4313 let mut len = 0;
4314 if !self.reason.is_empty() {
4315 len += 1;
4316 }
4317 if !self.error.is_empty() {
4318 len += 1;
4319 }
4320 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4321 if !self.reason.is_empty() {
4322 struct_ser.serialize_field("reason", &self.reason)?;
4323 }
4324 if !self.error.is_empty() {
4325 struct_ser.serialize_field("error", &self.error)?;
4326 }
4327 struct_ser.end()
4328 }
4329}
4330impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4331 #[allow(deprecated)]
4332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4333 where
4334 D: serde::Deserializer<'de>,
4335 {
4336 const FIELDS: &[&str] = &[
4337 "reason",
4338 "error",
4339 ];
4340
4341 #[allow(clippy::enum_variant_names)]
4342 enum GeneratedField {
4343 Reason,
4344 Error,
4345 }
4346 impl<'de> serde::Deserialize<'de> for GeneratedField {
4347 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4348 where
4349 D: serde::Deserializer<'de>,
4350 {
4351 struct GeneratedVisitor;
4352
4353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4354 type Value = GeneratedField;
4355
4356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4357 write!(formatter, "expected one of: {:?}", &FIELDS)
4358 }
4359
4360 #[allow(unused_variables)]
4361 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4362 where
4363 E: serde::de::Error,
4364 {
4365 match value {
4366 "reason" => Ok(GeneratedField::Reason),
4367 "error" => Ok(GeneratedField::Error),
4368 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4369 }
4370 }
4371 }
4372 deserializer.deserialize_identifier(GeneratedVisitor)
4373 }
4374 }
4375 struct GeneratedVisitor;
4376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4377 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4378
4379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4380 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4381 }
4382
4383 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4384 where
4385 V: serde::de::MapAccess<'de>,
4386 {
4387 let mut reason__ = None;
4388 let mut error__ = None;
4389 while let Some(k) = map_.next_key()? {
4390 match k {
4391 GeneratedField::Reason => {
4392 if reason__.is_some() {
4393 return Err(serde::de::Error::duplicate_field("reason"));
4394 }
4395 reason__ = Some(map_.next_value()?);
4396 }
4397 GeneratedField::Error => {
4398 if error__.is_some() {
4399 return Err(serde::de::Error::duplicate_field("error"));
4400 }
4401 error__ = Some(map_.next_value()?);
4402 }
4403 }
4404 }
4405 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4406 reason: reason__.unwrap_or_default(),
4407 error: error__.unwrap_or_default(),
4408 })
4409 }
4410 }
4411 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4412 }
4413}
4414impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4415 #[allow(deprecated)]
4416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4417 where
4418 S: serde::Serializer,
4419 {
4420 use serde::ser::SerializeStruct;
4421 let mut len = 0;
4422 if !self.reason.is_empty() {
4423 len += 1;
4424 }
4425 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4426 if !self.reason.is_empty() {
4427 struct_ser.serialize_field("reason", &self.reason)?;
4428 }
4429 struct_ser.end()
4430 }
4431}
4432impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4433 #[allow(deprecated)]
4434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4435 where
4436 D: serde::Deserializer<'de>,
4437 {
4438 const FIELDS: &[&str] = &[
4439 "reason",
4440 ];
4441
4442 #[allow(clippy::enum_variant_names)]
4443 enum GeneratedField {
4444 Reason,
4445 }
4446 impl<'de> serde::Deserialize<'de> for GeneratedField {
4447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4448 where
4449 D: serde::Deserializer<'de>,
4450 {
4451 struct GeneratedVisitor;
4452
4453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4454 type Value = GeneratedField;
4455
4456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4457 write!(formatter, "expected one of: {:?}", &FIELDS)
4458 }
4459
4460 #[allow(unused_variables)]
4461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4462 where
4463 E: serde::de::Error,
4464 {
4465 match value {
4466 "reason" => Ok(GeneratedField::Reason),
4467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4468 }
4469 }
4470 }
4471 deserializer.deserialize_identifier(GeneratedVisitor)
4472 }
4473 }
4474 struct GeneratedVisitor;
4475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4476 type Value = event_log::event_recovery::GlobalRecoveryStart;
4477
4478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4479 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4480 }
4481
4482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4483 where
4484 V: serde::de::MapAccess<'de>,
4485 {
4486 let mut reason__ = None;
4487 while let Some(k) = map_.next_key()? {
4488 match k {
4489 GeneratedField::Reason => {
4490 if reason__.is_some() {
4491 return Err(serde::de::Error::duplicate_field("reason"));
4492 }
4493 reason__ = Some(map_.next_value()?);
4494 }
4495 }
4496 }
4497 Ok(event_log::event_recovery::GlobalRecoveryStart {
4498 reason: reason__.unwrap_or_default(),
4499 })
4500 }
4501 }
4502 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4503 }
4504}
4505impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4506 #[allow(deprecated)]
4507 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4508 where
4509 S: serde::Serializer,
4510 {
4511 use serde::ser::SerializeStruct;
4512 let mut len = 0;
4513 if !self.reason.is_empty() {
4514 len += 1;
4515 }
4516 if self.duration_secs != 0. {
4517 len += 1;
4518 }
4519 if !self.running_database_ids.is_empty() {
4520 len += 1;
4521 }
4522 if !self.recovering_database_ids.is_empty() {
4523 len += 1;
4524 }
4525 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4526 if !self.reason.is_empty() {
4527 struct_ser.serialize_field("reason", &self.reason)?;
4528 }
4529 if self.duration_secs != 0. {
4530 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4531 }
4532 if !self.running_database_ids.is_empty() {
4533 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4534 }
4535 if !self.recovering_database_ids.is_empty() {
4536 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4537 }
4538 struct_ser.end()
4539 }
4540}
4541impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4542 #[allow(deprecated)]
4543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4544 where
4545 D: serde::Deserializer<'de>,
4546 {
4547 const FIELDS: &[&str] = &[
4548 "reason",
4549 "duration_secs",
4550 "durationSecs",
4551 "running_database_ids",
4552 "runningDatabaseIds",
4553 "recovering_database_ids",
4554 "recoveringDatabaseIds",
4555 ];
4556
4557 #[allow(clippy::enum_variant_names)]
4558 enum GeneratedField {
4559 Reason,
4560 DurationSecs,
4561 RunningDatabaseIds,
4562 RecoveringDatabaseIds,
4563 }
4564 impl<'de> serde::Deserialize<'de> for GeneratedField {
4565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4566 where
4567 D: serde::Deserializer<'de>,
4568 {
4569 struct GeneratedVisitor;
4570
4571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4572 type Value = GeneratedField;
4573
4574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4575 write!(formatter, "expected one of: {:?}", &FIELDS)
4576 }
4577
4578 #[allow(unused_variables)]
4579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4580 where
4581 E: serde::de::Error,
4582 {
4583 match value {
4584 "reason" => Ok(GeneratedField::Reason),
4585 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4586 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4587 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4588 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4589 }
4590 }
4591 }
4592 deserializer.deserialize_identifier(GeneratedVisitor)
4593 }
4594 }
4595 struct GeneratedVisitor;
4596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4597 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4598
4599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4601 }
4602
4603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4604 where
4605 V: serde::de::MapAccess<'de>,
4606 {
4607 let mut reason__ = None;
4608 let mut duration_secs__ = None;
4609 let mut running_database_ids__ = None;
4610 let mut recovering_database_ids__ = None;
4611 while let Some(k) = map_.next_key()? {
4612 match k {
4613 GeneratedField::Reason => {
4614 if reason__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("reason"));
4616 }
4617 reason__ = Some(map_.next_value()?);
4618 }
4619 GeneratedField::DurationSecs => {
4620 if duration_secs__.is_some() {
4621 return Err(serde::de::Error::duplicate_field("durationSecs"));
4622 }
4623 duration_secs__ =
4624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4625 ;
4626 }
4627 GeneratedField::RunningDatabaseIds => {
4628 if running_database_ids__.is_some() {
4629 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4630 }
4631 running_database_ids__ =
4632 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4633 .into_iter().map(|x| x.0).collect())
4634 ;
4635 }
4636 GeneratedField::RecoveringDatabaseIds => {
4637 if recovering_database_ids__.is_some() {
4638 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4639 }
4640 recovering_database_ids__ =
4641 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4642 .into_iter().map(|x| x.0).collect())
4643 ;
4644 }
4645 }
4646 }
4647 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4648 reason: reason__.unwrap_or_default(),
4649 duration_secs: duration_secs__.unwrap_or_default(),
4650 running_database_ids: running_database_ids__.unwrap_or_default(),
4651 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4652 })
4653 }
4654 }
4655 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4656 }
4657}
4658impl serde::Serialize for event_log::EventSinkFail {
4659 #[allow(deprecated)]
4660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4661 where
4662 S: serde::Serializer,
4663 {
4664 use serde::ser::SerializeStruct;
4665 let mut len = 0;
4666 if self.sink_id != 0 {
4667 len += 1;
4668 }
4669 if !self.sink_name.is_empty() {
4670 len += 1;
4671 }
4672 if !self.connector.is_empty() {
4673 len += 1;
4674 }
4675 if !self.error.is_empty() {
4676 len += 1;
4677 }
4678 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4679 if self.sink_id != 0 {
4680 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4681 }
4682 if !self.sink_name.is_empty() {
4683 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4684 }
4685 if !self.connector.is_empty() {
4686 struct_ser.serialize_field("connector", &self.connector)?;
4687 }
4688 if !self.error.is_empty() {
4689 struct_ser.serialize_field("error", &self.error)?;
4690 }
4691 struct_ser.end()
4692 }
4693}
4694impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4695 #[allow(deprecated)]
4696 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4697 where
4698 D: serde::Deserializer<'de>,
4699 {
4700 const FIELDS: &[&str] = &[
4701 "sink_id",
4702 "sinkId",
4703 "sink_name",
4704 "sinkName",
4705 "connector",
4706 "error",
4707 ];
4708
4709 #[allow(clippy::enum_variant_names)]
4710 enum GeneratedField {
4711 SinkId,
4712 SinkName,
4713 Connector,
4714 Error,
4715 }
4716 impl<'de> serde::Deserialize<'de> for GeneratedField {
4717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4718 where
4719 D: serde::Deserializer<'de>,
4720 {
4721 struct GeneratedVisitor;
4722
4723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4724 type Value = GeneratedField;
4725
4726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4727 write!(formatter, "expected one of: {:?}", &FIELDS)
4728 }
4729
4730 #[allow(unused_variables)]
4731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4732 where
4733 E: serde::de::Error,
4734 {
4735 match value {
4736 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4737 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4738 "connector" => Ok(GeneratedField::Connector),
4739 "error" => Ok(GeneratedField::Error),
4740 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4741 }
4742 }
4743 }
4744 deserializer.deserialize_identifier(GeneratedVisitor)
4745 }
4746 }
4747 struct GeneratedVisitor;
4748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4749 type Value = event_log::EventSinkFail;
4750
4751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4752 formatter.write_str("struct meta.EventLog.EventSinkFail")
4753 }
4754
4755 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4756 where
4757 V: serde::de::MapAccess<'de>,
4758 {
4759 let mut sink_id__ = None;
4760 let mut sink_name__ = None;
4761 let mut connector__ = None;
4762 let mut error__ = None;
4763 while let Some(k) = map_.next_key()? {
4764 match k {
4765 GeneratedField::SinkId => {
4766 if sink_id__.is_some() {
4767 return Err(serde::de::Error::duplicate_field("sinkId"));
4768 }
4769 sink_id__ =
4770 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4771 ;
4772 }
4773 GeneratedField::SinkName => {
4774 if sink_name__.is_some() {
4775 return Err(serde::de::Error::duplicate_field("sinkName"));
4776 }
4777 sink_name__ = Some(map_.next_value()?);
4778 }
4779 GeneratedField::Connector => {
4780 if connector__.is_some() {
4781 return Err(serde::de::Error::duplicate_field("connector"));
4782 }
4783 connector__ = Some(map_.next_value()?);
4784 }
4785 GeneratedField::Error => {
4786 if error__.is_some() {
4787 return Err(serde::de::Error::duplicate_field("error"));
4788 }
4789 error__ = Some(map_.next_value()?);
4790 }
4791 }
4792 }
4793 Ok(event_log::EventSinkFail {
4794 sink_id: sink_id__.unwrap_or_default(),
4795 sink_name: sink_name__.unwrap_or_default(),
4796 connector: connector__.unwrap_or_default(),
4797 error: error__.unwrap_or_default(),
4798 })
4799 }
4800 }
4801 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4802 }
4803}
4804impl serde::Serialize for event_log::EventWorkerNodePanic {
4805 #[allow(deprecated)]
4806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4807 where
4808 S: serde::Serializer,
4809 {
4810 use serde::ser::SerializeStruct;
4811 let mut len = 0;
4812 if self.worker_id != 0 {
4813 len += 1;
4814 }
4815 if self.worker_type != 0 {
4816 len += 1;
4817 }
4818 if self.host_addr.is_some() {
4819 len += 1;
4820 }
4821 if !self.panic_info.is_empty() {
4822 len += 1;
4823 }
4824 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4825 if self.worker_id != 0 {
4826 struct_ser.serialize_field("workerId", &self.worker_id)?;
4827 }
4828 if self.worker_type != 0 {
4829 let v = super::common::WorkerType::try_from(self.worker_type)
4830 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4831 struct_ser.serialize_field("workerType", &v)?;
4832 }
4833 if let Some(v) = self.host_addr.as_ref() {
4834 struct_ser.serialize_field("hostAddr", v)?;
4835 }
4836 if !self.panic_info.is_empty() {
4837 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4838 }
4839 struct_ser.end()
4840 }
4841}
4842impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4843 #[allow(deprecated)]
4844 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4845 where
4846 D: serde::Deserializer<'de>,
4847 {
4848 const FIELDS: &[&str] = &[
4849 "worker_id",
4850 "workerId",
4851 "worker_type",
4852 "workerType",
4853 "host_addr",
4854 "hostAddr",
4855 "panic_info",
4856 "panicInfo",
4857 ];
4858
4859 #[allow(clippy::enum_variant_names)]
4860 enum GeneratedField {
4861 WorkerId,
4862 WorkerType,
4863 HostAddr,
4864 PanicInfo,
4865 }
4866 impl<'de> serde::Deserialize<'de> for GeneratedField {
4867 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4868 where
4869 D: serde::Deserializer<'de>,
4870 {
4871 struct GeneratedVisitor;
4872
4873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4874 type Value = GeneratedField;
4875
4876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4877 write!(formatter, "expected one of: {:?}", &FIELDS)
4878 }
4879
4880 #[allow(unused_variables)]
4881 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4882 where
4883 E: serde::de::Error,
4884 {
4885 match value {
4886 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4887 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4888 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4889 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4890 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4891 }
4892 }
4893 }
4894 deserializer.deserialize_identifier(GeneratedVisitor)
4895 }
4896 }
4897 struct GeneratedVisitor;
4898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4899 type Value = event_log::EventWorkerNodePanic;
4900
4901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4902 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4903 }
4904
4905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4906 where
4907 V: serde::de::MapAccess<'de>,
4908 {
4909 let mut worker_id__ = None;
4910 let mut worker_type__ = None;
4911 let mut host_addr__ = None;
4912 let mut panic_info__ = None;
4913 while let Some(k) = map_.next_key()? {
4914 match k {
4915 GeneratedField::WorkerId => {
4916 if worker_id__.is_some() {
4917 return Err(serde::de::Error::duplicate_field("workerId"));
4918 }
4919 worker_id__ =
4920 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4921 ;
4922 }
4923 GeneratedField::WorkerType => {
4924 if worker_type__.is_some() {
4925 return Err(serde::de::Error::duplicate_field("workerType"));
4926 }
4927 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4928 }
4929 GeneratedField::HostAddr => {
4930 if host_addr__.is_some() {
4931 return Err(serde::de::Error::duplicate_field("hostAddr"));
4932 }
4933 host_addr__ = map_.next_value()?;
4934 }
4935 GeneratedField::PanicInfo => {
4936 if panic_info__.is_some() {
4937 return Err(serde::de::Error::duplicate_field("panicInfo"));
4938 }
4939 panic_info__ = Some(map_.next_value()?);
4940 }
4941 }
4942 }
4943 Ok(event_log::EventWorkerNodePanic {
4944 worker_id: worker_id__.unwrap_or_default(),
4945 worker_type: worker_type__.unwrap_or_default(),
4946 host_addr: host_addr__,
4947 panic_info: panic_info__.unwrap_or_default(),
4948 })
4949 }
4950 }
4951 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4952 }
4953}
4954impl serde::Serialize for FlushRequest {
4955 #[allow(deprecated)]
4956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4957 where
4958 S: serde::Serializer,
4959 {
4960 use serde::ser::SerializeStruct;
4961 let mut len = 0;
4962 if self.database_id != 0 {
4963 len += 1;
4964 }
4965 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4966 if self.database_id != 0 {
4967 struct_ser.serialize_field("databaseId", &self.database_id)?;
4968 }
4969 struct_ser.end()
4970 }
4971}
4972impl<'de> serde::Deserialize<'de> for FlushRequest {
4973 #[allow(deprecated)]
4974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4975 where
4976 D: serde::Deserializer<'de>,
4977 {
4978 const FIELDS: &[&str] = &[
4979 "database_id",
4980 "databaseId",
4981 ];
4982
4983 #[allow(clippy::enum_variant_names)]
4984 enum GeneratedField {
4985 DatabaseId,
4986 }
4987 impl<'de> serde::Deserialize<'de> for GeneratedField {
4988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4989 where
4990 D: serde::Deserializer<'de>,
4991 {
4992 struct GeneratedVisitor;
4993
4994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4995 type Value = GeneratedField;
4996
4997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4998 write!(formatter, "expected one of: {:?}", &FIELDS)
4999 }
5000
5001 #[allow(unused_variables)]
5002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5003 where
5004 E: serde::de::Error,
5005 {
5006 match value {
5007 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5009 }
5010 }
5011 }
5012 deserializer.deserialize_identifier(GeneratedVisitor)
5013 }
5014 }
5015 struct GeneratedVisitor;
5016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5017 type Value = FlushRequest;
5018
5019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5020 formatter.write_str("struct meta.FlushRequest")
5021 }
5022
5023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5024 where
5025 V: serde::de::MapAccess<'de>,
5026 {
5027 let mut database_id__ = None;
5028 while let Some(k) = map_.next_key()? {
5029 match k {
5030 GeneratedField::DatabaseId => {
5031 if database_id__.is_some() {
5032 return Err(serde::de::Error::duplicate_field("databaseId"));
5033 }
5034 database_id__ =
5035 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5036 ;
5037 }
5038 }
5039 }
5040 Ok(FlushRequest {
5041 database_id: database_id__.unwrap_or_default(),
5042 })
5043 }
5044 }
5045 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5046 }
5047}
5048impl serde::Serialize for FlushResponse {
5049 #[allow(deprecated)]
5050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5051 where
5052 S: serde::Serializer,
5053 {
5054 use serde::ser::SerializeStruct;
5055 let mut len = 0;
5056 if self.status.is_some() {
5057 len += 1;
5058 }
5059 if self.hummock_version_id != 0 {
5060 len += 1;
5061 }
5062 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5063 if let Some(v) = self.status.as_ref() {
5064 struct_ser.serialize_field("status", v)?;
5065 }
5066 if self.hummock_version_id != 0 {
5067 #[allow(clippy::needless_borrow)]
5068 #[allow(clippy::needless_borrows_for_generic_args)]
5069 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5070 }
5071 struct_ser.end()
5072 }
5073}
5074impl<'de> serde::Deserialize<'de> for FlushResponse {
5075 #[allow(deprecated)]
5076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5077 where
5078 D: serde::Deserializer<'de>,
5079 {
5080 const FIELDS: &[&str] = &[
5081 "status",
5082 "hummock_version_id",
5083 "hummockVersionId",
5084 ];
5085
5086 #[allow(clippy::enum_variant_names)]
5087 enum GeneratedField {
5088 Status,
5089 HummockVersionId,
5090 }
5091 impl<'de> serde::Deserialize<'de> for GeneratedField {
5092 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5093 where
5094 D: serde::Deserializer<'de>,
5095 {
5096 struct GeneratedVisitor;
5097
5098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5099 type Value = GeneratedField;
5100
5101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5102 write!(formatter, "expected one of: {:?}", &FIELDS)
5103 }
5104
5105 #[allow(unused_variables)]
5106 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5107 where
5108 E: serde::de::Error,
5109 {
5110 match value {
5111 "status" => Ok(GeneratedField::Status),
5112 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5113 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5114 }
5115 }
5116 }
5117 deserializer.deserialize_identifier(GeneratedVisitor)
5118 }
5119 }
5120 struct GeneratedVisitor;
5121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5122 type Value = FlushResponse;
5123
5124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5125 formatter.write_str("struct meta.FlushResponse")
5126 }
5127
5128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5129 where
5130 V: serde::de::MapAccess<'de>,
5131 {
5132 let mut status__ = None;
5133 let mut hummock_version_id__ = None;
5134 while let Some(k) = map_.next_key()? {
5135 match k {
5136 GeneratedField::Status => {
5137 if status__.is_some() {
5138 return Err(serde::de::Error::duplicate_field("status"));
5139 }
5140 status__ = map_.next_value()?;
5141 }
5142 GeneratedField::HummockVersionId => {
5143 if hummock_version_id__.is_some() {
5144 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5145 }
5146 hummock_version_id__ =
5147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5148 ;
5149 }
5150 }
5151 }
5152 Ok(FlushResponse {
5153 status: status__,
5154 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5155 })
5156 }
5157 }
5158 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5159 }
5160}
5161impl serde::Serialize for FragmentDistribution {
5162 #[allow(deprecated)]
5163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5164 where
5165 S: serde::Serializer,
5166 {
5167 use serde::ser::SerializeStruct;
5168 let mut len = 0;
5169 if self.fragment_id != 0 {
5170 len += 1;
5171 }
5172 if self.table_id != 0 {
5173 len += 1;
5174 }
5175 if self.distribution_type != 0 {
5176 len += 1;
5177 }
5178 if !self.state_table_ids.is_empty() {
5179 len += 1;
5180 }
5181 if !self.upstream_fragment_ids.is_empty() {
5182 len += 1;
5183 }
5184 if self.fragment_type_mask != 0 {
5185 len += 1;
5186 }
5187 if self.parallelism != 0 {
5188 len += 1;
5189 }
5190 if self.vnode_count != 0 {
5191 len += 1;
5192 }
5193 if self.node.is_some() {
5194 len += 1;
5195 }
5196 if !self.parallelism_policy.is_empty() {
5197 len += 1;
5198 }
5199 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5200 if self.fragment_id != 0 {
5201 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5202 }
5203 if self.table_id != 0 {
5204 struct_ser.serialize_field("tableId", &self.table_id)?;
5205 }
5206 if self.distribution_type != 0 {
5207 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5208 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5209 struct_ser.serialize_field("distributionType", &v)?;
5210 }
5211 if !self.state_table_ids.is_empty() {
5212 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5213 }
5214 if !self.upstream_fragment_ids.is_empty() {
5215 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5216 }
5217 if self.fragment_type_mask != 0 {
5218 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5219 }
5220 if self.parallelism != 0 {
5221 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5222 }
5223 if self.vnode_count != 0 {
5224 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5225 }
5226 if let Some(v) = self.node.as_ref() {
5227 struct_ser.serialize_field("node", v)?;
5228 }
5229 if !self.parallelism_policy.is_empty() {
5230 struct_ser.serialize_field("parallelismPolicy", &self.parallelism_policy)?;
5231 }
5232 struct_ser.end()
5233 }
5234}
5235impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5236 #[allow(deprecated)]
5237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5238 where
5239 D: serde::Deserializer<'de>,
5240 {
5241 const FIELDS: &[&str] = &[
5242 "fragment_id",
5243 "fragmentId",
5244 "table_id",
5245 "tableId",
5246 "distribution_type",
5247 "distributionType",
5248 "state_table_ids",
5249 "stateTableIds",
5250 "upstream_fragment_ids",
5251 "upstreamFragmentIds",
5252 "fragment_type_mask",
5253 "fragmentTypeMask",
5254 "parallelism",
5255 "vnode_count",
5256 "vnodeCount",
5257 "node",
5258 "parallelism_policy",
5259 "parallelismPolicy",
5260 ];
5261
5262 #[allow(clippy::enum_variant_names)]
5263 enum GeneratedField {
5264 FragmentId,
5265 TableId,
5266 DistributionType,
5267 StateTableIds,
5268 UpstreamFragmentIds,
5269 FragmentTypeMask,
5270 Parallelism,
5271 VnodeCount,
5272 Node,
5273 ParallelismPolicy,
5274 }
5275 impl<'de> serde::Deserialize<'de> for GeneratedField {
5276 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5277 where
5278 D: serde::Deserializer<'de>,
5279 {
5280 struct GeneratedVisitor;
5281
5282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5283 type Value = GeneratedField;
5284
5285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5286 write!(formatter, "expected one of: {:?}", &FIELDS)
5287 }
5288
5289 #[allow(unused_variables)]
5290 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5291 where
5292 E: serde::de::Error,
5293 {
5294 match value {
5295 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5296 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5297 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5298 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5299 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5300 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5301 "parallelism" => Ok(GeneratedField::Parallelism),
5302 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5303 "node" => Ok(GeneratedField::Node),
5304 "parallelismPolicy" | "parallelism_policy" => Ok(GeneratedField::ParallelismPolicy),
5305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5306 }
5307 }
5308 }
5309 deserializer.deserialize_identifier(GeneratedVisitor)
5310 }
5311 }
5312 struct GeneratedVisitor;
5313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5314 type Value = FragmentDistribution;
5315
5316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5317 formatter.write_str("struct meta.FragmentDistribution")
5318 }
5319
5320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5321 where
5322 V: serde::de::MapAccess<'de>,
5323 {
5324 let mut fragment_id__ = None;
5325 let mut table_id__ = None;
5326 let mut distribution_type__ = None;
5327 let mut state_table_ids__ = None;
5328 let mut upstream_fragment_ids__ = None;
5329 let mut fragment_type_mask__ = None;
5330 let mut parallelism__ = None;
5331 let mut vnode_count__ = None;
5332 let mut node__ = None;
5333 let mut parallelism_policy__ = None;
5334 while let Some(k) = map_.next_key()? {
5335 match k {
5336 GeneratedField::FragmentId => {
5337 if fragment_id__.is_some() {
5338 return Err(serde::de::Error::duplicate_field("fragmentId"));
5339 }
5340 fragment_id__ =
5341 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5342 ;
5343 }
5344 GeneratedField::TableId => {
5345 if table_id__.is_some() {
5346 return Err(serde::de::Error::duplicate_field("tableId"));
5347 }
5348 table_id__ =
5349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5350 ;
5351 }
5352 GeneratedField::DistributionType => {
5353 if distribution_type__.is_some() {
5354 return Err(serde::de::Error::duplicate_field("distributionType"));
5355 }
5356 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5357 }
5358 GeneratedField::StateTableIds => {
5359 if state_table_ids__.is_some() {
5360 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5361 }
5362 state_table_ids__ =
5363 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5364 .into_iter().map(|x| x.0).collect())
5365 ;
5366 }
5367 GeneratedField::UpstreamFragmentIds => {
5368 if upstream_fragment_ids__.is_some() {
5369 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5370 }
5371 upstream_fragment_ids__ =
5372 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5373 .into_iter().map(|x| x.0).collect())
5374 ;
5375 }
5376 GeneratedField::FragmentTypeMask => {
5377 if fragment_type_mask__.is_some() {
5378 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5379 }
5380 fragment_type_mask__ =
5381 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5382 ;
5383 }
5384 GeneratedField::Parallelism => {
5385 if parallelism__.is_some() {
5386 return Err(serde::de::Error::duplicate_field("parallelism"));
5387 }
5388 parallelism__ =
5389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5390 ;
5391 }
5392 GeneratedField::VnodeCount => {
5393 if vnode_count__.is_some() {
5394 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5395 }
5396 vnode_count__ =
5397 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5398 ;
5399 }
5400 GeneratedField::Node => {
5401 if node__.is_some() {
5402 return Err(serde::de::Error::duplicate_field("node"));
5403 }
5404 node__ = map_.next_value()?;
5405 }
5406 GeneratedField::ParallelismPolicy => {
5407 if parallelism_policy__.is_some() {
5408 return Err(serde::de::Error::duplicate_field("parallelismPolicy"));
5409 }
5410 parallelism_policy__ = Some(map_.next_value()?);
5411 }
5412 }
5413 }
5414 Ok(FragmentDistribution {
5415 fragment_id: fragment_id__.unwrap_or_default(),
5416 table_id: table_id__.unwrap_or_default(),
5417 distribution_type: distribution_type__.unwrap_or_default(),
5418 state_table_ids: state_table_ids__.unwrap_or_default(),
5419 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5420 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5421 parallelism: parallelism__.unwrap_or_default(),
5422 vnode_count: vnode_count__.unwrap_or_default(),
5423 node: node__,
5424 parallelism_policy: parallelism_policy__.unwrap_or_default(),
5425 })
5426 }
5427 }
5428 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5429 }
5430}
5431impl serde::Serialize for FragmentIdToActorIdMap {
5432 #[allow(deprecated)]
5433 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5434 where
5435 S: serde::Serializer,
5436 {
5437 use serde::ser::SerializeStruct;
5438 let mut len = 0;
5439 if !self.map.is_empty() {
5440 len += 1;
5441 }
5442 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5443 if !self.map.is_empty() {
5444 struct_ser.serialize_field("map", &self.map)?;
5445 }
5446 struct_ser.end()
5447 }
5448}
5449impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5450 #[allow(deprecated)]
5451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5452 where
5453 D: serde::Deserializer<'de>,
5454 {
5455 const FIELDS: &[&str] = &[
5456 "map",
5457 ];
5458
5459 #[allow(clippy::enum_variant_names)]
5460 enum GeneratedField {
5461 Map,
5462 }
5463 impl<'de> serde::Deserialize<'de> for GeneratedField {
5464 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5465 where
5466 D: serde::Deserializer<'de>,
5467 {
5468 struct GeneratedVisitor;
5469
5470 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5471 type Value = GeneratedField;
5472
5473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5474 write!(formatter, "expected one of: {:?}", &FIELDS)
5475 }
5476
5477 #[allow(unused_variables)]
5478 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5479 where
5480 E: serde::de::Error,
5481 {
5482 match value {
5483 "map" => Ok(GeneratedField::Map),
5484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5485 }
5486 }
5487 }
5488 deserializer.deserialize_identifier(GeneratedVisitor)
5489 }
5490 }
5491 struct GeneratedVisitor;
5492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5493 type Value = FragmentIdToActorIdMap;
5494
5495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5496 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5497 }
5498
5499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5500 where
5501 V: serde::de::MapAccess<'de>,
5502 {
5503 let mut map__ = None;
5504 while let Some(k) = map_.next_key()? {
5505 match k {
5506 GeneratedField::Map => {
5507 if map__.is_some() {
5508 return Err(serde::de::Error::duplicate_field("map"));
5509 }
5510 map__ = Some(
5511 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5512 .into_iter().map(|(k,v)| (k.0, v)).collect()
5513 );
5514 }
5515 }
5516 }
5517 Ok(FragmentIdToActorIdMap {
5518 map: map__.unwrap_or_default(),
5519 })
5520 }
5521 }
5522 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5523 }
5524}
5525impl serde::Serialize for FragmentToRelationMap {
5526 #[allow(deprecated)]
5527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5528 where
5529 S: serde::Serializer,
5530 {
5531 use serde::ser::SerializeStruct;
5532 let mut len = 0;
5533 if !self.fragment_to_relation_map.is_empty() {
5534 len += 1;
5535 }
5536 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5537 if !self.fragment_to_relation_map.is_empty() {
5538 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5539 }
5540 struct_ser.end()
5541 }
5542}
5543impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5544 #[allow(deprecated)]
5545 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5546 where
5547 D: serde::Deserializer<'de>,
5548 {
5549 const FIELDS: &[&str] = &[
5550 "fragment_to_relation_map",
5551 "fragmentToRelationMap",
5552 ];
5553
5554 #[allow(clippy::enum_variant_names)]
5555 enum GeneratedField {
5556 FragmentToRelationMap,
5557 }
5558 impl<'de> serde::Deserialize<'de> for GeneratedField {
5559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5560 where
5561 D: serde::Deserializer<'de>,
5562 {
5563 struct GeneratedVisitor;
5564
5565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5566 type Value = GeneratedField;
5567
5568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5569 write!(formatter, "expected one of: {:?}", &FIELDS)
5570 }
5571
5572 #[allow(unused_variables)]
5573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5574 where
5575 E: serde::de::Error,
5576 {
5577 match value {
5578 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5579 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5580 }
5581 }
5582 }
5583 deserializer.deserialize_identifier(GeneratedVisitor)
5584 }
5585 }
5586 struct GeneratedVisitor;
5587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5588 type Value = FragmentToRelationMap;
5589
5590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5591 formatter.write_str("struct meta.FragmentToRelationMap")
5592 }
5593
5594 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5595 where
5596 V: serde::de::MapAccess<'de>,
5597 {
5598 let mut fragment_to_relation_map__ = None;
5599 while let Some(k) = map_.next_key()? {
5600 match k {
5601 GeneratedField::FragmentToRelationMap => {
5602 if fragment_to_relation_map__.is_some() {
5603 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5604 }
5605 fragment_to_relation_map__ = Some(
5606 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5607 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5608 );
5609 }
5610 }
5611 }
5612 Ok(FragmentToRelationMap {
5613 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5614 })
5615 }
5616 }
5617 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5618 }
5619}
5620impl serde::Serialize for FragmentWorkerSlotMapping {
5621 #[allow(deprecated)]
5622 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5623 where
5624 S: serde::Serializer,
5625 {
5626 use serde::ser::SerializeStruct;
5627 let mut len = 0;
5628 if self.fragment_id != 0 {
5629 len += 1;
5630 }
5631 if self.mapping.is_some() {
5632 len += 1;
5633 }
5634 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5635 if self.fragment_id != 0 {
5636 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5637 }
5638 if let Some(v) = self.mapping.as_ref() {
5639 struct_ser.serialize_field("mapping", v)?;
5640 }
5641 struct_ser.end()
5642 }
5643}
5644impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5645 #[allow(deprecated)]
5646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5647 where
5648 D: serde::Deserializer<'de>,
5649 {
5650 const FIELDS: &[&str] = &[
5651 "fragment_id",
5652 "fragmentId",
5653 "mapping",
5654 ];
5655
5656 #[allow(clippy::enum_variant_names)]
5657 enum GeneratedField {
5658 FragmentId,
5659 Mapping,
5660 }
5661 impl<'de> serde::Deserialize<'de> for GeneratedField {
5662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5663 where
5664 D: serde::Deserializer<'de>,
5665 {
5666 struct GeneratedVisitor;
5667
5668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5669 type Value = GeneratedField;
5670
5671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5672 write!(formatter, "expected one of: {:?}", &FIELDS)
5673 }
5674
5675 #[allow(unused_variables)]
5676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5677 where
5678 E: serde::de::Error,
5679 {
5680 match value {
5681 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5682 "mapping" => Ok(GeneratedField::Mapping),
5683 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5684 }
5685 }
5686 }
5687 deserializer.deserialize_identifier(GeneratedVisitor)
5688 }
5689 }
5690 struct GeneratedVisitor;
5691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5692 type Value = FragmentWorkerSlotMapping;
5693
5694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5695 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5696 }
5697
5698 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5699 where
5700 V: serde::de::MapAccess<'de>,
5701 {
5702 let mut fragment_id__ = None;
5703 let mut mapping__ = None;
5704 while let Some(k) = map_.next_key()? {
5705 match k {
5706 GeneratedField::FragmentId => {
5707 if fragment_id__.is_some() {
5708 return Err(serde::de::Error::duplicate_field("fragmentId"));
5709 }
5710 fragment_id__ =
5711 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5712 ;
5713 }
5714 GeneratedField::Mapping => {
5715 if mapping__.is_some() {
5716 return Err(serde::de::Error::duplicate_field("mapping"));
5717 }
5718 mapping__ = map_.next_value()?;
5719 }
5720 }
5721 }
5722 Ok(FragmentWorkerSlotMapping {
5723 fragment_id: fragment_id__.unwrap_or_default(),
5724 mapping: mapping__,
5725 })
5726 }
5727 }
5728 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5729 }
5730}
5731impl serde::Serialize for FragmentWorkerSlotMappings {
5732 #[allow(deprecated)]
5733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5734 where
5735 S: serde::Serializer,
5736 {
5737 use serde::ser::SerializeStruct;
5738 let mut len = 0;
5739 if !self.mappings.is_empty() {
5740 len += 1;
5741 }
5742 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5743 if !self.mappings.is_empty() {
5744 struct_ser.serialize_field("mappings", &self.mappings)?;
5745 }
5746 struct_ser.end()
5747 }
5748}
5749impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5750 #[allow(deprecated)]
5751 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5752 where
5753 D: serde::Deserializer<'de>,
5754 {
5755 const FIELDS: &[&str] = &[
5756 "mappings",
5757 ];
5758
5759 #[allow(clippy::enum_variant_names)]
5760 enum GeneratedField {
5761 Mappings,
5762 }
5763 impl<'de> serde::Deserialize<'de> for GeneratedField {
5764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5765 where
5766 D: serde::Deserializer<'de>,
5767 {
5768 struct GeneratedVisitor;
5769
5770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5771 type Value = GeneratedField;
5772
5773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5774 write!(formatter, "expected one of: {:?}", &FIELDS)
5775 }
5776
5777 #[allow(unused_variables)]
5778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5779 where
5780 E: serde::de::Error,
5781 {
5782 match value {
5783 "mappings" => Ok(GeneratedField::Mappings),
5784 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5785 }
5786 }
5787 }
5788 deserializer.deserialize_identifier(GeneratedVisitor)
5789 }
5790 }
5791 struct GeneratedVisitor;
5792 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5793 type Value = FragmentWorkerSlotMappings;
5794
5795 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5796 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5797 }
5798
5799 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5800 where
5801 V: serde::de::MapAccess<'de>,
5802 {
5803 let mut mappings__ = None;
5804 while let Some(k) = map_.next_key()? {
5805 match k {
5806 GeneratedField::Mappings => {
5807 if mappings__.is_some() {
5808 return Err(serde::de::Error::duplicate_field("mappings"));
5809 }
5810 mappings__ = Some(map_.next_value()?);
5811 }
5812 }
5813 }
5814 Ok(FragmentWorkerSlotMappings {
5815 mappings: mappings__.unwrap_or_default(),
5816 })
5817 }
5818 }
5819 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5820 }
5821}
5822impl serde::Serialize for GetClusterInfoRequest {
5823 #[allow(deprecated)]
5824 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5825 where
5826 S: serde::Serializer,
5827 {
5828 use serde::ser::SerializeStruct;
5829 let len = 0;
5830 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5831 struct_ser.end()
5832 }
5833}
5834impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5835 #[allow(deprecated)]
5836 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5837 where
5838 D: serde::Deserializer<'de>,
5839 {
5840 const FIELDS: &[&str] = &[
5841 ];
5842
5843 #[allow(clippy::enum_variant_names)]
5844 enum GeneratedField {
5845 }
5846 impl<'de> serde::Deserialize<'de> for GeneratedField {
5847 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5848 where
5849 D: serde::Deserializer<'de>,
5850 {
5851 struct GeneratedVisitor;
5852
5853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5854 type Value = GeneratedField;
5855
5856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5857 write!(formatter, "expected one of: {:?}", &FIELDS)
5858 }
5859
5860 #[allow(unused_variables)]
5861 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5862 where
5863 E: serde::de::Error,
5864 {
5865 Err(serde::de::Error::unknown_field(value, FIELDS))
5866 }
5867 }
5868 deserializer.deserialize_identifier(GeneratedVisitor)
5869 }
5870 }
5871 struct GeneratedVisitor;
5872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5873 type Value = GetClusterInfoRequest;
5874
5875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5876 formatter.write_str("struct meta.GetClusterInfoRequest")
5877 }
5878
5879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5880 where
5881 V: serde::de::MapAccess<'de>,
5882 {
5883 while map_.next_key::<GeneratedField>()?.is_some() {
5884 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5885 }
5886 Ok(GetClusterInfoRequest {
5887 })
5888 }
5889 }
5890 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5891 }
5892}
5893impl serde::Serialize for GetClusterInfoResponse {
5894 #[allow(deprecated)]
5895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5896 where
5897 S: serde::Serializer,
5898 {
5899 use serde::ser::SerializeStruct;
5900 let mut len = 0;
5901 if !self.worker_nodes.is_empty() {
5902 len += 1;
5903 }
5904 if !self.table_fragments.is_empty() {
5905 len += 1;
5906 }
5907 if !self.actor_splits.is_empty() {
5908 len += 1;
5909 }
5910 if !self.source_infos.is_empty() {
5911 len += 1;
5912 }
5913 if self.revision != 0 {
5914 len += 1;
5915 }
5916 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5917 if !self.worker_nodes.is_empty() {
5918 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5919 }
5920 if !self.table_fragments.is_empty() {
5921 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5922 }
5923 if !self.actor_splits.is_empty() {
5924 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5925 }
5926 if !self.source_infos.is_empty() {
5927 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5928 }
5929 if self.revision != 0 {
5930 #[allow(clippy::needless_borrow)]
5931 #[allow(clippy::needless_borrows_for_generic_args)]
5932 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5933 }
5934 struct_ser.end()
5935 }
5936}
5937impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5938 #[allow(deprecated)]
5939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5940 where
5941 D: serde::Deserializer<'de>,
5942 {
5943 const FIELDS: &[&str] = &[
5944 "worker_nodes",
5945 "workerNodes",
5946 "table_fragments",
5947 "tableFragments",
5948 "actor_splits",
5949 "actorSplits",
5950 "source_infos",
5951 "sourceInfos",
5952 "revision",
5953 ];
5954
5955 #[allow(clippy::enum_variant_names)]
5956 enum GeneratedField {
5957 WorkerNodes,
5958 TableFragments,
5959 ActorSplits,
5960 SourceInfos,
5961 Revision,
5962 }
5963 impl<'de> serde::Deserialize<'de> for GeneratedField {
5964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5965 where
5966 D: serde::Deserializer<'de>,
5967 {
5968 struct GeneratedVisitor;
5969
5970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5971 type Value = GeneratedField;
5972
5973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5974 write!(formatter, "expected one of: {:?}", &FIELDS)
5975 }
5976
5977 #[allow(unused_variables)]
5978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5979 where
5980 E: serde::de::Error,
5981 {
5982 match value {
5983 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5984 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5985 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5986 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5987 "revision" => Ok(GeneratedField::Revision),
5988 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5989 }
5990 }
5991 }
5992 deserializer.deserialize_identifier(GeneratedVisitor)
5993 }
5994 }
5995 struct GeneratedVisitor;
5996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5997 type Value = GetClusterInfoResponse;
5998
5999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6000 formatter.write_str("struct meta.GetClusterInfoResponse")
6001 }
6002
6003 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
6004 where
6005 V: serde::de::MapAccess<'de>,
6006 {
6007 let mut worker_nodes__ = None;
6008 let mut table_fragments__ = None;
6009 let mut actor_splits__ = None;
6010 let mut source_infos__ = None;
6011 let mut revision__ = None;
6012 while let Some(k) = map_.next_key()? {
6013 match k {
6014 GeneratedField::WorkerNodes => {
6015 if worker_nodes__.is_some() {
6016 return Err(serde::de::Error::duplicate_field("workerNodes"));
6017 }
6018 worker_nodes__ = Some(map_.next_value()?);
6019 }
6020 GeneratedField::TableFragments => {
6021 if table_fragments__.is_some() {
6022 return Err(serde::de::Error::duplicate_field("tableFragments"));
6023 }
6024 table_fragments__ = Some(map_.next_value()?);
6025 }
6026 GeneratedField::ActorSplits => {
6027 if actor_splits__.is_some() {
6028 return Err(serde::de::Error::duplicate_field("actorSplits"));
6029 }
6030 actor_splits__ = Some(
6031 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6032 .into_iter().map(|(k,v)| (k.0, v)).collect()
6033 );
6034 }
6035 GeneratedField::SourceInfos => {
6036 if source_infos__.is_some() {
6037 return Err(serde::de::Error::duplicate_field("sourceInfos"));
6038 }
6039 source_infos__ = Some(
6040 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6041 .into_iter().map(|(k,v)| (k.0, v)).collect()
6042 );
6043 }
6044 GeneratedField::Revision => {
6045 if revision__.is_some() {
6046 return Err(serde::de::Error::duplicate_field("revision"));
6047 }
6048 revision__ =
6049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6050 ;
6051 }
6052 }
6053 }
6054 Ok(GetClusterInfoResponse {
6055 worker_nodes: worker_nodes__.unwrap_or_default(),
6056 table_fragments: table_fragments__.unwrap_or_default(),
6057 actor_splits: actor_splits__.unwrap_or_default(),
6058 source_infos: source_infos__.unwrap_or_default(),
6059 revision: revision__.unwrap_or_default(),
6060 })
6061 }
6062 }
6063 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6064 }
6065}
6066impl serde::Serialize for GetClusterLimitsRequest {
6067 #[allow(deprecated)]
6068 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6069 where
6070 S: serde::Serializer,
6071 {
6072 use serde::ser::SerializeStruct;
6073 let len = 0;
6074 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6075 struct_ser.end()
6076 }
6077}
6078impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6079 #[allow(deprecated)]
6080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6081 where
6082 D: serde::Deserializer<'de>,
6083 {
6084 const FIELDS: &[&str] = &[
6085 ];
6086
6087 #[allow(clippy::enum_variant_names)]
6088 enum GeneratedField {
6089 }
6090 impl<'de> serde::Deserialize<'de> for GeneratedField {
6091 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6092 where
6093 D: serde::Deserializer<'de>,
6094 {
6095 struct GeneratedVisitor;
6096
6097 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6098 type Value = GeneratedField;
6099
6100 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6101 write!(formatter, "expected one of: {:?}", &FIELDS)
6102 }
6103
6104 #[allow(unused_variables)]
6105 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6106 where
6107 E: serde::de::Error,
6108 {
6109 Err(serde::de::Error::unknown_field(value, FIELDS))
6110 }
6111 }
6112 deserializer.deserialize_identifier(GeneratedVisitor)
6113 }
6114 }
6115 struct GeneratedVisitor;
6116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6117 type Value = GetClusterLimitsRequest;
6118
6119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6120 formatter.write_str("struct meta.GetClusterLimitsRequest")
6121 }
6122
6123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6124 where
6125 V: serde::de::MapAccess<'de>,
6126 {
6127 while map_.next_key::<GeneratedField>()?.is_some() {
6128 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6129 }
6130 Ok(GetClusterLimitsRequest {
6131 })
6132 }
6133 }
6134 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6135 }
6136}
6137impl serde::Serialize for GetClusterLimitsResponse {
6138 #[allow(deprecated)]
6139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6140 where
6141 S: serde::Serializer,
6142 {
6143 use serde::ser::SerializeStruct;
6144 let mut len = 0;
6145 if !self.active_limits.is_empty() {
6146 len += 1;
6147 }
6148 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6149 if !self.active_limits.is_empty() {
6150 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6151 }
6152 struct_ser.end()
6153 }
6154}
6155impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6156 #[allow(deprecated)]
6157 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6158 where
6159 D: serde::Deserializer<'de>,
6160 {
6161 const FIELDS: &[&str] = &[
6162 "active_limits",
6163 "activeLimits",
6164 ];
6165
6166 #[allow(clippy::enum_variant_names)]
6167 enum GeneratedField {
6168 ActiveLimits,
6169 }
6170 impl<'de> serde::Deserialize<'de> for GeneratedField {
6171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6172 where
6173 D: serde::Deserializer<'de>,
6174 {
6175 struct GeneratedVisitor;
6176
6177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6178 type Value = GeneratedField;
6179
6180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6181 write!(formatter, "expected one of: {:?}", &FIELDS)
6182 }
6183
6184 #[allow(unused_variables)]
6185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6186 where
6187 E: serde::de::Error,
6188 {
6189 match value {
6190 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6192 }
6193 }
6194 }
6195 deserializer.deserialize_identifier(GeneratedVisitor)
6196 }
6197 }
6198 struct GeneratedVisitor;
6199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6200 type Value = GetClusterLimitsResponse;
6201
6202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6203 formatter.write_str("struct meta.GetClusterLimitsResponse")
6204 }
6205
6206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6207 where
6208 V: serde::de::MapAccess<'de>,
6209 {
6210 let mut active_limits__ = None;
6211 while let Some(k) = map_.next_key()? {
6212 match k {
6213 GeneratedField::ActiveLimits => {
6214 if active_limits__.is_some() {
6215 return Err(serde::de::Error::duplicate_field("activeLimits"));
6216 }
6217 active_limits__ = Some(map_.next_value()?);
6218 }
6219 }
6220 }
6221 Ok(GetClusterLimitsResponse {
6222 active_limits: active_limits__.unwrap_or_default(),
6223 })
6224 }
6225 }
6226 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6227 }
6228}
6229impl serde::Serialize for GetClusterRecoveryStatusRequest {
6230 #[allow(deprecated)]
6231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6232 where
6233 S: serde::Serializer,
6234 {
6235 use serde::ser::SerializeStruct;
6236 let len = 0;
6237 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6238 struct_ser.end()
6239 }
6240}
6241impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6242 #[allow(deprecated)]
6243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6244 where
6245 D: serde::Deserializer<'de>,
6246 {
6247 const FIELDS: &[&str] = &[
6248 ];
6249
6250 #[allow(clippy::enum_variant_names)]
6251 enum GeneratedField {
6252 }
6253 impl<'de> serde::Deserialize<'de> for GeneratedField {
6254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6255 where
6256 D: serde::Deserializer<'de>,
6257 {
6258 struct GeneratedVisitor;
6259
6260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6261 type Value = GeneratedField;
6262
6263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6264 write!(formatter, "expected one of: {:?}", &FIELDS)
6265 }
6266
6267 #[allow(unused_variables)]
6268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6269 where
6270 E: serde::de::Error,
6271 {
6272 Err(serde::de::Error::unknown_field(value, FIELDS))
6273 }
6274 }
6275 deserializer.deserialize_identifier(GeneratedVisitor)
6276 }
6277 }
6278 struct GeneratedVisitor;
6279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6280 type Value = GetClusterRecoveryStatusRequest;
6281
6282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6283 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6284 }
6285
6286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6287 where
6288 V: serde::de::MapAccess<'de>,
6289 {
6290 while map_.next_key::<GeneratedField>()?.is_some() {
6291 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6292 }
6293 Ok(GetClusterRecoveryStatusRequest {
6294 })
6295 }
6296 }
6297 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6298 }
6299}
6300impl serde::Serialize for GetClusterRecoveryStatusResponse {
6301 #[allow(deprecated)]
6302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6303 where
6304 S: serde::Serializer,
6305 {
6306 use serde::ser::SerializeStruct;
6307 let mut len = 0;
6308 if self.status != 0 {
6309 len += 1;
6310 }
6311 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6312 if self.status != 0 {
6313 let v = RecoveryStatus::try_from(self.status)
6314 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6315 struct_ser.serialize_field("status", &v)?;
6316 }
6317 struct_ser.end()
6318 }
6319}
6320impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6321 #[allow(deprecated)]
6322 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6323 where
6324 D: serde::Deserializer<'de>,
6325 {
6326 const FIELDS: &[&str] = &[
6327 "status",
6328 ];
6329
6330 #[allow(clippy::enum_variant_names)]
6331 enum GeneratedField {
6332 Status,
6333 }
6334 impl<'de> serde::Deserialize<'de> for GeneratedField {
6335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6336 where
6337 D: serde::Deserializer<'de>,
6338 {
6339 struct GeneratedVisitor;
6340
6341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6342 type Value = GeneratedField;
6343
6344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6345 write!(formatter, "expected one of: {:?}", &FIELDS)
6346 }
6347
6348 #[allow(unused_variables)]
6349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6350 where
6351 E: serde::de::Error,
6352 {
6353 match value {
6354 "status" => Ok(GeneratedField::Status),
6355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6356 }
6357 }
6358 }
6359 deserializer.deserialize_identifier(GeneratedVisitor)
6360 }
6361 }
6362 struct GeneratedVisitor;
6363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6364 type Value = GetClusterRecoveryStatusResponse;
6365
6366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6367 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6368 }
6369
6370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6371 where
6372 V: serde::de::MapAccess<'de>,
6373 {
6374 let mut status__ = None;
6375 while let Some(k) = map_.next_key()? {
6376 match k {
6377 GeneratedField::Status => {
6378 if status__.is_some() {
6379 return Err(serde::de::Error::duplicate_field("status"));
6380 }
6381 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6382 }
6383 }
6384 }
6385 Ok(GetClusterRecoveryStatusResponse {
6386 status: status__.unwrap_or_default(),
6387 })
6388 }
6389 }
6390 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6391 }
6392}
6393impl serde::Serialize for GetFragmentByIdRequest {
6394 #[allow(deprecated)]
6395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6396 where
6397 S: serde::Serializer,
6398 {
6399 use serde::ser::SerializeStruct;
6400 let mut len = 0;
6401 if self.fragment_id != 0 {
6402 len += 1;
6403 }
6404 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6405 if self.fragment_id != 0 {
6406 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6407 }
6408 struct_ser.end()
6409 }
6410}
6411impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6412 #[allow(deprecated)]
6413 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6414 where
6415 D: serde::Deserializer<'de>,
6416 {
6417 const FIELDS: &[&str] = &[
6418 "fragment_id",
6419 "fragmentId",
6420 ];
6421
6422 #[allow(clippy::enum_variant_names)]
6423 enum GeneratedField {
6424 FragmentId,
6425 }
6426 impl<'de> serde::Deserialize<'de> for GeneratedField {
6427 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6428 where
6429 D: serde::Deserializer<'de>,
6430 {
6431 struct GeneratedVisitor;
6432
6433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6434 type Value = GeneratedField;
6435
6436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6437 write!(formatter, "expected one of: {:?}", &FIELDS)
6438 }
6439
6440 #[allow(unused_variables)]
6441 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6442 where
6443 E: serde::de::Error,
6444 {
6445 match value {
6446 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6448 }
6449 }
6450 }
6451 deserializer.deserialize_identifier(GeneratedVisitor)
6452 }
6453 }
6454 struct GeneratedVisitor;
6455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6456 type Value = GetFragmentByIdRequest;
6457
6458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6459 formatter.write_str("struct meta.GetFragmentByIdRequest")
6460 }
6461
6462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6463 where
6464 V: serde::de::MapAccess<'de>,
6465 {
6466 let mut fragment_id__ = None;
6467 while let Some(k) = map_.next_key()? {
6468 match k {
6469 GeneratedField::FragmentId => {
6470 if fragment_id__.is_some() {
6471 return Err(serde::de::Error::duplicate_field("fragmentId"));
6472 }
6473 fragment_id__ =
6474 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6475 ;
6476 }
6477 }
6478 }
6479 Ok(GetFragmentByIdRequest {
6480 fragment_id: fragment_id__.unwrap_or_default(),
6481 })
6482 }
6483 }
6484 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6485 }
6486}
6487impl serde::Serialize for GetFragmentByIdResponse {
6488 #[allow(deprecated)]
6489 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6490 where
6491 S: serde::Serializer,
6492 {
6493 use serde::ser::SerializeStruct;
6494 let mut len = 0;
6495 if self.distribution.is_some() {
6496 len += 1;
6497 }
6498 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6499 if let Some(v) = self.distribution.as_ref() {
6500 struct_ser.serialize_field("distribution", v)?;
6501 }
6502 struct_ser.end()
6503 }
6504}
6505impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6506 #[allow(deprecated)]
6507 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6508 where
6509 D: serde::Deserializer<'de>,
6510 {
6511 const FIELDS: &[&str] = &[
6512 "distribution",
6513 ];
6514
6515 #[allow(clippy::enum_variant_names)]
6516 enum GeneratedField {
6517 Distribution,
6518 }
6519 impl<'de> serde::Deserialize<'de> for GeneratedField {
6520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6521 where
6522 D: serde::Deserializer<'de>,
6523 {
6524 struct GeneratedVisitor;
6525
6526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6527 type Value = GeneratedField;
6528
6529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6530 write!(formatter, "expected one of: {:?}", &FIELDS)
6531 }
6532
6533 #[allow(unused_variables)]
6534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6535 where
6536 E: serde::de::Error,
6537 {
6538 match value {
6539 "distribution" => Ok(GeneratedField::Distribution),
6540 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6541 }
6542 }
6543 }
6544 deserializer.deserialize_identifier(GeneratedVisitor)
6545 }
6546 }
6547 struct GeneratedVisitor;
6548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6549 type Value = GetFragmentByIdResponse;
6550
6551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6552 formatter.write_str("struct meta.GetFragmentByIdResponse")
6553 }
6554
6555 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6556 where
6557 V: serde::de::MapAccess<'de>,
6558 {
6559 let mut distribution__ = None;
6560 while let Some(k) = map_.next_key()? {
6561 match k {
6562 GeneratedField::Distribution => {
6563 if distribution__.is_some() {
6564 return Err(serde::de::Error::duplicate_field("distribution"));
6565 }
6566 distribution__ = map_.next_value()?;
6567 }
6568 }
6569 }
6570 Ok(GetFragmentByIdResponse {
6571 distribution: distribution__,
6572 })
6573 }
6574 }
6575 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6576 }
6577}
6578impl serde::Serialize for GetMetaStoreInfoRequest {
6579 #[allow(deprecated)]
6580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6581 where
6582 S: serde::Serializer,
6583 {
6584 use serde::ser::SerializeStruct;
6585 let len = 0;
6586 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6587 struct_ser.end()
6588 }
6589}
6590impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6591 #[allow(deprecated)]
6592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6593 where
6594 D: serde::Deserializer<'de>,
6595 {
6596 const FIELDS: &[&str] = &[
6597 ];
6598
6599 #[allow(clippy::enum_variant_names)]
6600 enum GeneratedField {
6601 }
6602 impl<'de> serde::Deserialize<'de> for GeneratedField {
6603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6604 where
6605 D: serde::Deserializer<'de>,
6606 {
6607 struct GeneratedVisitor;
6608
6609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6610 type Value = GeneratedField;
6611
6612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6613 write!(formatter, "expected one of: {:?}", &FIELDS)
6614 }
6615
6616 #[allow(unused_variables)]
6617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6618 where
6619 E: serde::de::Error,
6620 {
6621 Err(serde::de::Error::unknown_field(value, FIELDS))
6622 }
6623 }
6624 deserializer.deserialize_identifier(GeneratedVisitor)
6625 }
6626 }
6627 struct GeneratedVisitor;
6628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6629 type Value = GetMetaStoreInfoRequest;
6630
6631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6632 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6633 }
6634
6635 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6636 where
6637 V: serde::de::MapAccess<'de>,
6638 {
6639 while map_.next_key::<GeneratedField>()?.is_some() {
6640 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6641 }
6642 Ok(GetMetaStoreInfoRequest {
6643 })
6644 }
6645 }
6646 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6647 }
6648}
6649impl serde::Serialize for GetMetaStoreInfoResponse {
6650 #[allow(deprecated)]
6651 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6652 where
6653 S: serde::Serializer,
6654 {
6655 use serde::ser::SerializeStruct;
6656 let mut len = 0;
6657 if !self.meta_store_endpoint.is_empty() {
6658 len += 1;
6659 }
6660 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6661 if !self.meta_store_endpoint.is_empty() {
6662 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6663 }
6664 struct_ser.end()
6665 }
6666}
6667impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6668 #[allow(deprecated)]
6669 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6670 where
6671 D: serde::Deserializer<'de>,
6672 {
6673 const FIELDS: &[&str] = &[
6674 "meta_store_endpoint",
6675 "metaStoreEndpoint",
6676 ];
6677
6678 #[allow(clippy::enum_variant_names)]
6679 enum GeneratedField {
6680 MetaStoreEndpoint,
6681 }
6682 impl<'de> serde::Deserialize<'de> for GeneratedField {
6683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6684 where
6685 D: serde::Deserializer<'de>,
6686 {
6687 struct GeneratedVisitor;
6688
6689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6690 type Value = GeneratedField;
6691
6692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6693 write!(formatter, "expected one of: {:?}", &FIELDS)
6694 }
6695
6696 #[allow(unused_variables)]
6697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6698 where
6699 E: serde::de::Error,
6700 {
6701 match value {
6702 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6704 }
6705 }
6706 }
6707 deserializer.deserialize_identifier(GeneratedVisitor)
6708 }
6709 }
6710 struct GeneratedVisitor;
6711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6712 type Value = GetMetaStoreInfoResponse;
6713
6714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6715 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6716 }
6717
6718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6719 where
6720 V: serde::de::MapAccess<'de>,
6721 {
6722 let mut meta_store_endpoint__ = None;
6723 while let Some(k) = map_.next_key()? {
6724 match k {
6725 GeneratedField::MetaStoreEndpoint => {
6726 if meta_store_endpoint__.is_some() {
6727 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6728 }
6729 meta_store_endpoint__ = Some(map_.next_value()?);
6730 }
6731 }
6732 }
6733 Ok(GetMetaStoreInfoResponse {
6734 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6735 })
6736 }
6737 }
6738 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6739 }
6740}
6741impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6742 #[allow(deprecated)]
6743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6744 where
6745 S: serde::Serializer,
6746 {
6747 use serde::ser::SerializeStruct;
6748 let len = 0;
6749 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6750 struct_ser.end()
6751 }
6752}
6753impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6754 #[allow(deprecated)]
6755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6756 where
6757 D: serde::Deserializer<'de>,
6758 {
6759 const FIELDS: &[&str] = &[
6760 ];
6761
6762 #[allow(clippy::enum_variant_names)]
6763 enum GeneratedField {
6764 }
6765 impl<'de> serde::Deserialize<'de> for GeneratedField {
6766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6767 where
6768 D: serde::Deserializer<'de>,
6769 {
6770 struct GeneratedVisitor;
6771
6772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6773 type Value = GeneratedField;
6774
6775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6776 write!(formatter, "expected one of: {:?}", &FIELDS)
6777 }
6778
6779 #[allow(unused_variables)]
6780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6781 where
6782 E: serde::de::Error,
6783 {
6784 Err(serde::de::Error::unknown_field(value, FIELDS))
6785 }
6786 }
6787 deserializer.deserialize_identifier(GeneratedVisitor)
6788 }
6789 }
6790 struct GeneratedVisitor;
6791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6792 type Value = GetServerlessStreamingJobsStatusRequest;
6793
6794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6795 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6796 }
6797
6798 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6799 where
6800 V: serde::de::MapAccess<'de>,
6801 {
6802 while map_.next_key::<GeneratedField>()?.is_some() {
6803 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6804 }
6805 Ok(GetServerlessStreamingJobsStatusRequest {
6806 })
6807 }
6808 }
6809 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6810 }
6811}
6812impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6813 #[allow(deprecated)]
6814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6815 where
6816 S: serde::Serializer,
6817 {
6818 use serde::ser::SerializeStruct;
6819 let mut len = 0;
6820 if !self.streaming_job_statuses.is_empty() {
6821 len += 1;
6822 }
6823 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6824 if !self.streaming_job_statuses.is_empty() {
6825 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6826 }
6827 struct_ser.end()
6828 }
6829}
6830impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6831 #[allow(deprecated)]
6832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6833 where
6834 D: serde::Deserializer<'de>,
6835 {
6836 const FIELDS: &[&str] = &[
6837 "streaming_job_statuses",
6838 "streamingJobStatuses",
6839 ];
6840
6841 #[allow(clippy::enum_variant_names)]
6842 enum GeneratedField {
6843 StreamingJobStatuses,
6844 }
6845 impl<'de> serde::Deserialize<'de> for GeneratedField {
6846 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6847 where
6848 D: serde::Deserializer<'de>,
6849 {
6850 struct GeneratedVisitor;
6851
6852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6853 type Value = GeneratedField;
6854
6855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6856 write!(formatter, "expected one of: {:?}", &FIELDS)
6857 }
6858
6859 #[allow(unused_variables)]
6860 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6861 where
6862 E: serde::de::Error,
6863 {
6864 match value {
6865 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6866 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6867 }
6868 }
6869 }
6870 deserializer.deserialize_identifier(GeneratedVisitor)
6871 }
6872 }
6873 struct GeneratedVisitor;
6874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6875 type Value = GetServerlessStreamingJobsStatusResponse;
6876
6877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6878 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6879 }
6880
6881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6882 where
6883 V: serde::de::MapAccess<'de>,
6884 {
6885 let mut streaming_job_statuses__ = None;
6886 while let Some(k) = map_.next_key()? {
6887 match k {
6888 GeneratedField::StreamingJobStatuses => {
6889 if streaming_job_statuses__.is_some() {
6890 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6891 }
6892 streaming_job_statuses__ = Some(map_.next_value()?);
6893 }
6894 }
6895 }
6896 Ok(GetServerlessStreamingJobsStatusResponse {
6897 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6898 })
6899 }
6900 }
6901 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6902 }
6903}
6904impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6905 #[allow(deprecated)]
6906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6907 where
6908 S: serde::Serializer,
6909 {
6910 use serde::ser::SerializeStruct;
6911 let mut len = 0;
6912 if self.table_id != 0 {
6913 len += 1;
6914 }
6915 if !self.node_label.is_empty() {
6916 len += 1;
6917 }
6918 if self.backfill_done {
6919 len += 1;
6920 }
6921 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6922 if self.table_id != 0 {
6923 struct_ser.serialize_field("tableId", &self.table_id)?;
6924 }
6925 if !self.node_label.is_empty() {
6926 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6927 }
6928 if self.backfill_done {
6929 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6930 }
6931 struct_ser.end()
6932 }
6933}
6934impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6935 #[allow(deprecated)]
6936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6937 where
6938 D: serde::Deserializer<'de>,
6939 {
6940 const FIELDS: &[&str] = &[
6941 "table_id",
6942 "tableId",
6943 "node_label",
6944 "nodeLabel",
6945 "backfill_done",
6946 "backfillDone",
6947 ];
6948
6949 #[allow(clippy::enum_variant_names)]
6950 enum GeneratedField {
6951 TableId,
6952 NodeLabel,
6953 BackfillDone,
6954 }
6955 impl<'de> serde::Deserialize<'de> for GeneratedField {
6956 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6957 where
6958 D: serde::Deserializer<'de>,
6959 {
6960 struct GeneratedVisitor;
6961
6962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6963 type Value = GeneratedField;
6964
6965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6966 write!(formatter, "expected one of: {:?}", &FIELDS)
6967 }
6968
6969 #[allow(unused_variables)]
6970 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6971 where
6972 E: serde::de::Error,
6973 {
6974 match value {
6975 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6976 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6977 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6978 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6979 }
6980 }
6981 }
6982 deserializer.deserialize_identifier(GeneratedVisitor)
6983 }
6984 }
6985 struct GeneratedVisitor;
6986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6987 type Value = get_serverless_streaming_jobs_status_response::Status;
6988
6989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6990 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6991 }
6992
6993 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6994 where
6995 V: serde::de::MapAccess<'de>,
6996 {
6997 let mut table_id__ = None;
6998 let mut node_label__ = None;
6999 let mut backfill_done__ = None;
7000 while let Some(k) = map_.next_key()? {
7001 match k {
7002 GeneratedField::TableId => {
7003 if table_id__.is_some() {
7004 return Err(serde::de::Error::duplicate_field("tableId"));
7005 }
7006 table_id__ =
7007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7008 ;
7009 }
7010 GeneratedField::NodeLabel => {
7011 if node_label__.is_some() {
7012 return Err(serde::de::Error::duplicate_field("nodeLabel"));
7013 }
7014 node_label__ = Some(map_.next_value()?);
7015 }
7016 GeneratedField::BackfillDone => {
7017 if backfill_done__.is_some() {
7018 return Err(serde::de::Error::duplicate_field("backfillDone"));
7019 }
7020 backfill_done__ = Some(map_.next_value()?);
7021 }
7022 }
7023 }
7024 Ok(get_serverless_streaming_jobs_status_response::Status {
7025 table_id: table_id__.unwrap_or_default(),
7026 node_label: node_label__.unwrap_or_default(),
7027 backfill_done: backfill_done__.unwrap_or_default(),
7028 })
7029 }
7030 }
7031 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7032 }
7033}
7034impl serde::Serialize for GetServingVnodeMappingsRequest {
7035 #[allow(deprecated)]
7036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7037 where
7038 S: serde::Serializer,
7039 {
7040 use serde::ser::SerializeStruct;
7041 let len = 0;
7042 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7043 struct_ser.end()
7044 }
7045}
7046impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7047 #[allow(deprecated)]
7048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7049 where
7050 D: serde::Deserializer<'de>,
7051 {
7052 const FIELDS: &[&str] = &[
7053 ];
7054
7055 #[allow(clippy::enum_variant_names)]
7056 enum GeneratedField {
7057 }
7058 impl<'de> serde::Deserialize<'de> for GeneratedField {
7059 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7060 where
7061 D: serde::Deserializer<'de>,
7062 {
7063 struct GeneratedVisitor;
7064
7065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7066 type Value = GeneratedField;
7067
7068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7069 write!(formatter, "expected one of: {:?}", &FIELDS)
7070 }
7071
7072 #[allow(unused_variables)]
7073 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7074 where
7075 E: serde::de::Error,
7076 {
7077 Err(serde::de::Error::unknown_field(value, FIELDS))
7078 }
7079 }
7080 deserializer.deserialize_identifier(GeneratedVisitor)
7081 }
7082 }
7083 struct GeneratedVisitor;
7084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7085 type Value = GetServingVnodeMappingsRequest;
7086
7087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7088 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7089 }
7090
7091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7092 where
7093 V: serde::de::MapAccess<'de>,
7094 {
7095 while map_.next_key::<GeneratedField>()?.is_some() {
7096 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7097 }
7098 Ok(GetServingVnodeMappingsRequest {
7099 })
7100 }
7101 }
7102 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7103 }
7104}
7105impl serde::Serialize for GetServingVnodeMappingsResponse {
7106 #[allow(deprecated)]
7107 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7108 where
7109 S: serde::Serializer,
7110 {
7111 use serde::ser::SerializeStruct;
7112 let mut len = 0;
7113 if !self.fragment_to_table.is_empty() {
7114 len += 1;
7115 }
7116 if !self.worker_slot_mappings.is_empty() {
7117 len += 1;
7118 }
7119 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7120 if !self.fragment_to_table.is_empty() {
7121 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7122 }
7123 if !self.worker_slot_mappings.is_empty() {
7124 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7125 }
7126 struct_ser.end()
7127 }
7128}
7129impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7130 #[allow(deprecated)]
7131 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7132 where
7133 D: serde::Deserializer<'de>,
7134 {
7135 const FIELDS: &[&str] = &[
7136 "fragment_to_table",
7137 "fragmentToTable",
7138 "worker_slot_mappings",
7139 "workerSlotMappings",
7140 ];
7141
7142 #[allow(clippy::enum_variant_names)]
7143 enum GeneratedField {
7144 FragmentToTable,
7145 WorkerSlotMappings,
7146 }
7147 impl<'de> serde::Deserialize<'de> for GeneratedField {
7148 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7149 where
7150 D: serde::Deserializer<'de>,
7151 {
7152 struct GeneratedVisitor;
7153
7154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7155 type Value = GeneratedField;
7156
7157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7158 write!(formatter, "expected one of: {:?}", &FIELDS)
7159 }
7160
7161 #[allow(unused_variables)]
7162 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7163 where
7164 E: serde::de::Error,
7165 {
7166 match value {
7167 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7168 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7169 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7170 }
7171 }
7172 }
7173 deserializer.deserialize_identifier(GeneratedVisitor)
7174 }
7175 }
7176 struct GeneratedVisitor;
7177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7178 type Value = GetServingVnodeMappingsResponse;
7179
7180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7181 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7182 }
7183
7184 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7185 where
7186 V: serde::de::MapAccess<'de>,
7187 {
7188 let mut fragment_to_table__ = None;
7189 let mut worker_slot_mappings__ = None;
7190 while let Some(k) = map_.next_key()? {
7191 match k {
7192 GeneratedField::FragmentToTable => {
7193 if fragment_to_table__.is_some() {
7194 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7195 }
7196 fragment_to_table__ = Some(
7197 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7198 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7199 );
7200 }
7201 GeneratedField::WorkerSlotMappings => {
7202 if worker_slot_mappings__.is_some() {
7203 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7204 }
7205 worker_slot_mappings__ = Some(map_.next_value()?);
7206 }
7207 }
7208 }
7209 Ok(GetServingVnodeMappingsResponse {
7210 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7211 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7212 })
7213 }
7214 }
7215 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7216 }
7217}
7218impl serde::Serialize for GetSessionParamsRequest {
7219 #[allow(deprecated)]
7220 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7221 where
7222 S: serde::Serializer,
7223 {
7224 use serde::ser::SerializeStruct;
7225 let len = 0;
7226 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7227 struct_ser.end()
7228 }
7229}
7230impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7231 #[allow(deprecated)]
7232 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7233 where
7234 D: serde::Deserializer<'de>,
7235 {
7236 const FIELDS: &[&str] = &[
7237 ];
7238
7239 #[allow(clippy::enum_variant_names)]
7240 enum GeneratedField {
7241 }
7242 impl<'de> serde::Deserialize<'de> for GeneratedField {
7243 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7244 where
7245 D: serde::Deserializer<'de>,
7246 {
7247 struct GeneratedVisitor;
7248
7249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7250 type Value = GeneratedField;
7251
7252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7253 write!(formatter, "expected one of: {:?}", &FIELDS)
7254 }
7255
7256 #[allow(unused_variables)]
7257 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7258 where
7259 E: serde::de::Error,
7260 {
7261 Err(serde::de::Error::unknown_field(value, FIELDS))
7262 }
7263 }
7264 deserializer.deserialize_identifier(GeneratedVisitor)
7265 }
7266 }
7267 struct GeneratedVisitor;
7268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7269 type Value = GetSessionParamsRequest;
7270
7271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7272 formatter.write_str("struct meta.GetSessionParamsRequest")
7273 }
7274
7275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7276 where
7277 V: serde::de::MapAccess<'de>,
7278 {
7279 while map_.next_key::<GeneratedField>()?.is_some() {
7280 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7281 }
7282 Ok(GetSessionParamsRequest {
7283 })
7284 }
7285 }
7286 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7287 }
7288}
7289impl serde::Serialize for GetSessionParamsResponse {
7290 #[allow(deprecated)]
7291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7292 where
7293 S: serde::Serializer,
7294 {
7295 use serde::ser::SerializeStruct;
7296 let mut len = 0;
7297 if !self.params.is_empty() {
7298 len += 1;
7299 }
7300 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7301 if !self.params.is_empty() {
7302 struct_ser.serialize_field("params", &self.params)?;
7303 }
7304 struct_ser.end()
7305 }
7306}
7307impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7308 #[allow(deprecated)]
7309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7310 where
7311 D: serde::Deserializer<'de>,
7312 {
7313 const FIELDS: &[&str] = &[
7314 "params",
7315 ];
7316
7317 #[allow(clippy::enum_variant_names)]
7318 enum GeneratedField {
7319 Params,
7320 }
7321 impl<'de> serde::Deserialize<'de> for GeneratedField {
7322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7323 where
7324 D: serde::Deserializer<'de>,
7325 {
7326 struct GeneratedVisitor;
7327
7328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7329 type Value = GeneratedField;
7330
7331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7332 write!(formatter, "expected one of: {:?}", &FIELDS)
7333 }
7334
7335 #[allow(unused_variables)]
7336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7337 where
7338 E: serde::de::Error,
7339 {
7340 match value {
7341 "params" => Ok(GeneratedField::Params),
7342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7343 }
7344 }
7345 }
7346 deserializer.deserialize_identifier(GeneratedVisitor)
7347 }
7348 }
7349 struct GeneratedVisitor;
7350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7351 type Value = GetSessionParamsResponse;
7352
7353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7354 formatter.write_str("struct meta.GetSessionParamsResponse")
7355 }
7356
7357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7358 where
7359 V: serde::de::MapAccess<'de>,
7360 {
7361 let mut params__ = None;
7362 while let Some(k) = map_.next_key()? {
7363 match k {
7364 GeneratedField::Params => {
7365 if params__.is_some() {
7366 return Err(serde::de::Error::duplicate_field("params"));
7367 }
7368 params__ = Some(map_.next_value()?);
7369 }
7370 }
7371 }
7372 Ok(GetSessionParamsResponse {
7373 params: params__.unwrap_or_default(),
7374 })
7375 }
7376 }
7377 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7378 }
7379}
7380impl serde::Serialize for GetSystemParamsRequest {
7381 #[allow(deprecated)]
7382 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7383 where
7384 S: serde::Serializer,
7385 {
7386 use serde::ser::SerializeStruct;
7387 let len = 0;
7388 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7389 struct_ser.end()
7390 }
7391}
7392impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7393 #[allow(deprecated)]
7394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7395 where
7396 D: serde::Deserializer<'de>,
7397 {
7398 const FIELDS: &[&str] = &[
7399 ];
7400
7401 #[allow(clippy::enum_variant_names)]
7402 enum GeneratedField {
7403 }
7404 impl<'de> serde::Deserialize<'de> for GeneratedField {
7405 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7406 where
7407 D: serde::Deserializer<'de>,
7408 {
7409 struct GeneratedVisitor;
7410
7411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7412 type Value = GeneratedField;
7413
7414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7415 write!(formatter, "expected one of: {:?}", &FIELDS)
7416 }
7417
7418 #[allow(unused_variables)]
7419 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7420 where
7421 E: serde::de::Error,
7422 {
7423 Err(serde::de::Error::unknown_field(value, FIELDS))
7424 }
7425 }
7426 deserializer.deserialize_identifier(GeneratedVisitor)
7427 }
7428 }
7429 struct GeneratedVisitor;
7430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7431 type Value = GetSystemParamsRequest;
7432
7433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7434 formatter.write_str("struct meta.GetSystemParamsRequest")
7435 }
7436
7437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7438 where
7439 V: serde::de::MapAccess<'de>,
7440 {
7441 while map_.next_key::<GeneratedField>()?.is_some() {
7442 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7443 }
7444 Ok(GetSystemParamsRequest {
7445 })
7446 }
7447 }
7448 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7449 }
7450}
7451impl serde::Serialize for GetSystemParamsResponse {
7452 #[allow(deprecated)]
7453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7454 where
7455 S: serde::Serializer,
7456 {
7457 use serde::ser::SerializeStruct;
7458 let mut len = 0;
7459 if self.params.is_some() {
7460 len += 1;
7461 }
7462 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7463 if let Some(v) = self.params.as_ref() {
7464 struct_ser.serialize_field("params", v)?;
7465 }
7466 struct_ser.end()
7467 }
7468}
7469impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7470 #[allow(deprecated)]
7471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7472 where
7473 D: serde::Deserializer<'de>,
7474 {
7475 const FIELDS: &[&str] = &[
7476 "params",
7477 ];
7478
7479 #[allow(clippy::enum_variant_names)]
7480 enum GeneratedField {
7481 Params,
7482 }
7483 impl<'de> serde::Deserialize<'de> for GeneratedField {
7484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7485 where
7486 D: serde::Deserializer<'de>,
7487 {
7488 struct GeneratedVisitor;
7489
7490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7491 type Value = GeneratedField;
7492
7493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7494 write!(formatter, "expected one of: {:?}", &FIELDS)
7495 }
7496
7497 #[allow(unused_variables)]
7498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7499 where
7500 E: serde::de::Error,
7501 {
7502 match value {
7503 "params" => Ok(GeneratedField::Params),
7504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7505 }
7506 }
7507 }
7508 deserializer.deserialize_identifier(GeneratedVisitor)
7509 }
7510 }
7511 struct GeneratedVisitor;
7512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7513 type Value = GetSystemParamsResponse;
7514
7515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7516 formatter.write_str("struct meta.GetSystemParamsResponse")
7517 }
7518
7519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7520 where
7521 V: serde::de::MapAccess<'de>,
7522 {
7523 let mut params__ = None;
7524 while let Some(k) = map_.next_key()? {
7525 match k {
7526 GeneratedField::Params => {
7527 if params__.is_some() {
7528 return Err(serde::de::Error::duplicate_field("params"));
7529 }
7530 params__ = map_.next_value()?;
7531 }
7532 }
7533 }
7534 Ok(GetSystemParamsResponse {
7535 params: params__,
7536 })
7537 }
7538 }
7539 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7540 }
7541}
7542impl serde::Serialize for GetTelemetryInfoRequest {
7543 #[allow(deprecated)]
7544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7545 where
7546 S: serde::Serializer,
7547 {
7548 use serde::ser::SerializeStruct;
7549 let len = 0;
7550 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7551 struct_ser.end()
7552 }
7553}
7554impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7555 #[allow(deprecated)]
7556 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7557 where
7558 D: serde::Deserializer<'de>,
7559 {
7560 const FIELDS: &[&str] = &[
7561 ];
7562
7563 #[allow(clippy::enum_variant_names)]
7564 enum GeneratedField {
7565 }
7566 impl<'de> serde::Deserialize<'de> for GeneratedField {
7567 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7568 where
7569 D: serde::Deserializer<'de>,
7570 {
7571 struct GeneratedVisitor;
7572
7573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7574 type Value = GeneratedField;
7575
7576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7577 write!(formatter, "expected one of: {:?}", &FIELDS)
7578 }
7579
7580 #[allow(unused_variables)]
7581 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7582 where
7583 E: serde::de::Error,
7584 {
7585 Err(serde::de::Error::unknown_field(value, FIELDS))
7586 }
7587 }
7588 deserializer.deserialize_identifier(GeneratedVisitor)
7589 }
7590 }
7591 struct GeneratedVisitor;
7592 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7593 type Value = GetTelemetryInfoRequest;
7594
7595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7596 formatter.write_str("struct meta.GetTelemetryInfoRequest")
7597 }
7598
7599 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7600 where
7601 V: serde::de::MapAccess<'de>,
7602 {
7603 while map_.next_key::<GeneratedField>()?.is_some() {
7604 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7605 }
7606 Ok(GetTelemetryInfoRequest {
7607 })
7608 }
7609 }
7610 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7611 }
7612}
7613impl serde::Serialize for HeartbeatRequest {
7614 #[allow(deprecated)]
7615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7616 where
7617 S: serde::Serializer,
7618 {
7619 use serde::ser::SerializeStruct;
7620 let mut len = 0;
7621 if self.node_id != 0 {
7622 len += 1;
7623 }
7624 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7625 if self.node_id != 0 {
7626 struct_ser.serialize_field("nodeId", &self.node_id)?;
7627 }
7628 struct_ser.end()
7629 }
7630}
7631impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7632 #[allow(deprecated)]
7633 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7634 where
7635 D: serde::Deserializer<'de>,
7636 {
7637 const FIELDS: &[&str] = &[
7638 "node_id",
7639 "nodeId",
7640 ];
7641
7642 #[allow(clippy::enum_variant_names)]
7643 enum GeneratedField {
7644 NodeId,
7645 }
7646 impl<'de> serde::Deserialize<'de> for GeneratedField {
7647 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7648 where
7649 D: serde::Deserializer<'de>,
7650 {
7651 struct GeneratedVisitor;
7652
7653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7654 type Value = GeneratedField;
7655
7656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7657 write!(formatter, "expected one of: {:?}", &FIELDS)
7658 }
7659
7660 #[allow(unused_variables)]
7661 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7662 where
7663 E: serde::de::Error,
7664 {
7665 match value {
7666 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7667 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7668 }
7669 }
7670 }
7671 deserializer.deserialize_identifier(GeneratedVisitor)
7672 }
7673 }
7674 struct GeneratedVisitor;
7675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7676 type Value = HeartbeatRequest;
7677
7678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7679 formatter.write_str("struct meta.HeartbeatRequest")
7680 }
7681
7682 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7683 where
7684 V: serde::de::MapAccess<'de>,
7685 {
7686 let mut node_id__ = None;
7687 while let Some(k) = map_.next_key()? {
7688 match k {
7689 GeneratedField::NodeId => {
7690 if node_id__.is_some() {
7691 return Err(serde::de::Error::duplicate_field("nodeId"));
7692 }
7693 node_id__ =
7694 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7695 ;
7696 }
7697 }
7698 }
7699 Ok(HeartbeatRequest {
7700 node_id: node_id__.unwrap_or_default(),
7701 })
7702 }
7703 }
7704 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7705 }
7706}
7707impl serde::Serialize for HeartbeatResponse {
7708 #[allow(deprecated)]
7709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7710 where
7711 S: serde::Serializer,
7712 {
7713 use serde::ser::SerializeStruct;
7714 let mut len = 0;
7715 if self.status.is_some() {
7716 len += 1;
7717 }
7718 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7719 if let Some(v) = self.status.as_ref() {
7720 struct_ser.serialize_field("status", v)?;
7721 }
7722 struct_ser.end()
7723 }
7724}
7725impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7726 #[allow(deprecated)]
7727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7728 where
7729 D: serde::Deserializer<'de>,
7730 {
7731 const FIELDS: &[&str] = &[
7732 "status",
7733 ];
7734
7735 #[allow(clippy::enum_variant_names)]
7736 enum GeneratedField {
7737 Status,
7738 }
7739 impl<'de> serde::Deserialize<'de> for GeneratedField {
7740 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7741 where
7742 D: serde::Deserializer<'de>,
7743 {
7744 struct GeneratedVisitor;
7745
7746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7747 type Value = GeneratedField;
7748
7749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7750 write!(formatter, "expected one of: {:?}", &FIELDS)
7751 }
7752
7753 #[allow(unused_variables)]
7754 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7755 where
7756 E: serde::de::Error,
7757 {
7758 match value {
7759 "status" => Ok(GeneratedField::Status),
7760 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7761 }
7762 }
7763 }
7764 deserializer.deserialize_identifier(GeneratedVisitor)
7765 }
7766 }
7767 struct GeneratedVisitor;
7768 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7769 type Value = HeartbeatResponse;
7770
7771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7772 formatter.write_str("struct meta.HeartbeatResponse")
7773 }
7774
7775 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7776 where
7777 V: serde::de::MapAccess<'de>,
7778 {
7779 let mut status__ = None;
7780 while let Some(k) = map_.next_key()? {
7781 match k {
7782 GeneratedField::Status => {
7783 if status__.is_some() {
7784 return Err(serde::de::Error::duplicate_field("status"));
7785 }
7786 status__ = map_.next_value()?;
7787 }
7788 }
7789 }
7790 Ok(HeartbeatResponse {
7791 status: status__,
7792 })
7793 }
7794 }
7795 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7796 }
7797}
7798impl serde::Serialize for ListActorSplitsRequest {
7799 #[allow(deprecated)]
7800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7801 where
7802 S: serde::Serializer,
7803 {
7804 use serde::ser::SerializeStruct;
7805 let len = 0;
7806 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7807 struct_ser.end()
7808 }
7809}
7810impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7811 #[allow(deprecated)]
7812 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7813 where
7814 D: serde::Deserializer<'de>,
7815 {
7816 const FIELDS: &[&str] = &[
7817 ];
7818
7819 #[allow(clippy::enum_variant_names)]
7820 enum GeneratedField {
7821 }
7822 impl<'de> serde::Deserialize<'de> for GeneratedField {
7823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7824 where
7825 D: serde::Deserializer<'de>,
7826 {
7827 struct GeneratedVisitor;
7828
7829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7830 type Value = GeneratedField;
7831
7832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7833 write!(formatter, "expected one of: {:?}", &FIELDS)
7834 }
7835
7836 #[allow(unused_variables)]
7837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7838 where
7839 E: serde::de::Error,
7840 {
7841 Err(serde::de::Error::unknown_field(value, FIELDS))
7842 }
7843 }
7844 deserializer.deserialize_identifier(GeneratedVisitor)
7845 }
7846 }
7847 struct GeneratedVisitor;
7848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7849 type Value = ListActorSplitsRequest;
7850
7851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7852 formatter.write_str("struct meta.ListActorSplitsRequest")
7853 }
7854
7855 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7856 where
7857 V: serde::de::MapAccess<'de>,
7858 {
7859 while map_.next_key::<GeneratedField>()?.is_some() {
7860 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7861 }
7862 Ok(ListActorSplitsRequest {
7863 })
7864 }
7865 }
7866 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7867 }
7868}
7869impl serde::Serialize for ListActorSplitsResponse {
7870 #[allow(deprecated)]
7871 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7872 where
7873 S: serde::Serializer,
7874 {
7875 use serde::ser::SerializeStruct;
7876 let mut len = 0;
7877 if !self.actor_splits.is_empty() {
7878 len += 1;
7879 }
7880 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7881 if !self.actor_splits.is_empty() {
7882 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7883 }
7884 struct_ser.end()
7885 }
7886}
7887impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7888 #[allow(deprecated)]
7889 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7890 where
7891 D: serde::Deserializer<'de>,
7892 {
7893 const FIELDS: &[&str] = &[
7894 "actor_splits",
7895 "actorSplits",
7896 ];
7897
7898 #[allow(clippy::enum_variant_names)]
7899 enum GeneratedField {
7900 ActorSplits,
7901 }
7902 impl<'de> serde::Deserialize<'de> for GeneratedField {
7903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7904 where
7905 D: serde::Deserializer<'de>,
7906 {
7907 struct GeneratedVisitor;
7908
7909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7910 type Value = GeneratedField;
7911
7912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7913 write!(formatter, "expected one of: {:?}", &FIELDS)
7914 }
7915
7916 #[allow(unused_variables)]
7917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7918 where
7919 E: serde::de::Error,
7920 {
7921 match value {
7922 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7923 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7924 }
7925 }
7926 }
7927 deserializer.deserialize_identifier(GeneratedVisitor)
7928 }
7929 }
7930 struct GeneratedVisitor;
7931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7932 type Value = ListActorSplitsResponse;
7933
7934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7935 formatter.write_str("struct meta.ListActorSplitsResponse")
7936 }
7937
7938 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7939 where
7940 V: serde::de::MapAccess<'de>,
7941 {
7942 let mut actor_splits__ = None;
7943 while let Some(k) = map_.next_key()? {
7944 match k {
7945 GeneratedField::ActorSplits => {
7946 if actor_splits__.is_some() {
7947 return Err(serde::de::Error::duplicate_field("actorSplits"));
7948 }
7949 actor_splits__ = Some(map_.next_value()?);
7950 }
7951 }
7952 }
7953 Ok(ListActorSplitsResponse {
7954 actor_splits: actor_splits__.unwrap_or_default(),
7955 })
7956 }
7957 }
7958 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7959 }
7960}
7961impl serde::Serialize for list_actor_splits_response::ActorSplit {
7962 #[allow(deprecated)]
7963 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7964 where
7965 S: serde::Serializer,
7966 {
7967 use serde::ser::SerializeStruct;
7968 let mut len = 0;
7969 if self.actor_id != 0 {
7970 len += 1;
7971 }
7972 if self.fragment_id != 0 {
7973 len += 1;
7974 }
7975 if self.source_id != 0 {
7976 len += 1;
7977 }
7978 if !self.split_id.is_empty() {
7979 len += 1;
7980 }
7981 if self.fragment_type != 0 {
7982 len += 1;
7983 }
7984 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7985 if self.actor_id != 0 {
7986 struct_ser.serialize_field("actorId", &self.actor_id)?;
7987 }
7988 if self.fragment_id != 0 {
7989 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7990 }
7991 if self.source_id != 0 {
7992 struct_ser.serialize_field("sourceId", &self.source_id)?;
7993 }
7994 if !self.split_id.is_empty() {
7995 struct_ser.serialize_field("splitId", &self.split_id)?;
7996 }
7997 if self.fragment_type != 0 {
7998 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7999 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
8000 struct_ser.serialize_field("fragmentType", &v)?;
8001 }
8002 struct_ser.end()
8003 }
8004}
8005impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
8006 #[allow(deprecated)]
8007 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8008 where
8009 D: serde::Deserializer<'de>,
8010 {
8011 const FIELDS: &[&str] = &[
8012 "actor_id",
8013 "actorId",
8014 "fragment_id",
8015 "fragmentId",
8016 "source_id",
8017 "sourceId",
8018 "split_id",
8019 "splitId",
8020 "fragment_type",
8021 "fragmentType",
8022 ];
8023
8024 #[allow(clippy::enum_variant_names)]
8025 enum GeneratedField {
8026 ActorId,
8027 FragmentId,
8028 SourceId,
8029 SplitId,
8030 FragmentType,
8031 }
8032 impl<'de> serde::Deserialize<'de> for GeneratedField {
8033 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8034 where
8035 D: serde::Deserializer<'de>,
8036 {
8037 struct GeneratedVisitor;
8038
8039 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8040 type Value = GeneratedField;
8041
8042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8043 write!(formatter, "expected one of: {:?}", &FIELDS)
8044 }
8045
8046 #[allow(unused_variables)]
8047 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8048 where
8049 E: serde::de::Error,
8050 {
8051 match value {
8052 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8053 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8054 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8055 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
8056 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
8057 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8058 }
8059 }
8060 }
8061 deserializer.deserialize_identifier(GeneratedVisitor)
8062 }
8063 }
8064 struct GeneratedVisitor;
8065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8066 type Value = list_actor_splits_response::ActorSplit;
8067
8068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8069 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
8070 }
8071
8072 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
8073 where
8074 V: serde::de::MapAccess<'de>,
8075 {
8076 let mut actor_id__ = None;
8077 let mut fragment_id__ = None;
8078 let mut source_id__ = None;
8079 let mut split_id__ = None;
8080 let mut fragment_type__ = None;
8081 while let Some(k) = map_.next_key()? {
8082 match k {
8083 GeneratedField::ActorId => {
8084 if actor_id__.is_some() {
8085 return Err(serde::de::Error::duplicate_field("actorId"));
8086 }
8087 actor_id__ =
8088 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8089 ;
8090 }
8091 GeneratedField::FragmentId => {
8092 if fragment_id__.is_some() {
8093 return Err(serde::de::Error::duplicate_field("fragmentId"));
8094 }
8095 fragment_id__ =
8096 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8097 ;
8098 }
8099 GeneratedField::SourceId => {
8100 if source_id__.is_some() {
8101 return Err(serde::de::Error::duplicate_field("sourceId"));
8102 }
8103 source_id__ =
8104 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8105 ;
8106 }
8107 GeneratedField::SplitId => {
8108 if split_id__.is_some() {
8109 return Err(serde::de::Error::duplicate_field("splitId"));
8110 }
8111 split_id__ = Some(map_.next_value()?);
8112 }
8113 GeneratedField::FragmentType => {
8114 if fragment_type__.is_some() {
8115 return Err(serde::de::Error::duplicate_field("fragmentType"));
8116 }
8117 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
8118 }
8119 }
8120 }
8121 Ok(list_actor_splits_response::ActorSplit {
8122 actor_id: actor_id__.unwrap_or_default(),
8123 fragment_id: fragment_id__.unwrap_or_default(),
8124 source_id: source_id__.unwrap_or_default(),
8125 split_id: split_id__.unwrap_or_default(),
8126 fragment_type: fragment_type__.unwrap_or_default(),
8127 })
8128 }
8129 }
8130 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
8131 }
8132}
8133impl serde::Serialize for list_actor_splits_response::FragmentType {
8134 #[allow(deprecated)]
8135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8136 where
8137 S: serde::Serializer,
8138 {
8139 let variant = match self {
8140 Self::Unspecified => "UNSPECIFIED",
8141 Self::NonSharedSource => "NON_SHARED_SOURCE",
8142 Self::SharedSource => "SHARED_SOURCE",
8143 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
8144 };
8145 serializer.serialize_str(variant)
8146 }
8147}
8148impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
8149 #[allow(deprecated)]
8150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8151 where
8152 D: serde::Deserializer<'de>,
8153 {
8154 const FIELDS: &[&str] = &[
8155 "UNSPECIFIED",
8156 "NON_SHARED_SOURCE",
8157 "SHARED_SOURCE",
8158 "SHARED_SOURCE_BACKFILL",
8159 ];
8160
8161 struct GeneratedVisitor;
8162
8163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8164 type Value = list_actor_splits_response::FragmentType;
8165
8166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8167 write!(formatter, "expected one of: {:?}", &FIELDS)
8168 }
8169
8170 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8171 where
8172 E: serde::de::Error,
8173 {
8174 i32::try_from(v)
8175 .ok()
8176 .and_then(|x| x.try_into().ok())
8177 .ok_or_else(|| {
8178 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8179 })
8180 }
8181
8182 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8183 where
8184 E: serde::de::Error,
8185 {
8186 i32::try_from(v)
8187 .ok()
8188 .and_then(|x| x.try_into().ok())
8189 .ok_or_else(|| {
8190 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8191 })
8192 }
8193
8194 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8195 where
8196 E: serde::de::Error,
8197 {
8198 match value {
8199 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8200 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8201 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8202 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8203 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8204 }
8205 }
8206 }
8207 deserializer.deserialize_any(GeneratedVisitor)
8208 }
8209}
8210impl serde::Serialize for ListActorStatesRequest {
8211 #[allow(deprecated)]
8212 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8213 where
8214 S: serde::Serializer,
8215 {
8216 use serde::ser::SerializeStruct;
8217 let len = 0;
8218 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8219 struct_ser.end()
8220 }
8221}
8222impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8223 #[allow(deprecated)]
8224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8225 where
8226 D: serde::Deserializer<'de>,
8227 {
8228 const FIELDS: &[&str] = &[
8229 ];
8230
8231 #[allow(clippy::enum_variant_names)]
8232 enum GeneratedField {
8233 }
8234 impl<'de> serde::Deserialize<'de> for GeneratedField {
8235 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8236 where
8237 D: serde::Deserializer<'de>,
8238 {
8239 struct GeneratedVisitor;
8240
8241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8242 type Value = GeneratedField;
8243
8244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8245 write!(formatter, "expected one of: {:?}", &FIELDS)
8246 }
8247
8248 #[allow(unused_variables)]
8249 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8250 where
8251 E: serde::de::Error,
8252 {
8253 Err(serde::de::Error::unknown_field(value, FIELDS))
8254 }
8255 }
8256 deserializer.deserialize_identifier(GeneratedVisitor)
8257 }
8258 }
8259 struct GeneratedVisitor;
8260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8261 type Value = ListActorStatesRequest;
8262
8263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8264 formatter.write_str("struct meta.ListActorStatesRequest")
8265 }
8266
8267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8268 where
8269 V: serde::de::MapAccess<'de>,
8270 {
8271 while map_.next_key::<GeneratedField>()?.is_some() {
8272 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8273 }
8274 Ok(ListActorStatesRequest {
8275 })
8276 }
8277 }
8278 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8279 }
8280}
8281impl serde::Serialize for ListActorStatesResponse {
8282 #[allow(deprecated)]
8283 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8284 where
8285 S: serde::Serializer,
8286 {
8287 use serde::ser::SerializeStruct;
8288 let mut len = 0;
8289 if !self.states.is_empty() {
8290 len += 1;
8291 }
8292 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8293 if !self.states.is_empty() {
8294 struct_ser.serialize_field("states", &self.states)?;
8295 }
8296 struct_ser.end()
8297 }
8298}
8299impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8300 #[allow(deprecated)]
8301 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8302 where
8303 D: serde::Deserializer<'de>,
8304 {
8305 const FIELDS: &[&str] = &[
8306 "states",
8307 ];
8308
8309 #[allow(clippy::enum_variant_names)]
8310 enum GeneratedField {
8311 States,
8312 }
8313 impl<'de> serde::Deserialize<'de> for GeneratedField {
8314 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8315 where
8316 D: serde::Deserializer<'de>,
8317 {
8318 struct GeneratedVisitor;
8319
8320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8321 type Value = GeneratedField;
8322
8323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8324 write!(formatter, "expected one of: {:?}", &FIELDS)
8325 }
8326
8327 #[allow(unused_variables)]
8328 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8329 where
8330 E: serde::de::Error,
8331 {
8332 match value {
8333 "states" => Ok(GeneratedField::States),
8334 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8335 }
8336 }
8337 }
8338 deserializer.deserialize_identifier(GeneratedVisitor)
8339 }
8340 }
8341 struct GeneratedVisitor;
8342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8343 type Value = ListActorStatesResponse;
8344
8345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8346 formatter.write_str("struct meta.ListActorStatesResponse")
8347 }
8348
8349 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8350 where
8351 V: serde::de::MapAccess<'de>,
8352 {
8353 let mut states__ = None;
8354 while let Some(k) = map_.next_key()? {
8355 match k {
8356 GeneratedField::States => {
8357 if states__.is_some() {
8358 return Err(serde::de::Error::duplicate_field("states"));
8359 }
8360 states__ = Some(map_.next_value()?);
8361 }
8362 }
8363 }
8364 Ok(ListActorStatesResponse {
8365 states: states__.unwrap_or_default(),
8366 })
8367 }
8368 }
8369 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8370 }
8371}
8372impl serde::Serialize for list_actor_states_response::ActorState {
8373 #[allow(deprecated)]
8374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8375 where
8376 S: serde::Serializer,
8377 {
8378 use serde::ser::SerializeStruct;
8379 let mut len = 0;
8380 if self.actor_id != 0 {
8381 len += 1;
8382 }
8383 if self.fragment_id != 0 {
8384 len += 1;
8385 }
8386 if self.worker_id != 0 {
8387 len += 1;
8388 }
8389 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8390 if self.actor_id != 0 {
8391 struct_ser.serialize_field("actorId", &self.actor_id)?;
8392 }
8393 if self.fragment_id != 0 {
8394 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8395 }
8396 if self.worker_id != 0 {
8397 struct_ser.serialize_field("workerId", &self.worker_id)?;
8398 }
8399 struct_ser.end()
8400 }
8401}
8402impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8403 #[allow(deprecated)]
8404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8405 where
8406 D: serde::Deserializer<'de>,
8407 {
8408 const FIELDS: &[&str] = &[
8409 "actor_id",
8410 "actorId",
8411 "fragment_id",
8412 "fragmentId",
8413 "worker_id",
8414 "workerId",
8415 ];
8416
8417 #[allow(clippy::enum_variant_names)]
8418 enum GeneratedField {
8419 ActorId,
8420 FragmentId,
8421 WorkerId,
8422 }
8423 impl<'de> serde::Deserialize<'de> for GeneratedField {
8424 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8425 where
8426 D: serde::Deserializer<'de>,
8427 {
8428 struct GeneratedVisitor;
8429
8430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8431 type Value = GeneratedField;
8432
8433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8434 write!(formatter, "expected one of: {:?}", &FIELDS)
8435 }
8436
8437 #[allow(unused_variables)]
8438 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8439 where
8440 E: serde::de::Error,
8441 {
8442 match value {
8443 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8444 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8445 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8447 }
8448 }
8449 }
8450 deserializer.deserialize_identifier(GeneratedVisitor)
8451 }
8452 }
8453 struct GeneratedVisitor;
8454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8455 type Value = list_actor_states_response::ActorState;
8456
8457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8458 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8459 }
8460
8461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8462 where
8463 V: serde::de::MapAccess<'de>,
8464 {
8465 let mut actor_id__ = None;
8466 let mut fragment_id__ = None;
8467 let mut worker_id__ = None;
8468 while let Some(k) = map_.next_key()? {
8469 match k {
8470 GeneratedField::ActorId => {
8471 if actor_id__.is_some() {
8472 return Err(serde::de::Error::duplicate_field("actorId"));
8473 }
8474 actor_id__ =
8475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8476 ;
8477 }
8478 GeneratedField::FragmentId => {
8479 if fragment_id__.is_some() {
8480 return Err(serde::de::Error::duplicate_field("fragmentId"));
8481 }
8482 fragment_id__ =
8483 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8484 ;
8485 }
8486 GeneratedField::WorkerId => {
8487 if worker_id__.is_some() {
8488 return Err(serde::de::Error::duplicate_field("workerId"));
8489 }
8490 worker_id__ =
8491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8492 ;
8493 }
8494 }
8495 }
8496 Ok(list_actor_states_response::ActorState {
8497 actor_id: actor_id__.unwrap_or_default(),
8498 fragment_id: fragment_id__.unwrap_or_default(),
8499 worker_id: worker_id__.unwrap_or_default(),
8500 })
8501 }
8502 }
8503 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8504 }
8505}
8506impl serde::Serialize for ListAllNodesRequest {
8507 #[allow(deprecated)]
8508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8509 where
8510 S: serde::Serializer,
8511 {
8512 use serde::ser::SerializeStruct;
8513 let mut len = 0;
8514 if self.worker_type.is_some() {
8515 len += 1;
8516 }
8517 if self.include_starting_nodes {
8518 len += 1;
8519 }
8520 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8521 if let Some(v) = self.worker_type.as_ref() {
8522 let v = super::common::WorkerType::try_from(*v)
8523 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8524 struct_ser.serialize_field("workerType", &v)?;
8525 }
8526 if self.include_starting_nodes {
8527 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8528 }
8529 struct_ser.end()
8530 }
8531}
8532impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8533 #[allow(deprecated)]
8534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8535 where
8536 D: serde::Deserializer<'de>,
8537 {
8538 const FIELDS: &[&str] = &[
8539 "worker_type",
8540 "workerType",
8541 "include_starting_nodes",
8542 "includeStartingNodes",
8543 ];
8544
8545 #[allow(clippy::enum_variant_names)]
8546 enum GeneratedField {
8547 WorkerType,
8548 IncludeStartingNodes,
8549 }
8550 impl<'de> serde::Deserialize<'de> for GeneratedField {
8551 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8552 where
8553 D: serde::Deserializer<'de>,
8554 {
8555 struct GeneratedVisitor;
8556
8557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8558 type Value = GeneratedField;
8559
8560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8561 write!(formatter, "expected one of: {:?}", &FIELDS)
8562 }
8563
8564 #[allow(unused_variables)]
8565 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8566 where
8567 E: serde::de::Error,
8568 {
8569 match value {
8570 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8571 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8572 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8573 }
8574 }
8575 }
8576 deserializer.deserialize_identifier(GeneratedVisitor)
8577 }
8578 }
8579 struct GeneratedVisitor;
8580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8581 type Value = ListAllNodesRequest;
8582
8583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8584 formatter.write_str("struct meta.ListAllNodesRequest")
8585 }
8586
8587 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8588 where
8589 V: serde::de::MapAccess<'de>,
8590 {
8591 let mut worker_type__ = None;
8592 let mut include_starting_nodes__ = None;
8593 while let Some(k) = map_.next_key()? {
8594 match k {
8595 GeneratedField::WorkerType => {
8596 if worker_type__.is_some() {
8597 return Err(serde::de::Error::duplicate_field("workerType"));
8598 }
8599 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8600 }
8601 GeneratedField::IncludeStartingNodes => {
8602 if include_starting_nodes__.is_some() {
8603 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8604 }
8605 include_starting_nodes__ = Some(map_.next_value()?);
8606 }
8607 }
8608 }
8609 Ok(ListAllNodesRequest {
8610 worker_type: worker_type__,
8611 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8612 })
8613 }
8614 }
8615 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8616 }
8617}
8618impl serde::Serialize for ListAllNodesResponse {
8619 #[allow(deprecated)]
8620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8621 where
8622 S: serde::Serializer,
8623 {
8624 use serde::ser::SerializeStruct;
8625 let mut len = 0;
8626 if self.status.is_some() {
8627 len += 1;
8628 }
8629 if !self.nodes.is_empty() {
8630 len += 1;
8631 }
8632 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8633 if let Some(v) = self.status.as_ref() {
8634 struct_ser.serialize_field("status", v)?;
8635 }
8636 if !self.nodes.is_empty() {
8637 struct_ser.serialize_field("nodes", &self.nodes)?;
8638 }
8639 struct_ser.end()
8640 }
8641}
8642impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8643 #[allow(deprecated)]
8644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8645 where
8646 D: serde::Deserializer<'de>,
8647 {
8648 const FIELDS: &[&str] = &[
8649 "status",
8650 "nodes",
8651 ];
8652
8653 #[allow(clippy::enum_variant_names)]
8654 enum GeneratedField {
8655 Status,
8656 Nodes,
8657 }
8658 impl<'de> serde::Deserialize<'de> for GeneratedField {
8659 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8660 where
8661 D: serde::Deserializer<'de>,
8662 {
8663 struct GeneratedVisitor;
8664
8665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8666 type Value = GeneratedField;
8667
8668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8669 write!(formatter, "expected one of: {:?}", &FIELDS)
8670 }
8671
8672 #[allow(unused_variables)]
8673 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8674 where
8675 E: serde::de::Error,
8676 {
8677 match value {
8678 "status" => Ok(GeneratedField::Status),
8679 "nodes" => Ok(GeneratedField::Nodes),
8680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8681 }
8682 }
8683 }
8684 deserializer.deserialize_identifier(GeneratedVisitor)
8685 }
8686 }
8687 struct GeneratedVisitor;
8688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8689 type Value = ListAllNodesResponse;
8690
8691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8692 formatter.write_str("struct meta.ListAllNodesResponse")
8693 }
8694
8695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8696 where
8697 V: serde::de::MapAccess<'de>,
8698 {
8699 let mut status__ = None;
8700 let mut nodes__ = None;
8701 while let Some(k) = map_.next_key()? {
8702 match k {
8703 GeneratedField::Status => {
8704 if status__.is_some() {
8705 return Err(serde::de::Error::duplicate_field("status"));
8706 }
8707 status__ = map_.next_value()?;
8708 }
8709 GeneratedField::Nodes => {
8710 if nodes__.is_some() {
8711 return Err(serde::de::Error::duplicate_field("nodes"));
8712 }
8713 nodes__ = Some(map_.next_value()?);
8714 }
8715 }
8716 }
8717 Ok(ListAllNodesResponse {
8718 status: status__,
8719 nodes: nodes__.unwrap_or_default(),
8720 })
8721 }
8722 }
8723 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8724 }
8725}
8726impl serde::Serialize for ListCdcProgressRequest {
8727 #[allow(deprecated)]
8728 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8729 where
8730 S: serde::Serializer,
8731 {
8732 use serde::ser::SerializeStruct;
8733 let len = 0;
8734 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
8735 struct_ser.end()
8736 }
8737}
8738impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
8739 #[allow(deprecated)]
8740 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8741 where
8742 D: serde::Deserializer<'de>,
8743 {
8744 const FIELDS: &[&str] = &[
8745 ];
8746
8747 #[allow(clippy::enum_variant_names)]
8748 enum GeneratedField {
8749 }
8750 impl<'de> serde::Deserialize<'de> for GeneratedField {
8751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8752 where
8753 D: serde::Deserializer<'de>,
8754 {
8755 struct GeneratedVisitor;
8756
8757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8758 type Value = GeneratedField;
8759
8760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8761 write!(formatter, "expected one of: {:?}", &FIELDS)
8762 }
8763
8764 #[allow(unused_variables)]
8765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8766 where
8767 E: serde::de::Error,
8768 {
8769 Err(serde::de::Error::unknown_field(value, FIELDS))
8770 }
8771 }
8772 deserializer.deserialize_identifier(GeneratedVisitor)
8773 }
8774 }
8775 struct GeneratedVisitor;
8776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8777 type Value = ListCdcProgressRequest;
8778
8779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8780 formatter.write_str("struct meta.ListCdcProgressRequest")
8781 }
8782
8783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
8784 where
8785 V: serde::de::MapAccess<'de>,
8786 {
8787 while map_.next_key::<GeneratedField>()?.is_some() {
8788 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8789 }
8790 Ok(ListCdcProgressRequest {
8791 })
8792 }
8793 }
8794 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
8795 }
8796}
8797impl serde::Serialize for ListCdcProgressResponse {
8798 #[allow(deprecated)]
8799 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8800 where
8801 S: serde::Serializer,
8802 {
8803 use serde::ser::SerializeStruct;
8804 let mut len = 0;
8805 if !self.cdc_progress.is_empty() {
8806 len += 1;
8807 }
8808 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
8809 if !self.cdc_progress.is_empty() {
8810 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
8811 }
8812 struct_ser.end()
8813 }
8814}
8815impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
8816 #[allow(deprecated)]
8817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8818 where
8819 D: serde::Deserializer<'de>,
8820 {
8821 const FIELDS: &[&str] = &[
8822 "cdc_progress",
8823 "cdcProgress",
8824 ];
8825
8826 #[allow(clippy::enum_variant_names)]
8827 enum GeneratedField {
8828 CdcProgress,
8829 }
8830 impl<'de> serde::Deserialize<'de> for GeneratedField {
8831 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8832 where
8833 D: serde::Deserializer<'de>,
8834 {
8835 struct GeneratedVisitor;
8836
8837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8838 type Value = GeneratedField;
8839
8840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8841 write!(formatter, "expected one of: {:?}", &FIELDS)
8842 }
8843
8844 #[allow(unused_variables)]
8845 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8846 where
8847 E: serde::de::Error,
8848 {
8849 match value {
8850 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
8851 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8852 }
8853 }
8854 }
8855 deserializer.deserialize_identifier(GeneratedVisitor)
8856 }
8857 }
8858 struct GeneratedVisitor;
8859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8860 type Value = ListCdcProgressResponse;
8861
8862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8863 formatter.write_str("struct meta.ListCdcProgressResponse")
8864 }
8865
8866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
8867 where
8868 V: serde::de::MapAccess<'de>,
8869 {
8870 let mut cdc_progress__ = None;
8871 while let Some(k) = map_.next_key()? {
8872 match k {
8873 GeneratedField::CdcProgress => {
8874 if cdc_progress__.is_some() {
8875 return Err(serde::de::Error::duplicate_field("cdcProgress"));
8876 }
8877 cdc_progress__ = Some(
8878 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8879 .into_iter().map(|(k,v)| (k.0, v)).collect()
8880 );
8881 }
8882 }
8883 }
8884 Ok(ListCdcProgressResponse {
8885 cdc_progress: cdc_progress__.unwrap_or_default(),
8886 })
8887 }
8888 }
8889 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
8890 }
8891}
8892impl serde::Serialize for list_cdc_progress_response::CdcProgress {
8893 #[allow(deprecated)]
8894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8895 where
8896 S: serde::Serializer,
8897 {
8898 use serde::ser::SerializeStruct;
8899 let mut len = 0;
8900 if self.split_total_count != 0 {
8901 len += 1;
8902 }
8903 if self.split_backfilled_count != 0 {
8904 len += 1;
8905 }
8906 if self.split_completed_count != 0 {
8907 len += 1;
8908 }
8909 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
8910 if self.split_total_count != 0 {
8911 #[allow(clippy::needless_borrow)]
8912 #[allow(clippy::needless_borrows_for_generic_args)]
8913 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
8914 }
8915 if self.split_backfilled_count != 0 {
8916 #[allow(clippy::needless_borrow)]
8917 #[allow(clippy::needless_borrows_for_generic_args)]
8918 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
8919 }
8920 if self.split_completed_count != 0 {
8921 #[allow(clippy::needless_borrow)]
8922 #[allow(clippy::needless_borrows_for_generic_args)]
8923 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
8924 }
8925 struct_ser.end()
8926 }
8927}
8928impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
8929 #[allow(deprecated)]
8930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8931 where
8932 D: serde::Deserializer<'de>,
8933 {
8934 const FIELDS: &[&str] = &[
8935 "split_total_count",
8936 "splitTotalCount",
8937 "split_backfilled_count",
8938 "splitBackfilledCount",
8939 "split_completed_count",
8940 "splitCompletedCount",
8941 ];
8942
8943 #[allow(clippy::enum_variant_names)]
8944 enum GeneratedField {
8945 SplitTotalCount,
8946 SplitBackfilledCount,
8947 SplitCompletedCount,
8948 }
8949 impl<'de> serde::Deserialize<'de> for GeneratedField {
8950 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8951 where
8952 D: serde::Deserializer<'de>,
8953 {
8954 struct GeneratedVisitor;
8955
8956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8957 type Value = GeneratedField;
8958
8959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8960 write!(formatter, "expected one of: {:?}", &FIELDS)
8961 }
8962
8963 #[allow(unused_variables)]
8964 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8965 where
8966 E: serde::de::Error,
8967 {
8968 match value {
8969 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
8970 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
8971 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
8972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8973 }
8974 }
8975 }
8976 deserializer.deserialize_identifier(GeneratedVisitor)
8977 }
8978 }
8979 struct GeneratedVisitor;
8980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8981 type Value = list_cdc_progress_response::CdcProgress;
8982
8983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8984 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
8985 }
8986
8987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
8988 where
8989 V: serde::de::MapAccess<'de>,
8990 {
8991 let mut split_total_count__ = None;
8992 let mut split_backfilled_count__ = None;
8993 let mut split_completed_count__ = None;
8994 while let Some(k) = map_.next_key()? {
8995 match k {
8996 GeneratedField::SplitTotalCount => {
8997 if split_total_count__.is_some() {
8998 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
8999 }
9000 split_total_count__ =
9001 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9002 ;
9003 }
9004 GeneratedField::SplitBackfilledCount => {
9005 if split_backfilled_count__.is_some() {
9006 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9007 }
9008 split_backfilled_count__ =
9009 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9010 ;
9011 }
9012 GeneratedField::SplitCompletedCount => {
9013 if split_completed_count__.is_some() {
9014 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9015 }
9016 split_completed_count__ =
9017 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9018 ;
9019 }
9020 }
9021 }
9022 Ok(list_cdc_progress_response::CdcProgress {
9023 split_total_count: split_total_count__.unwrap_or_default(),
9024 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
9025 split_completed_count: split_completed_count__.unwrap_or_default(),
9026 })
9027 }
9028 }
9029 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
9030 }
9031}
9032impl serde::Serialize for ListCreatingFragmentDistributionRequest {
9033 #[allow(deprecated)]
9034 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9035 where
9036 S: serde::Serializer,
9037 {
9038 use serde::ser::SerializeStruct;
9039 let len = 0;
9040 let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
9041 struct_ser.end()
9042 }
9043}
9044impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
9045 #[allow(deprecated)]
9046 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9047 where
9048 D: serde::Deserializer<'de>,
9049 {
9050 const FIELDS: &[&str] = &[
9051 ];
9052
9053 #[allow(clippy::enum_variant_names)]
9054 enum GeneratedField {
9055 }
9056 impl<'de> serde::Deserialize<'de> for GeneratedField {
9057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9058 where
9059 D: serde::Deserializer<'de>,
9060 {
9061 struct GeneratedVisitor;
9062
9063 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9064 type Value = GeneratedField;
9065
9066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9067 write!(formatter, "expected one of: {:?}", &FIELDS)
9068 }
9069
9070 #[allow(unused_variables)]
9071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9072 where
9073 E: serde::de::Error,
9074 {
9075 Err(serde::de::Error::unknown_field(value, FIELDS))
9076 }
9077 }
9078 deserializer.deserialize_identifier(GeneratedVisitor)
9079 }
9080 }
9081 struct GeneratedVisitor;
9082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9083 type Value = ListCreatingFragmentDistributionRequest;
9084
9085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9086 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
9087 }
9088
9089 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
9090 where
9091 V: serde::de::MapAccess<'de>,
9092 {
9093 while map_.next_key::<GeneratedField>()?.is_some() {
9094 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9095 }
9096 Ok(ListCreatingFragmentDistributionRequest {
9097 })
9098 }
9099 }
9100 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9101 }
9102}
9103impl serde::Serialize for ListCreatingFragmentDistributionResponse {
9104 #[allow(deprecated)]
9105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9106 where
9107 S: serde::Serializer,
9108 {
9109 use serde::ser::SerializeStruct;
9110 let mut len = 0;
9111 if !self.distributions.is_empty() {
9112 len += 1;
9113 }
9114 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
9115 if !self.distributions.is_empty() {
9116 struct_ser.serialize_field("distributions", &self.distributions)?;
9117 }
9118 struct_ser.end()
9119 }
9120}
9121impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
9122 #[allow(deprecated)]
9123 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9124 where
9125 D: serde::Deserializer<'de>,
9126 {
9127 const FIELDS: &[&str] = &[
9128 "distributions",
9129 ];
9130
9131 #[allow(clippy::enum_variant_names)]
9132 enum GeneratedField {
9133 Distributions,
9134 }
9135 impl<'de> serde::Deserialize<'de> for GeneratedField {
9136 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9137 where
9138 D: serde::Deserializer<'de>,
9139 {
9140 struct GeneratedVisitor;
9141
9142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9143 type Value = GeneratedField;
9144
9145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9146 write!(formatter, "expected one of: {:?}", &FIELDS)
9147 }
9148
9149 #[allow(unused_variables)]
9150 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9151 where
9152 E: serde::de::Error,
9153 {
9154 match value {
9155 "distributions" => Ok(GeneratedField::Distributions),
9156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9157 }
9158 }
9159 }
9160 deserializer.deserialize_identifier(GeneratedVisitor)
9161 }
9162 }
9163 struct GeneratedVisitor;
9164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9165 type Value = ListCreatingFragmentDistributionResponse;
9166
9167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9168 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
9169 }
9170
9171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
9172 where
9173 V: serde::de::MapAccess<'de>,
9174 {
9175 let mut distributions__ = None;
9176 while let Some(k) = map_.next_key()? {
9177 match k {
9178 GeneratedField::Distributions => {
9179 if distributions__.is_some() {
9180 return Err(serde::de::Error::duplicate_field("distributions"));
9181 }
9182 distributions__ = Some(map_.next_value()?);
9183 }
9184 }
9185 }
9186 Ok(ListCreatingFragmentDistributionResponse {
9187 distributions: distributions__.unwrap_or_default(),
9188 })
9189 }
9190 }
9191 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9192 }
9193}
9194impl serde::Serialize for ListEventLogRequest {
9195 #[allow(deprecated)]
9196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9197 where
9198 S: serde::Serializer,
9199 {
9200 use serde::ser::SerializeStruct;
9201 let len = 0;
9202 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
9203 struct_ser.end()
9204 }
9205}
9206impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
9207 #[allow(deprecated)]
9208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9209 where
9210 D: serde::Deserializer<'de>,
9211 {
9212 const FIELDS: &[&str] = &[
9213 ];
9214
9215 #[allow(clippy::enum_variant_names)]
9216 enum GeneratedField {
9217 }
9218 impl<'de> serde::Deserialize<'de> for GeneratedField {
9219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9220 where
9221 D: serde::Deserializer<'de>,
9222 {
9223 struct GeneratedVisitor;
9224
9225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9226 type Value = GeneratedField;
9227
9228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9229 write!(formatter, "expected one of: {:?}", &FIELDS)
9230 }
9231
9232 #[allow(unused_variables)]
9233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9234 where
9235 E: serde::de::Error,
9236 {
9237 Err(serde::de::Error::unknown_field(value, FIELDS))
9238 }
9239 }
9240 deserializer.deserialize_identifier(GeneratedVisitor)
9241 }
9242 }
9243 struct GeneratedVisitor;
9244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9245 type Value = ListEventLogRequest;
9246
9247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9248 formatter.write_str("struct meta.ListEventLogRequest")
9249 }
9250
9251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
9252 where
9253 V: serde::de::MapAccess<'de>,
9254 {
9255 while map_.next_key::<GeneratedField>()?.is_some() {
9256 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9257 }
9258 Ok(ListEventLogRequest {
9259 })
9260 }
9261 }
9262 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
9263 }
9264}
9265impl serde::Serialize for ListEventLogResponse {
9266 #[allow(deprecated)]
9267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9268 where
9269 S: serde::Serializer,
9270 {
9271 use serde::ser::SerializeStruct;
9272 let mut len = 0;
9273 if !self.event_logs.is_empty() {
9274 len += 1;
9275 }
9276 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
9277 if !self.event_logs.is_empty() {
9278 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
9279 }
9280 struct_ser.end()
9281 }
9282}
9283impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
9284 #[allow(deprecated)]
9285 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9286 where
9287 D: serde::Deserializer<'de>,
9288 {
9289 const FIELDS: &[&str] = &[
9290 "event_logs",
9291 "eventLogs",
9292 ];
9293
9294 #[allow(clippy::enum_variant_names)]
9295 enum GeneratedField {
9296 EventLogs,
9297 }
9298 impl<'de> serde::Deserialize<'de> for GeneratedField {
9299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9300 where
9301 D: serde::Deserializer<'de>,
9302 {
9303 struct GeneratedVisitor;
9304
9305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9306 type Value = GeneratedField;
9307
9308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9309 write!(formatter, "expected one of: {:?}", &FIELDS)
9310 }
9311
9312 #[allow(unused_variables)]
9313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9314 where
9315 E: serde::de::Error,
9316 {
9317 match value {
9318 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
9319 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9320 }
9321 }
9322 }
9323 deserializer.deserialize_identifier(GeneratedVisitor)
9324 }
9325 }
9326 struct GeneratedVisitor;
9327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9328 type Value = ListEventLogResponse;
9329
9330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9331 formatter.write_str("struct meta.ListEventLogResponse")
9332 }
9333
9334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
9335 where
9336 V: serde::de::MapAccess<'de>,
9337 {
9338 let mut event_logs__ = None;
9339 while let Some(k) = map_.next_key()? {
9340 match k {
9341 GeneratedField::EventLogs => {
9342 if event_logs__.is_some() {
9343 return Err(serde::de::Error::duplicate_field("eventLogs"));
9344 }
9345 event_logs__ = Some(map_.next_value()?);
9346 }
9347 }
9348 }
9349 Ok(ListEventLogResponse {
9350 event_logs: event_logs__.unwrap_or_default(),
9351 })
9352 }
9353 }
9354 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
9355 }
9356}
9357impl serde::Serialize for ListFragmentDistributionRequest {
9358 #[allow(deprecated)]
9359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9360 where
9361 S: serde::Serializer,
9362 {
9363 use serde::ser::SerializeStruct;
9364 let len = 0;
9365 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
9366 struct_ser.end()
9367 }
9368}
9369impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
9370 #[allow(deprecated)]
9371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9372 where
9373 D: serde::Deserializer<'de>,
9374 {
9375 const FIELDS: &[&str] = &[
9376 ];
9377
9378 #[allow(clippy::enum_variant_names)]
9379 enum GeneratedField {
9380 }
9381 impl<'de> serde::Deserialize<'de> for GeneratedField {
9382 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9383 where
9384 D: serde::Deserializer<'de>,
9385 {
9386 struct GeneratedVisitor;
9387
9388 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9389 type Value = GeneratedField;
9390
9391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9392 write!(formatter, "expected one of: {:?}", &FIELDS)
9393 }
9394
9395 #[allow(unused_variables)]
9396 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9397 where
9398 E: serde::de::Error,
9399 {
9400 Err(serde::de::Error::unknown_field(value, FIELDS))
9401 }
9402 }
9403 deserializer.deserialize_identifier(GeneratedVisitor)
9404 }
9405 }
9406 struct GeneratedVisitor;
9407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9408 type Value = ListFragmentDistributionRequest;
9409
9410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9411 formatter.write_str("struct meta.ListFragmentDistributionRequest")
9412 }
9413
9414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
9415 where
9416 V: serde::de::MapAccess<'de>,
9417 {
9418 while map_.next_key::<GeneratedField>()?.is_some() {
9419 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9420 }
9421 Ok(ListFragmentDistributionRequest {
9422 })
9423 }
9424 }
9425 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9426 }
9427}
9428impl serde::Serialize for ListFragmentDistributionResponse {
9429 #[allow(deprecated)]
9430 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9431 where
9432 S: serde::Serializer,
9433 {
9434 use serde::ser::SerializeStruct;
9435 let mut len = 0;
9436 if !self.distributions.is_empty() {
9437 len += 1;
9438 }
9439 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
9440 if !self.distributions.is_empty() {
9441 struct_ser.serialize_field("distributions", &self.distributions)?;
9442 }
9443 struct_ser.end()
9444 }
9445}
9446impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
9447 #[allow(deprecated)]
9448 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9449 where
9450 D: serde::Deserializer<'de>,
9451 {
9452 const FIELDS: &[&str] = &[
9453 "distributions",
9454 ];
9455
9456 #[allow(clippy::enum_variant_names)]
9457 enum GeneratedField {
9458 Distributions,
9459 }
9460 impl<'de> serde::Deserialize<'de> for GeneratedField {
9461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9462 where
9463 D: serde::Deserializer<'de>,
9464 {
9465 struct GeneratedVisitor;
9466
9467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9468 type Value = GeneratedField;
9469
9470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9471 write!(formatter, "expected one of: {:?}", &FIELDS)
9472 }
9473
9474 #[allow(unused_variables)]
9475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9476 where
9477 E: serde::de::Error,
9478 {
9479 match value {
9480 "distributions" => Ok(GeneratedField::Distributions),
9481 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9482 }
9483 }
9484 }
9485 deserializer.deserialize_identifier(GeneratedVisitor)
9486 }
9487 }
9488 struct GeneratedVisitor;
9489 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9490 type Value = ListFragmentDistributionResponse;
9491
9492 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9493 formatter.write_str("struct meta.ListFragmentDistributionResponse")
9494 }
9495
9496 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9497 where
9498 V: serde::de::MapAccess<'de>,
9499 {
9500 let mut distributions__ = None;
9501 while let Some(k) = map_.next_key()? {
9502 match k {
9503 GeneratedField::Distributions => {
9504 if distributions__.is_some() {
9505 return Err(serde::de::Error::duplicate_field("distributions"));
9506 }
9507 distributions__ = Some(map_.next_value()?);
9508 }
9509 }
9510 }
9511 Ok(ListFragmentDistributionResponse {
9512 distributions: distributions__.unwrap_or_default(),
9513 })
9514 }
9515 }
9516 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9517 }
9518}
9519impl serde::Serialize for ListIcebergTablesRequest {
9520 #[allow(deprecated)]
9521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9522 where
9523 S: serde::Serializer,
9524 {
9525 use serde::ser::SerializeStruct;
9526 let len = 0;
9527 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
9528 struct_ser.end()
9529 }
9530}
9531impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
9532 #[allow(deprecated)]
9533 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9534 where
9535 D: serde::Deserializer<'de>,
9536 {
9537 const FIELDS: &[&str] = &[
9538 ];
9539
9540 #[allow(clippy::enum_variant_names)]
9541 enum GeneratedField {
9542 }
9543 impl<'de> serde::Deserialize<'de> for GeneratedField {
9544 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9545 where
9546 D: serde::Deserializer<'de>,
9547 {
9548 struct GeneratedVisitor;
9549
9550 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9551 type Value = GeneratedField;
9552
9553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9554 write!(formatter, "expected one of: {:?}", &FIELDS)
9555 }
9556
9557 #[allow(unused_variables)]
9558 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9559 where
9560 E: serde::de::Error,
9561 {
9562 Err(serde::de::Error::unknown_field(value, FIELDS))
9563 }
9564 }
9565 deserializer.deserialize_identifier(GeneratedVisitor)
9566 }
9567 }
9568 struct GeneratedVisitor;
9569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9570 type Value = ListIcebergTablesRequest;
9571
9572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9573 formatter.write_str("struct meta.ListIcebergTablesRequest")
9574 }
9575
9576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
9577 where
9578 V: serde::de::MapAccess<'de>,
9579 {
9580 while map_.next_key::<GeneratedField>()?.is_some() {
9581 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9582 }
9583 Ok(ListIcebergTablesRequest {
9584 })
9585 }
9586 }
9587 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
9588 }
9589}
9590impl serde::Serialize for ListIcebergTablesResponse {
9591 #[allow(deprecated)]
9592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9593 where
9594 S: serde::Serializer,
9595 {
9596 use serde::ser::SerializeStruct;
9597 let mut len = 0;
9598 if !self.iceberg_tables.is_empty() {
9599 len += 1;
9600 }
9601 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
9602 if !self.iceberg_tables.is_empty() {
9603 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
9604 }
9605 struct_ser.end()
9606 }
9607}
9608impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
9609 #[allow(deprecated)]
9610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9611 where
9612 D: serde::Deserializer<'de>,
9613 {
9614 const FIELDS: &[&str] = &[
9615 "iceberg_tables",
9616 "icebergTables",
9617 ];
9618
9619 #[allow(clippy::enum_variant_names)]
9620 enum GeneratedField {
9621 IcebergTables,
9622 }
9623 impl<'de> serde::Deserialize<'de> for GeneratedField {
9624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9625 where
9626 D: serde::Deserializer<'de>,
9627 {
9628 struct GeneratedVisitor;
9629
9630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9631 type Value = GeneratedField;
9632
9633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9634 write!(formatter, "expected one of: {:?}", &FIELDS)
9635 }
9636
9637 #[allow(unused_variables)]
9638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9639 where
9640 E: serde::de::Error,
9641 {
9642 match value {
9643 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9644 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9645 }
9646 }
9647 }
9648 deserializer.deserialize_identifier(GeneratedVisitor)
9649 }
9650 }
9651 struct GeneratedVisitor;
9652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9653 type Value = ListIcebergTablesResponse;
9654
9655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9656 formatter.write_str("struct meta.ListIcebergTablesResponse")
9657 }
9658
9659 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9660 where
9661 V: serde::de::MapAccess<'de>,
9662 {
9663 let mut iceberg_tables__ = None;
9664 while let Some(k) = map_.next_key()? {
9665 match k {
9666 GeneratedField::IcebergTables => {
9667 if iceberg_tables__.is_some() {
9668 return Err(serde::de::Error::duplicate_field("icebergTables"));
9669 }
9670 iceberg_tables__ = Some(map_.next_value()?);
9671 }
9672 }
9673 }
9674 Ok(ListIcebergTablesResponse {
9675 iceberg_tables: iceberg_tables__.unwrap_or_default(),
9676 })
9677 }
9678 }
9679 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9680 }
9681}
9682impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9683 #[allow(deprecated)]
9684 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9685 where
9686 S: serde::Serializer,
9687 {
9688 use serde::ser::SerializeStruct;
9689 let mut len = 0;
9690 if !self.catalog_name.is_empty() {
9691 len += 1;
9692 }
9693 if !self.table_namespace.is_empty() {
9694 len += 1;
9695 }
9696 if !self.table_name.is_empty() {
9697 len += 1;
9698 }
9699 if self.metadata_location.is_some() {
9700 len += 1;
9701 }
9702 if self.previous_metadata_location.is_some() {
9703 len += 1;
9704 }
9705 if self.iceberg_type.is_some() {
9706 len += 1;
9707 }
9708 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9709 if !self.catalog_name.is_empty() {
9710 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9711 }
9712 if !self.table_namespace.is_empty() {
9713 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9714 }
9715 if !self.table_name.is_empty() {
9716 struct_ser.serialize_field("tableName", &self.table_name)?;
9717 }
9718 if let Some(v) = self.metadata_location.as_ref() {
9719 struct_ser.serialize_field("metadataLocation", v)?;
9720 }
9721 if let Some(v) = self.previous_metadata_location.as_ref() {
9722 struct_ser.serialize_field("previousMetadataLocation", v)?;
9723 }
9724 if let Some(v) = self.iceberg_type.as_ref() {
9725 struct_ser.serialize_field("icebergType", v)?;
9726 }
9727 struct_ser.end()
9728 }
9729}
9730impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9731 #[allow(deprecated)]
9732 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9733 where
9734 D: serde::Deserializer<'de>,
9735 {
9736 const FIELDS: &[&str] = &[
9737 "catalog_name",
9738 "catalogName",
9739 "table_namespace",
9740 "tableNamespace",
9741 "table_name",
9742 "tableName",
9743 "metadata_location",
9744 "metadataLocation",
9745 "previous_metadata_location",
9746 "previousMetadataLocation",
9747 "iceberg_type",
9748 "icebergType",
9749 ];
9750
9751 #[allow(clippy::enum_variant_names)]
9752 enum GeneratedField {
9753 CatalogName,
9754 TableNamespace,
9755 TableName,
9756 MetadataLocation,
9757 PreviousMetadataLocation,
9758 IcebergType,
9759 }
9760 impl<'de> serde::Deserialize<'de> for GeneratedField {
9761 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9762 where
9763 D: serde::Deserializer<'de>,
9764 {
9765 struct GeneratedVisitor;
9766
9767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9768 type Value = GeneratedField;
9769
9770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9771 write!(formatter, "expected one of: {:?}", &FIELDS)
9772 }
9773
9774 #[allow(unused_variables)]
9775 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9776 where
9777 E: serde::de::Error,
9778 {
9779 match value {
9780 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9781 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9782 "tableName" | "table_name" => Ok(GeneratedField::TableName),
9783 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9784 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9785 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9786 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9787 }
9788 }
9789 }
9790 deserializer.deserialize_identifier(GeneratedVisitor)
9791 }
9792 }
9793 struct GeneratedVisitor;
9794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9795 type Value = list_iceberg_tables_response::IcebergTable;
9796
9797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9798 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9799 }
9800
9801 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9802 where
9803 V: serde::de::MapAccess<'de>,
9804 {
9805 let mut catalog_name__ = None;
9806 let mut table_namespace__ = None;
9807 let mut table_name__ = None;
9808 let mut metadata_location__ = None;
9809 let mut previous_metadata_location__ = None;
9810 let mut iceberg_type__ = None;
9811 while let Some(k) = map_.next_key()? {
9812 match k {
9813 GeneratedField::CatalogName => {
9814 if catalog_name__.is_some() {
9815 return Err(serde::de::Error::duplicate_field("catalogName"));
9816 }
9817 catalog_name__ = Some(map_.next_value()?);
9818 }
9819 GeneratedField::TableNamespace => {
9820 if table_namespace__.is_some() {
9821 return Err(serde::de::Error::duplicate_field("tableNamespace"));
9822 }
9823 table_namespace__ = Some(map_.next_value()?);
9824 }
9825 GeneratedField::TableName => {
9826 if table_name__.is_some() {
9827 return Err(serde::de::Error::duplicate_field("tableName"));
9828 }
9829 table_name__ = Some(map_.next_value()?);
9830 }
9831 GeneratedField::MetadataLocation => {
9832 if metadata_location__.is_some() {
9833 return Err(serde::de::Error::duplicate_field("metadataLocation"));
9834 }
9835 metadata_location__ = map_.next_value()?;
9836 }
9837 GeneratedField::PreviousMetadataLocation => {
9838 if previous_metadata_location__.is_some() {
9839 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9840 }
9841 previous_metadata_location__ = map_.next_value()?;
9842 }
9843 GeneratedField::IcebergType => {
9844 if iceberg_type__.is_some() {
9845 return Err(serde::de::Error::duplicate_field("icebergType"));
9846 }
9847 iceberg_type__ = map_.next_value()?;
9848 }
9849 }
9850 }
9851 Ok(list_iceberg_tables_response::IcebergTable {
9852 catalog_name: catalog_name__.unwrap_or_default(),
9853 table_namespace: table_namespace__.unwrap_or_default(),
9854 table_name: table_name__.unwrap_or_default(),
9855 metadata_location: metadata_location__,
9856 previous_metadata_location: previous_metadata_location__,
9857 iceberg_type: iceberg_type__,
9858 })
9859 }
9860 }
9861 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9862 }
9863}
9864impl serde::Serialize for ListObjectDependenciesRequest {
9865 #[allow(deprecated)]
9866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9867 where
9868 S: serde::Serializer,
9869 {
9870 use serde::ser::SerializeStruct;
9871 let len = 0;
9872 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9873 struct_ser.end()
9874 }
9875}
9876impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9877 #[allow(deprecated)]
9878 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9879 where
9880 D: serde::Deserializer<'de>,
9881 {
9882 const FIELDS: &[&str] = &[
9883 ];
9884
9885 #[allow(clippy::enum_variant_names)]
9886 enum GeneratedField {
9887 }
9888 impl<'de> serde::Deserialize<'de> for GeneratedField {
9889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9890 where
9891 D: serde::Deserializer<'de>,
9892 {
9893 struct GeneratedVisitor;
9894
9895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9896 type Value = GeneratedField;
9897
9898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9899 write!(formatter, "expected one of: {:?}", &FIELDS)
9900 }
9901
9902 #[allow(unused_variables)]
9903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9904 where
9905 E: serde::de::Error,
9906 {
9907 Err(serde::de::Error::unknown_field(value, FIELDS))
9908 }
9909 }
9910 deserializer.deserialize_identifier(GeneratedVisitor)
9911 }
9912 }
9913 struct GeneratedVisitor;
9914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9915 type Value = ListObjectDependenciesRequest;
9916
9917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9918 formatter.write_str("struct meta.ListObjectDependenciesRequest")
9919 }
9920
9921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9922 where
9923 V: serde::de::MapAccess<'de>,
9924 {
9925 while map_.next_key::<GeneratedField>()?.is_some() {
9926 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9927 }
9928 Ok(ListObjectDependenciesRequest {
9929 })
9930 }
9931 }
9932 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9933 }
9934}
9935impl serde::Serialize for ListObjectDependenciesResponse {
9936 #[allow(deprecated)]
9937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9938 where
9939 S: serde::Serializer,
9940 {
9941 use serde::ser::SerializeStruct;
9942 let mut len = 0;
9943 if !self.dependencies.is_empty() {
9944 len += 1;
9945 }
9946 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9947 if !self.dependencies.is_empty() {
9948 struct_ser.serialize_field("dependencies", &self.dependencies)?;
9949 }
9950 struct_ser.end()
9951 }
9952}
9953impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9954 #[allow(deprecated)]
9955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9956 where
9957 D: serde::Deserializer<'de>,
9958 {
9959 const FIELDS: &[&str] = &[
9960 "dependencies",
9961 ];
9962
9963 #[allow(clippy::enum_variant_names)]
9964 enum GeneratedField {
9965 Dependencies,
9966 }
9967 impl<'de> serde::Deserialize<'de> for GeneratedField {
9968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9969 where
9970 D: serde::Deserializer<'de>,
9971 {
9972 struct GeneratedVisitor;
9973
9974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9975 type Value = GeneratedField;
9976
9977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9978 write!(formatter, "expected one of: {:?}", &FIELDS)
9979 }
9980
9981 #[allow(unused_variables)]
9982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9983 where
9984 E: serde::de::Error,
9985 {
9986 match value {
9987 "dependencies" => Ok(GeneratedField::Dependencies),
9988 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9989 }
9990 }
9991 }
9992 deserializer.deserialize_identifier(GeneratedVisitor)
9993 }
9994 }
9995 struct GeneratedVisitor;
9996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9997 type Value = ListObjectDependenciesResponse;
9998
9999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10000 formatter.write_str("struct meta.ListObjectDependenciesResponse")
10001 }
10002
10003 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
10004 where
10005 V: serde::de::MapAccess<'de>,
10006 {
10007 let mut dependencies__ = None;
10008 while let Some(k) = map_.next_key()? {
10009 match k {
10010 GeneratedField::Dependencies => {
10011 if dependencies__.is_some() {
10012 return Err(serde::de::Error::duplicate_field("dependencies"));
10013 }
10014 dependencies__ = Some(map_.next_value()?);
10015 }
10016 }
10017 }
10018 Ok(ListObjectDependenciesResponse {
10019 dependencies: dependencies__.unwrap_or_default(),
10020 })
10021 }
10022 }
10023 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
10024 }
10025}
10026impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
10027 #[allow(deprecated)]
10028 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10029 where
10030 S: serde::Serializer,
10031 {
10032 use serde::ser::SerializeStruct;
10033 let mut len = 0;
10034 if self.object_id != 0 {
10035 len += 1;
10036 }
10037 if self.referenced_object_id != 0 {
10038 len += 1;
10039 }
10040 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
10041 if self.object_id != 0 {
10042 struct_ser.serialize_field("objectId", &self.object_id)?;
10043 }
10044 if self.referenced_object_id != 0 {
10045 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
10046 }
10047 struct_ser.end()
10048 }
10049}
10050impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
10051 #[allow(deprecated)]
10052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10053 where
10054 D: serde::Deserializer<'de>,
10055 {
10056 const FIELDS: &[&str] = &[
10057 "object_id",
10058 "objectId",
10059 "referenced_object_id",
10060 "referencedObjectId",
10061 ];
10062
10063 #[allow(clippy::enum_variant_names)]
10064 enum GeneratedField {
10065 ObjectId,
10066 ReferencedObjectId,
10067 }
10068 impl<'de> serde::Deserialize<'de> for GeneratedField {
10069 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10070 where
10071 D: serde::Deserializer<'de>,
10072 {
10073 struct GeneratedVisitor;
10074
10075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10076 type Value = GeneratedField;
10077
10078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10079 write!(formatter, "expected one of: {:?}", &FIELDS)
10080 }
10081
10082 #[allow(unused_variables)]
10083 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10084 where
10085 E: serde::de::Error,
10086 {
10087 match value {
10088 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
10089 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
10090 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10091 }
10092 }
10093 }
10094 deserializer.deserialize_identifier(GeneratedVisitor)
10095 }
10096 }
10097 struct GeneratedVisitor;
10098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10099 type Value = list_object_dependencies_response::ObjectDependencies;
10100
10101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10102 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
10103 }
10104
10105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
10106 where
10107 V: serde::de::MapAccess<'de>,
10108 {
10109 let mut object_id__ = None;
10110 let mut referenced_object_id__ = None;
10111 while let Some(k) = map_.next_key()? {
10112 match k {
10113 GeneratedField::ObjectId => {
10114 if object_id__.is_some() {
10115 return Err(serde::de::Error::duplicate_field("objectId"));
10116 }
10117 object_id__ =
10118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10119 ;
10120 }
10121 GeneratedField::ReferencedObjectId => {
10122 if referenced_object_id__.is_some() {
10123 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
10124 }
10125 referenced_object_id__ =
10126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10127 ;
10128 }
10129 }
10130 }
10131 Ok(list_object_dependencies_response::ObjectDependencies {
10132 object_id: object_id__.unwrap_or_default(),
10133 referenced_object_id: referenced_object_id__.unwrap_or_default(),
10134 })
10135 }
10136 }
10137 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
10138 }
10139}
10140impl serde::Serialize for ListRateLimitsRequest {
10141 #[allow(deprecated)]
10142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10143 where
10144 S: serde::Serializer,
10145 {
10146 use serde::ser::SerializeStruct;
10147 let len = 0;
10148 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10149 struct_ser.end()
10150 }
10151}
10152impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10153 #[allow(deprecated)]
10154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10155 where
10156 D: serde::Deserializer<'de>,
10157 {
10158 const FIELDS: &[&str] = &[
10159 ];
10160
10161 #[allow(clippy::enum_variant_names)]
10162 enum GeneratedField {
10163 }
10164 impl<'de> serde::Deserialize<'de> for GeneratedField {
10165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10166 where
10167 D: serde::Deserializer<'de>,
10168 {
10169 struct GeneratedVisitor;
10170
10171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10172 type Value = GeneratedField;
10173
10174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10175 write!(formatter, "expected one of: {:?}", &FIELDS)
10176 }
10177
10178 #[allow(unused_variables)]
10179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10180 where
10181 E: serde::de::Error,
10182 {
10183 Err(serde::de::Error::unknown_field(value, FIELDS))
10184 }
10185 }
10186 deserializer.deserialize_identifier(GeneratedVisitor)
10187 }
10188 }
10189 struct GeneratedVisitor;
10190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10191 type Value = ListRateLimitsRequest;
10192
10193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10194 formatter.write_str("struct meta.ListRateLimitsRequest")
10195 }
10196
10197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10198 where
10199 V: serde::de::MapAccess<'de>,
10200 {
10201 while map_.next_key::<GeneratedField>()?.is_some() {
10202 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10203 }
10204 Ok(ListRateLimitsRequest {
10205 })
10206 }
10207 }
10208 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10209 }
10210}
10211impl serde::Serialize for ListRateLimitsResponse {
10212 #[allow(deprecated)]
10213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10214 where
10215 S: serde::Serializer,
10216 {
10217 use serde::ser::SerializeStruct;
10218 let mut len = 0;
10219 if !self.rate_limits.is_empty() {
10220 len += 1;
10221 }
10222 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10223 if !self.rate_limits.is_empty() {
10224 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10225 }
10226 struct_ser.end()
10227 }
10228}
10229impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10230 #[allow(deprecated)]
10231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10232 where
10233 D: serde::Deserializer<'de>,
10234 {
10235 const FIELDS: &[&str] = &[
10236 "rate_limits",
10237 "rateLimits",
10238 ];
10239
10240 #[allow(clippy::enum_variant_names)]
10241 enum GeneratedField {
10242 RateLimits,
10243 }
10244 impl<'de> serde::Deserialize<'de> for GeneratedField {
10245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10246 where
10247 D: serde::Deserializer<'de>,
10248 {
10249 struct GeneratedVisitor;
10250
10251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10252 type Value = GeneratedField;
10253
10254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10255 write!(formatter, "expected one of: {:?}", &FIELDS)
10256 }
10257
10258 #[allow(unused_variables)]
10259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10260 where
10261 E: serde::de::Error,
10262 {
10263 match value {
10264 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10266 }
10267 }
10268 }
10269 deserializer.deserialize_identifier(GeneratedVisitor)
10270 }
10271 }
10272 struct GeneratedVisitor;
10273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10274 type Value = ListRateLimitsResponse;
10275
10276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10277 formatter.write_str("struct meta.ListRateLimitsResponse")
10278 }
10279
10280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
10281 where
10282 V: serde::de::MapAccess<'de>,
10283 {
10284 let mut rate_limits__ = None;
10285 while let Some(k) = map_.next_key()? {
10286 match k {
10287 GeneratedField::RateLimits => {
10288 if rate_limits__.is_some() {
10289 return Err(serde::de::Error::duplicate_field("rateLimits"));
10290 }
10291 rate_limits__ = Some(map_.next_value()?);
10292 }
10293 }
10294 }
10295 Ok(ListRateLimitsResponse {
10296 rate_limits: rate_limits__.unwrap_or_default(),
10297 })
10298 }
10299 }
10300 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
10301 }
10302}
10303impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
10304 #[allow(deprecated)]
10305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10306 where
10307 S: serde::Serializer,
10308 {
10309 use serde::ser::SerializeStruct;
10310 let mut len = 0;
10311 if self.fragment_id != 0 {
10312 len += 1;
10313 }
10314 if self.job_id != 0 {
10315 len += 1;
10316 }
10317 if self.fragment_type_mask != 0 {
10318 len += 1;
10319 }
10320 if self.rate_limit != 0 {
10321 len += 1;
10322 }
10323 if !self.node_name.is_empty() {
10324 len += 1;
10325 }
10326 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
10327 if self.fragment_id != 0 {
10328 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10329 }
10330 if self.job_id != 0 {
10331 struct_ser.serialize_field("jobId", &self.job_id)?;
10332 }
10333 if self.fragment_type_mask != 0 {
10334 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10335 }
10336 if self.rate_limit != 0 {
10337 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
10338 }
10339 if !self.node_name.is_empty() {
10340 struct_ser.serialize_field("nodeName", &self.node_name)?;
10341 }
10342 struct_ser.end()
10343 }
10344}
10345impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
10346 #[allow(deprecated)]
10347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10348 where
10349 D: serde::Deserializer<'de>,
10350 {
10351 const FIELDS: &[&str] = &[
10352 "fragment_id",
10353 "fragmentId",
10354 "job_id",
10355 "jobId",
10356 "fragment_type_mask",
10357 "fragmentTypeMask",
10358 "rate_limit",
10359 "rateLimit",
10360 "node_name",
10361 "nodeName",
10362 ];
10363
10364 #[allow(clippy::enum_variant_names)]
10365 enum GeneratedField {
10366 FragmentId,
10367 JobId,
10368 FragmentTypeMask,
10369 RateLimit,
10370 NodeName,
10371 }
10372 impl<'de> serde::Deserialize<'de> for GeneratedField {
10373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10374 where
10375 D: serde::Deserializer<'de>,
10376 {
10377 struct GeneratedVisitor;
10378
10379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10380 type Value = GeneratedField;
10381
10382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10383 write!(formatter, "expected one of: {:?}", &FIELDS)
10384 }
10385
10386 #[allow(unused_variables)]
10387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10388 where
10389 E: serde::de::Error,
10390 {
10391 match value {
10392 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10393 "jobId" | "job_id" => Ok(GeneratedField::JobId),
10394 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10395 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10396 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
10397 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10398 }
10399 }
10400 }
10401 deserializer.deserialize_identifier(GeneratedVisitor)
10402 }
10403 }
10404 struct GeneratedVisitor;
10405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10406 type Value = list_rate_limits_response::RateLimitInfo;
10407
10408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10409 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
10410 }
10411
10412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
10413 where
10414 V: serde::de::MapAccess<'de>,
10415 {
10416 let mut fragment_id__ = None;
10417 let mut job_id__ = None;
10418 let mut fragment_type_mask__ = None;
10419 let mut rate_limit__ = None;
10420 let mut node_name__ = None;
10421 while let Some(k) = map_.next_key()? {
10422 match k {
10423 GeneratedField::FragmentId => {
10424 if fragment_id__.is_some() {
10425 return Err(serde::de::Error::duplicate_field("fragmentId"));
10426 }
10427 fragment_id__ =
10428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10429 ;
10430 }
10431 GeneratedField::JobId => {
10432 if job_id__.is_some() {
10433 return Err(serde::de::Error::duplicate_field("jobId"));
10434 }
10435 job_id__ =
10436 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10437 ;
10438 }
10439 GeneratedField::FragmentTypeMask => {
10440 if fragment_type_mask__.is_some() {
10441 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10442 }
10443 fragment_type_mask__ =
10444 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10445 ;
10446 }
10447 GeneratedField::RateLimit => {
10448 if rate_limit__.is_some() {
10449 return Err(serde::de::Error::duplicate_field("rateLimit"));
10450 }
10451 rate_limit__ =
10452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10453 ;
10454 }
10455 GeneratedField::NodeName => {
10456 if node_name__.is_some() {
10457 return Err(serde::de::Error::duplicate_field("nodeName"));
10458 }
10459 node_name__ = Some(map_.next_value()?);
10460 }
10461 }
10462 }
10463 Ok(list_rate_limits_response::RateLimitInfo {
10464 fragment_id: fragment_id__.unwrap_or_default(),
10465 job_id: job_id__.unwrap_or_default(),
10466 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10467 rate_limit: rate_limit__.unwrap_or_default(),
10468 node_name: node_name__.unwrap_or_default(),
10469 })
10470 }
10471 }
10472 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10473 }
10474}
10475impl serde::Serialize for ListStreamingJobStatesRequest {
10476 #[allow(deprecated)]
10477 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10478 where
10479 S: serde::Serializer,
10480 {
10481 use serde::ser::SerializeStruct;
10482 let len = 0;
10483 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
10484 struct_ser.end()
10485 }
10486}
10487impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
10488 #[allow(deprecated)]
10489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10490 where
10491 D: serde::Deserializer<'de>,
10492 {
10493 const FIELDS: &[&str] = &[
10494 ];
10495
10496 #[allow(clippy::enum_variant_names)]
10497 enum GeneratedField {
10498 }
10499 impl<'de> serde::Deserialize<'de> for GeneratedField {
10500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10501 where
10502 D: serde::Deserializer<'de>,
10503 {
10504 struct GeneratedVisitor;
10505
10506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10507 type Value = GeneratedField;
10508
10509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10510 write!(formatter, "expected one of: {:?}", &FIELDS)
10511 }
10512
10513 #[allow(unused_variables)]
10514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10515 where
10516 E: serde::de::Error,
10517 {
10518 Err(serde::de::Error::unknown_field(value, FIELDS))
10519 }
10520 }
10521 deserializer.deserialize_identifier(GeneratedVisitor)
10522 }
10523 }
10524 struct GeneratedVisitor;
10525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10526 type Value = ListStreamingJobStatesRequest;
10527
10528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10529 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
10530 }
10531
10532 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
10533 where
10534 V: serde::de::MapAccess<'de>,
10535 {
10536 while map_.next_key::<GeneratedField>()?.is_some() {
10537 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10538 }
10539 Ok(ListStreamingJobStatesRequest {
10540 })
10541 }
10542 }
10543 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
10544 }
10545}
10546impl serde::Serialize for ListStreamingJobStatesResponse {
10547 #[allow(deprecated)]
10548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10549 where
10550 S: serde::Serializer,
10551 {
10552 use serde::ser::SerializeStruct;
10553 let mut len = 0;
10554 if !self.states.is_empty() {
10555 len += 1;
10556 }
10557 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
10558 if !self.states.is_empty() {
10559 struct_ser.serialize_field("states", &self.states)?;
10560 }
10561 struct_ser.end()
10562 }
10563}
10564impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
10565 #[allow(deprecated)]
10566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10567 where
10568 D: serde::Deserializer<'de>,
10569 {
10570 const FIELDS: &[&str] = &[
10571 "states",
10572 ];
10573
10574 #[allow(clippy::enum_variant_names)]
10575 enum GeneratedField {
10576 States,
10577 }
10578 impl<'de> serde::Deserialize<'de> for GeneratedField {
10579 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10580 where
10581 D: serde::Deserializer<'de>,
10582 {
10583 struct GeneratedVisitor;
10584
10585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10586 type Value = GeneratedField;
10587
10588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10589 write!(formatter, "expected one of: {:?}", &FIELDS)
10590 }
10591
10592 #[allow(unused_variables)]
10593 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10594 where
10595 E: serde::de::Error,
10596 {
10597 match value {
10598 "states" => Ok(GeneratedField::States),
10599 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10600 }
10601 }
10602 }
10603 deserializer.deserialize_identifier(GeneratedVisitor)
10604 }
10605 }
10606 struct GeneratedVisitor;
10607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10608 type Value = ListStreamingJobStatesResponse;
10609
10610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10611 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
10612 }
10613
10614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
10615 where
10616 V: serde::de::MapAccess<'de>,
10617 {
10618 let mut states__ = None;
10619 while let Some(k) = map_.next_key()? {
10620 match k {
10621 GeneratedField::States => {
10622 if states__.is_some() {
10623 return Err(serde::de::Error::duplicate_field("states"));
10624 }
10625 states__ = Some(map_.next_value()?);
10626 }
10627 }
10628 }
10629 Ok(ListStreamingJobStatesResponse {
10630 states: states__.unwrap_or_default(),
10631 })
10632 }
10633 }
10634 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10635 }
10636}
10637impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10638 #[allow(deprecated)]
10639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10640 where
10641 S: serde::Serializer,
10642 {
10643 use serde::ser::SerializeStruct;
10644 let mut len = 0;
10645 if self.table_id != 0 {
10646 len += 1;
10647 }
10648 if self.state != 0 {
10649 len += 1;
10650 }
10651 if self.parallelism.is_some() {
10652 len += 1;
10653 }
10654 if self.max_parallelism != 0 {
10655 len += 1;
10656 }
10657 if !self.name.is_empty() {
10658 len += 1;
10659 }
10660 if !self.resource_group.is_empty() {
10661 len += 1;
10662 }
10663 if self.database_id != 0 {
10664 len += 1;
10665 }
10666 if self.schema_id != 0 {
10667 len += 1;
10668 }
10669 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10670 if self.table_id != 0 {
10671 struct_ser.serialize_field("tableId", &self.table_id)?;
10672 }
10673 if self.state != 0 {
10674 let v = table_fragments::State::try_from(self.state)
10675 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10676 struct_ser.serialize_field("state", &v)?;
10677 }
10678 if let Some(v) = self.parallelism.as_ref() {
10679 struct_ser.serialize_field("parallelism", v)?;
10680 }
10681 if self.max_parallelism != 0 {
10682 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10683 }
10684 if !self.name.is_empty() {
10685 struct_ser.serialize_field("name", &self.name)?;
10686 }
10687 if !self.resource_group.is_empty() {
10688 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10689 }
10690 if self.database_id != 0 {
10691 struct_ser.serialize_field("databaseId", &self.database_id)?;
10692 }
10693 if self.schema_id != 0 {
10694 struct_ser.serialize_field("schemaId", &self.schema_id)?;
10695 }
10696 struct_ser.end()
10697 }
10698}
10699impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10700 #[allow(deprecated)]
10701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10702 where
10703 D: serde::Deserializer<'de>,
10704 {
10705 const FIELDS: &[&str] = &[
10706 "table_id",
10707 "tableId",
10708 "state",
10709 "parallelism",
10710 "max_parallelism",
10711 "maxParallelism",
10712 "name",
10713 "resource_group",
10714 "resourceGroup",
10715 "database_id",
10716 "databaseId",
10717 "schema_id",
10718 "schemaId",
10719 ];
10720
10721 #[allow(clippy::enum_variant_names)]
10722 enum GeneratedField {
10723 TableId,
10724 State,
10725 Parallelism,
10726 MaxParallelism,
10727 Name,
10728 ResourceGroup,
10729 DatabaseId,
10730 SchemaId,
10731 }
10732 impl<'de> serde::Deserialize<'de> for GeneratedField {
10733 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10734 where
10735 D: serde::Deserializer<'de>,
10736 {
10737 struct GeneratedVisitor;
10738
10739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10740 type Value = GeneratedField;
10741
10742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10743 write!(formatter, "expected one of: {:?}", &FIELDS)
10744 }
10745
10746 #[allow(unused_variables)]
10747 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10748 where
10749 E: serde::de::Error,
10750 {
10751 match value {
10752 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10753 "state" => Ok(GeneratedField::State),
10754 "parallelism" => Ok(GeneratedField::Parallelism),
10755 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10756 "name" => Ok(GeneratedField::Name),
10757 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10758 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
10759 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
10760 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10761 }
10762 }
10763 }
10764 deserializer.deserialize_identifier(GeneratedVisitor)
10765 }
10766 }
10767 struct GeneratedVisitor;
10768 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10769 type Value = list_streaming_job_states_response::StreamingJobState;
10770
10771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10772 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10773 }
10774
10775 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10776 where
10777 V: serde::de::MapAccess<'de>,
10778 {
10779 let mut table_id__ = None;
10780 let mut state__ = None;
10781 let mut parallelism__ = None;
10782 let mut max_parallelism__ = None;
10783 let mut name__ = None;
10784 let mut resource_group__ = None;
10785 let mut database_id__ = None;
10786 let mut schema_id__ = None;
10787 while let Some(k) = map_.next_key()? {
10788 match k {
10789 GeneratedField::TableId => {
10790 if table_id__.is_some() {
10791 return Err(serde::de::Error::duplicate_field("tableId"));
10792 }
10793 table_id__ =
10794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10795 ;
10796 }
10797 GeneratedField::State => {
10798 if state__.is_some() {
10799 return Err(serde::de::Error::duplicate_field("state"));
10800 }
10801 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10802 }
10803 GeneratedField::Parallelism => {
10804 if parallelism__.is_some() {
10805 return Err(serde::de::Error::duplicate_field("parallelism"));
10806 }
10807 parallelism__ = map_.next_value()?;
10808 }
10809 GeneratedField::MaxParallelism => {
10810 if max_parallelism__.is_some() {
10811 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10812 }
10813 max_parallelism__ =
10814 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10815 ;
10816 }
10817 GeneratedField::Name => {
10818 if name__.is_some() {
10819 return Err(serde::de::Error::duplicate_field("name"));
10820 }
10821 name__ = Some(map_.next_value()?);
10822 }
10823 GeneratedField::ResourceGroup => {
10824 if resource_group__.is_some() {
10825 return Err(serde::de::Error::duplicate_field("resourceGroup"));
10826 }
10827 resource_group__ = Some(map_.next_value()?);
10828 }
10829 GeneratedField::DatabaseId => {
10830 if database_id__.is_some() {
10831 return Err(serde::de::Error::duplicate_field("databaseId"));
10832 }
10833 database_id__ =
10834 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10835 ;
10836 }
10837 GeneratedField::SchemaId => {
10838 if schema_id__.is_some() {
10839 return Err(serde::de::Error::duplicate_field("schemaId"));
10840 }
10841 schema_id__ =
10842 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10843 ;
10844 }
10845 }
10846 }
10847 Ok(list_streaming_job_states_response::StreamingJobState {
10848 table_id: table_id__.unwrap_or_default(),
10849 state: state__.unwrap_or_default(),
10850 parallelism: parallelism__,
10851 max_parallelism: max_parallelism__.unwrap_or_default(),
10852 name: name__.unwrap_or_default(),
10853 resource_group: resource_group__.unwrap_or_default(),
10854 database_id: database_id__.unwrap_or_default(),
10855 schema_id: schema_id__.unwrap_or_default(),
10856 })
10857 }
10858 }
10859 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10860 }
10861}
10862impl serde::Serialize for ListTableFragmentsRequest {
10863 #[allow(deprecated)]
10864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10865 where
10866 S: serde::Serializer,
10867 {
10868 use serde::ser::SerializeStruct;
10869 let mut len = 0;
10870 if !self.table_ids.is_empty() {
10871 len += 1;
10872 }
10873 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10874 if !self.table_ids.is_empty() {
10875 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10876 }
10877 struct_ser.end()
10878 }
10879}
10880impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10881 #[allow(deprecated)]
10882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10883 where
10884 D: serde::Deserializer<'de>,
10885 {
10886 const FIELDS: &[&str] = &[
10887 "table_ids",
10888 "tableIds",
10889 ];
10890
10891 #[allow(clippy::enum_variant_names)]
10892 enum GeneratedField {
10893 TableIds,
10894 }
10895 impl<'de> serde::Deserialize<'de> for GeneratedField {
10896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10897 where
10898 D: serde::Deserializer<'de>,
10899 {
10900 struct GeneratedVisitor;
10901
10902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10903 type Value = GeneratedField;
10904
10905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10906 write!(formatter, "expected one of: {:?}", &FIELDS)
10907 }
10908
10909 #[allow(unused_variables)]
10910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10911 where
10912 E: serde::de::Error,
10913 {
10914 match value {
10915 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10917 }
10918 }
10919 }
10920 deserializer.deserialize_identifier(GeneratedVisitor)
10921 }
10922 }
10923 struct GeneratedVisitor;
10924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10925 type Value = ListTableFragmentsRequest;
10926
10927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10928 formatter.write_str("struct meta.ListTableFragmentsRequest")
10929 }
10930
10931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10932 where
10933 V: serde::de::MapAccess<'de>,
10934 {
10935 let mut table_ids__ = None;
10936 while let Some(k) = map_.next_key()? {
10937 match k {
10938 GeneratedField::TableIds => {
10939 if table_ids__.is_some() {
10940 return Err(serde::de::Error::duplicate_field("tableIds"));
10941 }
10942 table_ids__ =
10943 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10944 .into_iter().map(|x| x.0).collect())
10945 ;
10946 }
10947 }
10948 }
10949 Ok(ListTableFragmentsRequest {
10950 table_ids: table_ids__.unwrap_or_default(),
10951 })
10952 }
10953 }
10954 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10955 }
10956}
10957impl serde::Serialize for ListTableFragmentsResponse {
10958 #[allow(deprecated)]
10959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10960 where
10961 S: serde::Serializer,
10962 {
10963 use serde::ser::SerializeStruct;
10964 let mut len = 0;
10965 if !self.table_fragments.is_empty() {
10966 len += 1;
10967 }
10968 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10969 if !self.table_fragments.is_empty() {
10970 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10971 }
10972 struct_ser.end()
10973 }
10974}
10975impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10976 #[allow(deprecated)]
10977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10978 where
10979 D: serde::Deserializer<'de>,
10980 {
10981 const FIELDS: &[&str] = &[
10982 "table_fragments",
10983 "tableFragments",
10984 ];
10985
10986 #[allow(clippy::enum_variant_names)]
10987 enum GeneratedField {
10988 TableFragments,
10989 }
10990 impl<'de> serde::Deserialize<'de> for GeneratedField {
10991 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10992 where
10993 D: serde::Deserializer<'de>,
10994 {
10995 struct GeneratedVisitor;
10996
10997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10998 type Value = GeneratedField;
10999
11000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11001 write!(formatter, "expected one of: {:?}", &FIELDS)
11002 }
11003
11004 #[allow(unused_variables)]
11005 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11006 where
11007 E: serde::de::Error,
11008 {
11009 match value {
11010 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
11011 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11012 }
11013 }
11014 }
11015 deserializer.deserialize_identifier(GeneratedVisitor)
11016 }
11017 }
11018 struct GeneratedVisitor;
11019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11020 type Value = ListTableFragmentsResponse;
11021
11022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11023 formatter.write_str("struct meta.ListTableFragmentsResponse")
11024 }
11025
11026 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
11027 where
11028 V: serde::de::MapAccess<'de>,
11029 {
11030 let mut table_fragments__ = None;
11031 while let Some(k) = map_.next_key()? {
11032 match k {
11033 GeneratedField::TableFragments => {
11034 if table_fragments__.is_some() {
11035 return Err(serde::de::Error::duplicate_field("tableFragments"));
11036 }
11037 table_fragments__ = Some(
11038 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11039 .into_iter().map(|(k,v)| (k.0, v)).collect()
11040 );
11041 }
11042 }
11043 }
11044 Ok(ListTableFragmentsResponse {
11045 table_fragments: table_fragments__.unwrap_or_default(),
11046 })
11047 }
11048 }
11049 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
11050 }
11051}
11052impl serde::Serialize for list_table_fragments_response::ActorInfo {
11053 #[allow(deprecated)]
11054 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11055 where
11056 S: serde::Serializer,
11057 {
11058 use serde::ser::SerializeStruct;
11059 let mut len = 0;
11060 if self.id != 0 {
11061 len += 1;
11062 }
11063 if self.node.is_some() {
11064 len += 1;
11065 }
11066 if !self.dispatcher.is_empty() {
11067 len += 1;
11068 }
11069 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
11070 if self.id != 0 {
11071 struct_ser.serialize_field("id", &self.id)?;
11072 }
11073 if let Some(v) = self.node.as_ref() {
11074 struct_ser.serialize_field("node", v)?;
11075 }
11076 if !self.dispatcher.is_empty() {
11077 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11078 }
11079 struct_ser.end()
11080 }
11081}
11082impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
11083 #[allow(deprecated)]
11084 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11085 where
11086 D: serde::Deserializer<'de>,
11087 {
11088 const FIELDS: &[&str] = &[
11089 "id",
11090 "node",
11091 "dispatcher",
11092 ];
11093
11094 #[allow(clippy::enum_variant_names)]
11095 enum GeneratedField {
11096 Id,
11097 Node,
11098 Dispatcher,
11099 }
11100 impl<'de> serde::Deserialize<'de> for GeneratedField {
11101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11102 where
11103 D: serde::Deserializer<'de>,
11104 {
11105 struct GeneratedVisitor;
11106
11107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11108 type Value = GeneratedField;
11109
11110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11111 write!(formatter, "expected one of: {:?}", &FIELDS)
11112 }
11113
11114 #[allow(unused_variables)]
11115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11116 where
11117 E: serde::de::Error,
11118 {
11119 match value {
11120 "id" => Ok(GeneratedField::Id),
11121 "node" => Ok(GeneratedField::Node),
11122 "dispatcher" => Ok(GeneratedField::Dispatcher),
11123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11124 }
11125 }
11126 }
11127 deserializer.deserialize_identifier(GeneratedVisitor)
11128 }
11129 }
11130 struct GeneratedVisitor;
11131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11132 type Value = list_table_fragments_response::ActorInfo;
11133
11134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11135 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
11136 }
11137
11138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
11139 where
11140 V: serde::de::MapAccess<'de>,
11141 {
11142 let mut id__ = None;
11143 let mut node__ = None;
11144 let mut dispatcher__ = None;
11145 while let Some(k) = map_.next_key()? {
11146 match k {
11147 GeneratedField::Id => {
11148 if id__.is_some() {
11149 return Err(serde::de::Error::duplicate_field("id"));
11150 }
11151 id__ =
11152 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11153 ;
11154 }
11155 GeneratedField::Node => {
11156 if node__.is_some() {
11157 return Err(serde::de::Error::duplicate_field("node"));
11158 }
11159 node__ = map_.next_value()?;
11160 }
11161 GeneratedField::Dispatcher => {
11162 if dispatcher__.is_some() {
11163 return Err(serde::de::Error::duplicate_field("dispatcher"));
11164 }
11165 dispatcher__ = Some(map_.next_value()?);
11166 }
11167 }
11168 }
11169 Ok(list_table_fragments_response::ActorInfo {
11170 id: id__.unwrap_or_default(),
11171 node: node__,
11172 dispatcher: dispatcher__.unwrap_or_default(),
11173 })
11174 }
11175 }
11176 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
11177 }
11178}
11179impl serde::Serialize for list_table_fragments_response::FragmentInfo {
11180 #[allow(deprecated)]
11181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11182 where
11183 S: serde::Serializer,
11184 {
11185 use serde::ser::SerializeStruct;
11186 let mut len = 0;
11187 if self.id != 0 {
11188 len += 1;
11189 }
11190 if !self.actors.is_empty() {
11191 len += 1;
11192 }
11193 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
11194 if self.id != 0 {
11195 struct_ser.serialize_field("id", &self.id)?;
11196 }
11197 if !self.actors.is_empty() {
11198 struct_ser.serialize_field("actors", &self.actors)?;
11199 }
11200 struct_ser.end()
11201 }
11202}
11203impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
11204 #[allow(deprecated)]
11205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11206 where
11207 D: serde::Deserializer<'de>,
11208 {
11209 const FIELDS: &[&str] = &[
11210 "id",
11211 "actors",
11212 ];
11213
11214 #[allow(clippy::enum_variant_names)]
11215 enum GeneratedField {
11216 Id,
11217 Actors,
11218 }
11219 impl<'de> serde::Deserialize<'de> for GeneratedField {
11220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11221 where
11222 D: serde::Deserializer<'de>,
11223 {
11224 struct GeneratedVisitor;
11225
11226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11227 type Value = GeneratedField;
11228
11229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11230 write!(formatter, "expected one of: {:?}", &FIELDS)
11231 }
11232
11233 #[allow(unused_variables)]
11234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11235 where
11236 E: serde::de::Error,
11237 {
11238 match value {
11239 "id" => Ok(GeneratedField::Id),
11240 "actors" => Ok(GeneratedField::Actors),
11241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11242 }
11243 }
11244 }
11245 deserializer.deserialize_identifier(GeneratedVisitor)
11246 }
11247 }
11248 struct GeneratedVisitor;
11249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11250 type Value = list_table_fragments_response::FragmentInfo;
11251
11252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11253 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
11254 }
11255
11256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
11257 where
11258 V: serde::de::MapAccess<'de>,
11259 {
11260 let mut id__ = None;
11261 let mut actors__ = None;
11262 while let Some(k) = map_.next_key()? {
11263 match k {
11264 GeneratedField::Id => {
11265 if id__.is_some() {
11266 return Err(serde::de::Error::duplicate_field("id"));
11267 }
11268 id__ =
11269 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11270 ;
11271 }
11272 GeneratedField::Actors => {
11273 if actors__.is_some() {
11274 return Err(serde::de::Error::duplicate_field("actors"));
11275 }
11276 actors__ = Some(map_.next_value()?);
11277 }
11278 }
11279 }
11280 Ok(list_table_fragments_response::FragmentInfo {
11281 id: id__.unwrap_or_default(),
11282 actors: actors__.unwrap_or_default(),
11283 })
11284 }
11285 }
11286 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
11287 }
11288}
11289impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
11290 #[allow(deprecated)]
11291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11292 where
11293 S: serde::Serializer,
11294 {
11295 use serde::ser::SerializeStruct;
11296 let mut len = 0;
11297 if !self.fragments.is_empty() {
11298 len += 1;
11299 }
11300 if self.ctx.is_some() {
11301 len += 1;
11302 }
11303 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
11304 if !self.fragments.is_empty() {
11305 struct_ser.serialize_field("fragments", &self.fragments)?;
11306 }
11307 if let Some(v) = self.ctx.as_ref() {
11308 struct_ser.serialize_field("ctx", v)?;
11309 }
11310 struct_ser.end()
11311 }
11312}
11313impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
11314 #[allow(deprecated)]
11315 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11316 where
11317 D: serde::Deserializer<'de>,
11318 {
11319 const FIELDS: &[&str] = &[
11320 "fragments",
11321 "ctx",
11322 ];
11323
11324 #[allow(clippy::enum_variant_names)]
11325 enum GeneratedField {
11326 Fragments,
11327 Ctx,
11328 }
11329 impl<'de> serde::Deserialize<'de> for GeneratedField {
11330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11331 where
11332 D: serde::Deserializer<'de>,
11333 {
11334 struct GeneratedVisitor;
11335
11336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11337 type Value = GeneratedField;
11338
11339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11340 write!(formatter, "expected one of: {:?}", &FIELDS)
11341 }
11342
11343 #[allow(unused_variables)]
11344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11345 where
11346 E: serde::de::Error,
11347 {
11348 match value {
11349 "fragments" => Ok(GeneratedField::Fragments),
11350 "ctx" => Ok(GeneratedField::Ctx),
11351 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11352 }
11353 }
11354 }
11355 deserializer.deserialize_identifier(GeneratedVisitor)
11356 }
11357 }
11358 struct GeneratedVisitor;
11359 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11360 type Value = list_table_fragments_response::TableFragmentInfo;
11361
11362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11363 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
11364 }
11365
11366 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
11367 where
11368 V: serde::de::MapAccess<'de>,
11369 {
11370 let mut fragments__ = None;
11371 let mut ctx__ = None;
11372 while let Some(k) = map_.next_key()? {
11373 match k {
11374 GeneratedField::Fragments => {
11375 if fragments__.is_some() {
11376 return Err(serde::de::Error::duplicate_field("fragments"));
11377 }
11378 fragments__ = Some(map_.next_value()?);
11379 }
11380 GeneratedField::Ctx => {
11381 if ctx__.is_some() {
11382 return Err(serde::de::Error::duplicate_field("ctx"));
11383 }
11384 ctx__ = map_.next_value()?;
11385 }
11386 }
11387 }
11388 Ok(list_table_fragments_response::TableFragmentInfo {
11389 fragments: fragments__.unwrap_or_default(),
11390 ctx: ctx__,
11391 })
11392 }
11393 }
11394 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
11395 }
11396}
11397impl serde::Serialize for MembersRequest {
11398 #[allow(deprecated)]
11399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11400 where
11401 S: serde::Serializer,
11402 {
11403 use serde::ser::SerializeStruct;
11404 let len = 0;
11405 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
11406 struct_ser.end()
11407 }
11408}
11409impl<'de> serde::Deserialize<'de> for MembersRequest {
11410 #[allow(deprecated)]
11411 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11412 where
11413 D: serde::Deserializer<'de>,
11414 {
11415 const FIELDS: &[&str] = &[
11416 ];
11417
11418 #[allow(clippy::enum_variant_names)]
11419 enum GeneratedField {
11420 }
11421 impl<'de> serde::Deserialize<'de> for GeneratedField {
11422 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11423 where
11424 D: serde::Deserializer<'de>,
11425 {
11426 struct GeneratedVisitor;
11427
11428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11429 type Value = GeneratedField;
11430
11431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11432 write!(formatter, "expected one of: {:?}", &FIELDS)
11433 }
11434
11435 #[allow(unused_variables)]
11436 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11437 where
11438 E: serde::de::Error,
11439 {
11440 Err(serde::de::Error::unknown_field(value, FIELDS))
11441 }
11442 }
11443 deserializer.deserialize_identifier(GeneratedVisitor)
11444 }
11445 }
11446 struct GeneratedVisitor;
11447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11448 type Value = MembersRequest;
11449
11450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11451 formatter.write_str("struct meta.MembersRequest")
11452 }
11453
11454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
11455 where
11456 V: serde::de::MapAccess<'de>,
11457 {
11458 while map_.next_key::<GeneratedField>()?.is_some() {
11459 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11460 }
11461 Ok(MembersRequest {
11462 })
11463 }
11464 }
11465 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
11466 }
11467}
11468impl serde::Serialize for MembersResponse {
11469 #[allow(deprecated)]
11470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11471 where
11472 S: serde::Serializer,
11473 {
11474 use serde::ser::SerializeStruct;
11475 let mut len = 0;
11476 if !self.members.is_empty() {
11477 len += 1;
11478 }
11479 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
11480 if !self.members.is_empty() {
11481 struct_ser.serialize_field("members", &self.members)?;
11482 }
11483 struct_ser.end()
11484 }
11485}
11486impl<'de> serde::Deserialize<'de> for MembersResponse {
11487 #[allow(deprecated)]
11488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11489 where
11490 D: serde::Deserializer<'de>,
11491 {
11492 const FIELDS: &[&str] = &[
11493 "members",
11494 ];
11495
11496 #[allow(clippy::enum_variant_names)]
11497 enum GeneratedField {
11498 Members,
11499 }
11500 impl<'de> serde::Deserialize<'de> for GeneratedField {
11501 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11502 where
11503 D: serde::Deserializer<'de>,
11504 {
11505 struct GeneratedVisitor;
11506
11507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11508 type Value = GeneratedField;
11509
11510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11511 write!(formatter, "expected one of: {:?}", &FIELDS)
11512 }
11513
11514 #[allow(unused_variables)]
11515 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11516 where
11517 E: serde::de::Error,
11518 {
11519 match value {
11520 "members" => Ok(GeneratedField::Members),
11521 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11522 }
11523 }
11524 }
11525 deserializer.deserialize_identifier(GeneratedVisitor)
11526 }
11527 }
11528 struct GeneratedVisitor;
11529 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11530 type Value = MembersResponse;
11531
11532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11533 formatter.write_str("struct meta.MembersResponse")
11534 }
11535
11536 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11537 where
11538 V: serde::de::MapAccess<'de>,
11539 {
11540 let mut members__ = None;
11541 while let Some(k) = map_.next_key()? {
11542 match k {
11543 GeneratedField::Members => {
11544 if members__.is_some() {
11545 return Err(serde::de::Error::duplicate_field("members"));
11546 }
11547 members__ = Some(map_.next_value()?);
11548 }
11549 }
11550 }
11551 Ok(MembersResponse {
11552 members: members__.unwrap_or_default(),
11553 })
11554 }
11555 }
11556 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11557 }
11558}
11559impl serde::Serialize for MetaMember {
11560 #[allow(deprecated)]
11561 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11562 where
11563 S: serde::Serializer,
11564 {
11565 use serde::ser::SerializeStruct;
11566 let mut len = 0;
11567 if self.address.is_some() {
11568 len += 1;
11569 }
11570 if self.is_leader {
11571 len += 1;
11572 }
11573 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11574 if let Some(v) = self.address.as_ref() {
11575 struct_ser.serialize_field("address", v)?;
11576 }
11577 if self.is_leader {
11578 struct_ser.serialize_field("isLeader", &self.is_leader)?;
11579 }
11580 struct_ser.end()
11581 }
11582}
11583impl<'de> serde::Deserialize<'de> for MetaMember {
11584 #[allow(deprecated)]
11585 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11586 where
11587 D: serde::Deserializer<'de>,
11588 {
11589 const FIELDS: &[&str] = &[
11590 "address",
11591 "is_leader",
11592 "isLeader",
11593 ];
11594
11595 #[allow(clippy::enum_variant_names)]
11596 enum GeneratedField {
11597 Address,
11598 IsLeader,
11599 }
11600 impl<'de> serde::Deserialize<'de> for GeneratedField {
11601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11602 where
11603 D: serde::Deserializer<'de>,
11604 {
11605 struct GeneratedVisitor;
11606
11607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11608 type Value = GeneratedField;
11609
11610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11611 write!(formatter, "expected one of: {:?}", &FIELDS)
11612 }
11613
11614 #[allow(unused_variables)]
11615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11616 where
11617 E: serde::de::Error,
11618 {
11619 match value {
11620 "address" => Ok(GeneratedField::Address),
11621 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11622 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11623 }
11624 }
11625 }
11626 deserializer.deserialize_identifier(GeneratedVisitor)
11627 }
11628 }
11629 struct GeneratedVisitor;
11630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11631 type Value = MetaMember;
11632
11633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11634 formatter.write_str("struct meta.MetaMember")
11635 }
11636
11637 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11638 where
11639 V: serde::de::MapAccess<'de>,
11640 {
11641 let mut address__ = None;
11642 let mut is_leader__ = None;
11643 while let Some(k) = map_.next_key()? {
11644 match k {
11645 GeneratedField::Address => {
11646 if address__.is_some() {
11647 return Err(serde::de::Error::duplicate_field("address"));
11648 }
11649 address__ = map_.next_value()?;
11650 }
11651 GeneratedField::IsLeader => {
11652 if is_leader__.is_some() {
11653 return Err(serde::de::Error::duplicate_field("isLeader"));
11654 }
11655 is_leader__ = Some(map_.next_value()?);
11656 }
11657 }
11658 }
11659 Ok(MetaMember {
11660 address: address__,
11661 is_leader: is_leader__.unwrap_or_default(),
11662 })
11663 }
11664 }
11665 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11666 }
11667}
11668impl serde::Serialize for MetaSnapshot {
11669 #[allow(deprecated)]
11670 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11671 where
11672 S: serde::Serializer,
11673 {
11674 use serde::ser::SerializeStruct;
11675 let mut len = 0;
11676 if !self.databases.is_empty() {
11677 len += 1;
11678 }
11679 if !self.schemas.is_empty() {
11680 len += 1;
11681 }
11682 if !self.sources.is_empty() {
11683 len += 1;
11684 }
11685 if !self.sinks.is_empty() {
11686 len += 1;
11687 }
11688 if !self.tables.is_empty() {
11689 len += 1;
11690 }
11691 if !self.indexes.is_empty() {
11692 len += 1;
11693 }
11694 if !self.views.is_empty() {
11695 len += 1;
11696 }
11697 if !self.functions.is_empty() {
11698 len += 1;
11699 }
11700 if !self.connections.is_empty() {
11701 len += 1;
11702 }
11703 if !self.subscriptions.is_empty() {
11704 len += 1;
11705 }
11706 if !self.users.is_empty() {
11707 len += 1;
11708 }
11709 if self.session_params.is_some() {
11710 len += 1;
11711 }
11712 if !self.secrets.is_empty() {
11713 len += 1;
11714 }
11715 if self.cluster_resource.is_some() {
11716 len += 1;
11717 }
11718 if !self.nodes.is_empty() {
11719 len += 1;
11720 }
11721 if self.hummock_version.is_some() {
11722 len += 1;
11723 }
11724 if self.meta_backup_manifest_id.is_some() {
11725 len += 1;
11726 }
11727 if self.hummock_write_limits.is_some() {
11728 len += 1;
11729 }
11730 if !self.streaming_worker_slot_mappings.is_empty() {
11731 len += 1;
11732 }
11733 if !self.serving_worker_slot_mappings.is_empty() {
11734 len += 1;
11735 }
11736 if self.version.is_some() {
11737 len += 1;
11738 }
11739 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11740 if !self.databases.is_empty() {
11741 struct_ser.serialize_field("databases", &self.databases)?;
11742 }
11743 if !self.schemas.is_empty() {
11744 struct_ser.serialize_field("schemas", &self.schemas)?;
11745 }
11746 if !self.sources.is_empty() {
11747 struct_ser.serialize_field("sources", &self.sources)?;
11748 }
11749 if !self.sinks.is_empty() {
11750 struct_ser.serialize_field("sinks", &self.sinks)?;
11751 }
11752 if !self.tables.is_empty() {
11753 struct_ser.serialize_field("tables", &self.tables)?;
11754 }
11755 if !self.indexes.is_empty() {
11756 struct_ser.serialize_field("indexes", &self.indexes)?;
11757 }
11758 if !self.views.is_empty() {
11759 struct_ser.serialize_field("views", &self.views)?;
11760 }
11761 if !self.functions.is_empty() {
11762 struct_ser.serialize_field("functions", &self.functions)?;
11763 }
11764 if !self.connections.is_empty() {
11765 struct_ser.serialize_field("connections", &self.connections)?;
11766 }
11767 if !self.subscriptions.is_empty() {
11768 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11769 }
11770 if !self.users.is_empty() {
11771 struct_ser.serialize_field("users", &self.users)?;
11772 }
11773 if let Some(v) = self.session_params.as_ref() {
11774 struct_ser.serialize_field("sessionParams", v)?;
11775 }
11776 if !self.secrets.is_empty() {
11777 struct_ser.serialize_field("secrets", &self.secrets)?;
11778 }
11779 if let Some(v) = self.cluster_resource.as_ref() {
11780 struct_ser.serialize_field("clusterResource", v)?;
11781 }
11782 if !self.nodes.is_empty() {
11783 struct_ser.serialize_field("nodes", &self.nodes)?;
11784 }
11785 if let Some(v) = self.hummock_version.as_ref() {
11786 struct_ser.serialize_field("hummockVersion", v)?;
11787 }
11788 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11789 struct_ser.serialize_field("metaBackupManifestId", v)?;
11790 }
11791 if let Some(v) = self.hummock_write_limits.as_ref() {
11792 struct_ser.serialize_field("hummockWriteLimits", v)?;
11793 }
11794 if !self.streaming_worker_slot_mappings.is_empty() {
11795 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11796 }
11797 if !self.serving_worker_slot_mappings.is_empty() {
11798 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11799 }
11800 if let Some(v) = self.version.as_ref() {
11801 struct_ser.serialize_field("version", v)?;
11802 }
11803 struct_ser.end()
11804 }
11805}
11806impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11807 #[allow(deprecated)]
11808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11809 where
11810 D: serde::Deserializer<'de>,
11811 {
11812 const FIELDS: &[&str] = &[
11813 "databases",
11814 "schemas",
11815 "sources",
11816 "sinks",
11817 "tables",
11818 "indexes",
11819 "views",
11820 "functions",
11821 "connections",
11822 "subscriptions",
11823 "users",
11824 "session_params",
11825 "sessionParams",
11826 "secrets",
11827 "cluster_resource",
11828 "clusterResource",
11829 "nodes",
11830 "hummock_version",
11831 "hummockVersion",
11832 "meta_backup_manifest_id",
11833 "metaBackupManifestId",
11834 "hummock_write_limits",
11835 "hummockWriteLimits",
11836 "streaming_worker_slot_mappings",
11837 "streamingWorkerSlotMappings",
11838 "serving_worker_slot_mappings",
11839 "servingWorkerSlotMappings",
11840 "version",
11841 ];
11842
11843 #[allow(clippy::enum_variant_names)]
11844 enum GeneratedField {
11845 Databases,
11846 Schemas,
11847 Sources,
11848 Sinks,
11849 Tables,
11850 Indexes,
11851 Views,
11852 Functions,
11853 Connections,
11854 Subscriptions,
11855 Users,
11856 SessionParams,
11857 Secrets,
11858 ClusterResource,
11859 Nodes,
11860 HummockVersion,
11861 MetaBackupManifestId,
11862 HummockWriteLimits,
11863 StreamingWorkerSlotMappings,
11864 ServingWorkerSlotMappings,
11865 Version,
11866 }
11867 impl<'de> serde::Deserialize<'de> for GeneratedField {
11868 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11869 where
11870 D: serde::Deserializer<'de>,
11871 {
11872 struct GeneratedVisitor;
11873
11874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11875 type Value = GeneratedField;
11876
11877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11878 write!(formatter, "expected one of: {:?}", &FIELDS)
11879 }
11880
11881 #[allow(unused_variables)]
11882 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11883 where
11884 E: serde::de::Error,
11885 {
11886 match value {
11887 "databases" => Ok(GeneratedField::Databases),
11888 "schemas" => Ok(GeneratedField::Schemas),
11889 "sources" => Ok(GeneratedField::Sources),
11890 "sinks" => Ok(GeneratedField::Sinks),
11891 "tables" => Ok(GeneratedField::Tables),
11892 "indexes" => Ok(GeneratedField::Indexes),
11893 "views" => Ok(GeneratedField::Views),
11894 "functions" => Ok(GeneratedField::Functions),
11895 "connections" => Ok(GeneratedField::Connections),
11896 "subscriptions" => Ok(GeneratedField::Subscriptions),
11897 "users" => Ok(GeneratedField::Users),
11898 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11899 "secrets" => Ok(GeneratedField::Secrets),
11900 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
11901 "nodes" => Ok(GeneratedField::Nodes),
11902 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11903 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11904 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11905 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11906 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11907 "version" => Ok(GeneratedField::Version),
11908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11909 }
11910 }
11911 }
11912 deserializer.deserialize_identifier(GeneratedVisitor)
11913 }
11914 }
11915 struct GeneratedVisitor;
11916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11917 type Value = MetaSnapshot;
11918
11919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11920 formatter.write_str("struct meta.MetaSnapshot")
11921 }
11922
11923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11924 where
11925 V: serde::de::MapAccess<'de>,
11926 {
11927 let mut databases__ = None;
11928 let mut schemas__ = None;
11929 let mut sources__ = None;
11930 let mut sinks__ = None;
11931 let mut tables__ = None;
11932 let mut indexes__ = None;
11933 let mut views__ = None;
11934 let mut functions__ = None;
11935 let mut connections__ = None;
11936 let mut subscriptions__ = None;
11937 let mut users__ = None;
11938 let mut session_params__ = None;
11939 let mut secrets__ = None;
11940 let mut cluster_resource__ = None;
11941 let mut nodes__ = None;
11942 let mut hummock_version__ = None;
11943 let mut meta_backup_manifest_id__ = None;
11944 let mut hummock_write_limits__ = None;
11945 let mut streaming_worker_slot_mappings__ = None;
11946 let mut serving_worker_slot_mappings__ = None;
11947 let mut version__ = None;
11948 while let Some(k) = map_.next_key()? {
11949 match k {
11950 GeneratedField::Databases => {
11951 if databases__.is_some() {
11952 return Err(serde::de::Error::duplicate_field("databases"));
11953 }
11954 databases__ = Some(map_.next_value()?);
11955 }
11956 GeneratedField::Schemas => {
11957 if schemas__.is_some() {
11958 return Err(serde::de::Error::duplicate_field("schemas"));
11959 }
11960 schemas__ = Some(map_.next_value()?);
11961 }
11962 GeneratedField::Sources => {
11963 if sources__.is_some() {
11964 return Err(serde::de::Error::duplicate_field("sources"));
11965 }
11966 sources__ = Some(map_.next_value()?);
11967 }
11968 GeneratedField::Sinks => {
11969 if sinks__.is_some() {
11970 return Err(serde::de::Error::duplicate_field("sinks"));
11971 }
11972 sinks__ = Some(map_.next_value()?);
11973 }
11974 GeneratedField::Tables => {
11975 if tables__.is_some() {
11976 return Err(serde::de::Error::duplicate_field("tables"));
11977 }
11978 tables__ = Some(map_.next_value()?);
11979 }
11980 GeneratedField::Indexes => {
11981 if indexes__.is_some() {
11982 return Err(serde::de::Error::duplicate_field("indexes"));
11983 }
11984 indexes__ = Some(map_.next_value()?);
11985 }
11986 GeneratedField::Views => {
11987 if views__.is_some() {
11988 return Err(serde::de::Error::duplicate_field("views"));
11989 }
11990 views__ = Some(map_.next_value()?);
11991 }
11992 GeneratedField::Functions => {
11993 if functions__.is_some() {
11994 return Err(serde::de::Error::duplicate_field("functions"));
11995 }
11996 functions__ = Some(map_.next_value()?);
11997 }
11998 GeneratedField::Connections => {
11999 if connections__.is_some() {
12000 return Err(serde::de::Error::duplicate_field("connections"));
12001 }
12002 connections__ = Some(map_.next_value()?);
12003 }
12004 GeneratedField::Subscriptions => {
12005 if subscriptions__.is_some() {
12006 return Err(serde::de::Error::duplicate_field("subscriptions"));
12007 }
12008 subscriptions__ = Some(map_.next_value()?);
12009 }
12010 GeneratedField::Users => {
12011 if users__.is_some() {
12012 return Err(serde::de::Error::duplicate_field("users"));
12013 }
12014 users__ = Some(map_.next_value()?);
12015 }
12016 GeneratedField::SessionParams => {
12017 if session_params__.is_some() {
12018 return Err(serde::de::Error::duplicate_field("sessionParams"));
12019 }
12020 session_params__ = map_.next_value()?;
12021 }
12022 GeneratedField::Secrets => {
12023 if secrets__.is_some() {
12024 return Err(serde::de::Error::duplicate_field("secrets"));
12025 }
12026 secrets__ = Some(map_.next_value()?);
12027 }
12028 GeneratedField::ClusterResource => {
12029 if cluster_resource__.is_some() {
12030 return Err(serde::de::Error::duplicate_field("clusterResource"));
12031 }
12032 cluster_resource__ = map_.next_value()?;
12033 }
12034 GeneratedField::Nodes => {
12035 if nodes__.is_some() {
12036 return Err(serde::de::Error::duplicate_field("nodes"));
12037 }
12038 nodes__ = Some(map_.next_value()?);
12039 }
12040 GeneratedField::HummockVersion => {
12041 if hummock_version__.is_some() {
12042 return Err(serde::de::Error::duplicate_field("hummockVersion"));
12043 }
12044 hummock_version__ = map_.next_value()?;
12045 }
12046 GeneratedField::MetaBackupManifestId => {
12047 if meta_backup_manifest_id__.is_some() {
12048 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
12049 }
12050 meta_backup_manifest_id__ = map_.next_value()?;
12051 }
12052 GeneratedField::HummockWriteLimits => {
12053 if hummock_write_limits__.is_some() {
12054 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
12055 }
12056 hummock_write_limits__ = map_.next_value()?;
12057 }
12058 GeneratedField::StreamingWorkerSlotMappings => {
12059 if streaming_worker_slot_mappings__.is_some() {
12060 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
12061 }
12062 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
12063 }
12064 GeneratedField::ServingWorkerSlotMappings => {
12065 if serving_worker_slot_mappings__.is_some() {
12066 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
12067 }
12068 serving_worker_slot_mappings__ = Some(map_.next_value()?);
12069 }
12070 GeneratedField::Version => {
12071 if version__.is_some() {
12072 return Err(serde::de::Error::duplicate_field("version"));
12073 }
12074 version__ = map_.next_value()?;
12075 }
12076 }
12077 }
12078 Ok(MetaSnapshot {
12079 databases: databases__.unwrap_or_default(),
12080 schemas: schemas__.unwrap_or_default(),
12081 sources: sources__.unwrap_or_default(),
12082 sinks: sinks__.unwrap_or_default(),
12083 tables: tables__.unwrap_or_default(),
12084 indexes: indexes__.unwrap_or_default(),
12085 views: views__.unwrap_or_default(),
12086 functions: functions__.unwrap_or_default(),
12087 connections: connections__.unwrap_or_default(),
12088 subscriptions: subscriptions__.unwrap_or_default(),
12089 users: users__.unwrap_or_default(),
12090 session_params: session_params__,
12091 secrets: secrets__.unwrap_or_default(),
12092 cluster_resource: cluster_resource__,
12093 nodes: nodes__.unwrap_or_default(),
12094 hummock_version: hummock_version__,
12095 meta_backup_manifest_id: meta_backup_manifest_id__,
12096 hummock_write_limits: hummock_write_limits__,
12097 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
12098 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
12099 version: version__,
12100 })
12101 }
12102 }
12103 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
12104 }
12105}
12106impl serde::Serialize for meta_snapshot::SnapshotVersion {
12107 #[allow(deprecated)]
12108 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12109 where
12110 S: serde::Serializer,
12111 {
12112 use serde::ser::SerializeStruct;
12113 let mut len = 0;
12114 if self.catalog_version != 0 {
12115 len += 1;
12116 }
12117 if self.worker_node_version != 0 {
12118 len += 1;
12119 }
12120 if self.streaming_worker_slot_mapping_version != 0 {
12121 len += 1;
12122 }
12123 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
12124 if self.catalog_version != 0 {
12125 #[allow(clippy::needless_borrow)]
12126 #[allow(clippy::needless_borrows_for_generic_args)]
12127 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
12128 }
12129 if self.worker_node_version != 0 {
12130 #[allow(clippy::needless_borrow)]
12131 #[allow(clippy::needless_borrows_for_generic_args)]
12132 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
12133 }
12134 if self.streaming_worker_slot_mapping_version != 0 {
12135 #[allow(clippy::needless_borrow)]
12136 #[allow(clippy::needless_borrows_for_generic_args)]
12137 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
12138 }
12139 struct_ser.end()
12140 }
12141}
12142impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
12143 #[allow(deprecated)]
12144 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12145 where
12146 D: serde::Deserializer<'de>,
12147 {
12148 const FIELDS: &[&str] = &[
12149 "catalog_version",
12150 "catalogVersion",
12151 "worker_node_version",
12152 "workerNodeVersion",
12153 "streaming_worker_slot_mapping_version",
12154 "streamingWorkerSlotMappingVersion",
12155 ];
12156
12157 #[allow(clippy::enum_variant_names)]
12158 enum GeneratedField {
12159 CatalogVersion,
12160 WorkerNodeVersion,
12161 StreamingWorkerSlotMappingVersion,
12162 }
12163 impl<'de> serde::Deserialize<'de> for GeneratedField {
12164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12165 where
12166 D: serde::Deserializer<'de>,
12167 {
12168 struct GeneratedVisitor;
12169
12170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12171 type Value = GeneratedField;
12172
12173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12174 write!(formatter, "expected one of: {:?}", &FIELDS)
12175 }
12176
12177 #[allow(unused_variables)]
12178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12179 where
12180 E: serde::de::Error,
12181 {
12182 match value {
12183 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12184 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
12185 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
12186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12187 }
12188 }
12189 }
12190 deserializer.deserialize_identifier(GeneratedVisitor)
12191 }
12192 }
12193 struct GeneratedVisitor;
12194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12195 type Value = meta_snapshot::SnapshotVersion;
12196
12197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12198 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
12199 }
12200
12201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
12202 where
12203 V: serde::de::MapAccess<'de>,
12204 {
12205 let mut catalog_version__ = None;
12206 let mut worker_node_version__ = None;
12207 let mut streaming_worker_slot_mapping_version__ = None;
12208 while let Some(k) = map_.next_key()? {
12209 match k {
12210 GeneratedField::CatalogVersion => {
12211 if catalog_version__.is_some() {
12212 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12213 }
12214 catalog_version__ =
12215 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12216 ;
12217 }
12218 GeneratedField::WorkerNodeVersion => {
12219 if worker_node_version__.is_some() {
12220 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
12221 }
12222 worker_node_version__ =
12223 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12224 ;
12225 }
12226 GeneratedField::StreamingWorkerSlotMappingVersion => {
12227 if streaming_worker_slot_mapping_version__.is_some() {
12228 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
12229 }
12230 streaming_worker_slot_mapping_version__ =
12231 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12232 ;
12233 }
12234 }
12235 }
12236 Ok(meta_snapshot::SnapshotVersion {
12237 catalog_version: catalog_version__.unwrap_or_default(),
12238 worker_node_version: worker_node_version__.unwrap_or_default(),
12239 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
12240 })
12241 }
12242 }
12243 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
12244 }
12245}
12246impl serde::Serialize for MigrationPlan {
12247 #[allow(deprecated)]
12248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12249 where
12250 S: serde::Serializer,
12251 {
12252 use serde::ser::SerializeStruct;
12253 let mut len = 0;
12254 if !self.worker_slot_migration_plan.is_empty() {
12255 len += 1;
12256 }
12257 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
12258 if !self.worker_slot_migration_plan.is_empty() {
12259 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
12260 .map(|(k, v)| (k, v.to_string())).collect();
12261 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
12262 }
12263 struct_ser.end()
12264 }
12265}
12266impl<'de> serde::Deserialize<'de> for MigrationPlan {
12267 #[allow(deprecated)]
12268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12269 where
12270 D: serde::Deserializer<'de>,
12271 {
12272 const FIELDS: &[&str] = &[
12273 "worker_slot_migration_plan",
12274 "workerSlotMigrationPlan",
12275 ];
12276
12277 #[allow(clippy::enum_variant_names)]
12278 enum GeneratedField {
12279 WorkerSlotMigrationPlan,
12280 }
12281 impl<'de> serde::Deserialize<'de> for GeneratedField {
12282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12283 where
12284 D: serde::Deserializer<'de>,
12285 {
12286 struct GeneratedVisitor;
12287
12288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12289 type Value = GeneratedField;
12290
12291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12292 write!(formatter, "expected one of: {:?}", &FIELDS)
12293 }
12294
12295 #[allow(unused_variables)]
12296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12297 where
12298 E: serde::de::Error,
12299 {
12300 match value {
12301 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
12302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12303 }
12304 }
12305 }
12306 deserializer.deserialize_identifier(GeneratedVisitor)
12307 }
12308 }
12309 struct GeneratedVisitor;
12310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12311 type Value = MigrationPlan;
12312
12313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12314 formatter.write_str("struct meta.MigrationPlan")
12315 }
12316
12317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
12318 where
12319 V: serde::de::MapAccess<'de>,
12320 {
12321 let mut worker_slot_migration_plan__ = None;
12322 while let Some(k) = map_.next_key()? {
12323 match k {
12324 GeneratedField::WorkerSlotMigrationPlan => {
12325 if worker_slot_migration_plan__.is_some() {
12326 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
12327 }
12328 worker_slot_migration_plan__ = Some(
12329 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12330 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
12331 );
12332 }
12333 }
12334 }
12335 Ok(MigrationPlan {
12336 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
12337 })
12338 }
12339 }
12340 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
12341 }
12342}
12343impl serde::Serialize for Object {
12344 #[allow(deprecated)]
12345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12346 where
12347 S: serde::Serializer,
12348 {
12349 use serde::ser::SerializeStruct;
12350 let mut len = 0;
12351 if self.object_info.is_some() {
12352 len += 1;
12353 }
12354 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
12355 if let Some(v) = self.object_info.as_ref() {
12356 match v {
12357 object::ObjectInfo::Database(v) => {
12358 struct_ser.serialize_field("database", v)?;
12359 }
12360 object::ObjectInfo::Schema(v) => {
12361 struct_ser.serialize_field("schema", v)?;
12362 }
12363 object::ObjectInfo::Table(v) => {
12364 struct_ser.serialize_field("table", v)?;
12365 }
12366 object::ObjectInfo::Index(v) => {
12367 struct_ser.serialize_field("index", v)?;
12368 }
12369 object::ObjectInfo::Source(v) => {
12370 struct_ser.serialize_field("source", v)?;
12371 }
12372 object::ObjectInfo::Sink(v) => {
12373 struct_ser.serialize_field("sink", v)?;
12374 }
12375 object::ObjectInfo::View(v) => {
12376 struct_ser.serialize_field("view", v)?;
12377 }
12378 object::ObjectInfo::Function(v) => {
12379 struct_ser.serialize_field("function", v)?;
12380 }
12381 object::ObjectInfo::Connection(v) => {
12382 struct_ser.serialize_field("connection", v)?;
12383 }
12384 object::ObjectInfo::Subscription(v) => {
12385 struct_ser.serialize_field("subscription", v)?;
12386 }
12387 object::ObjectInfo::Secret(v) => {
12388 struct_ser.serialize_field("secret", v)?;
12389 }
12390 }
12391 }
12392 struct_ser.end()
12393 }
12394}
12395impl<'de> serde::Deserialize<'de> for Object {
12396 #[allow(deprecated)]
12397 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12398 where
12399 D: serde::Deserializer<'de>,
12400 {
12401 const FIELDS: &[&str] = &[
12402 "database",
12403 "schema",
12404 "table",
12405 "index",
12406 "source",
12407 "sink",
12408 "view",
12409 "function",
12410 "connection",
12411 "subscription",
12412 "secret",
12413 ];
12414
12415 #[allow(clippy::enum_variant_names)]
12416 enum GeneratedField {
12417 Database,
12418 Schema,
12419 Table,
12420 Index,
12421 Source,
12422 Sink,
12423 View,
12424 Function,
12425 Connection,
12426 Subscription,
12427 Secret,
12428 }
12429 impl<'de> serde::Deserialize<'de> for GeneratedField {
12430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12431 where
12432 D: serde::Deserializer<'de>,
12433 {
12434 struct GeneratedVisitor;
12435
12436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12437 type Value = GeneratedField;
12438
12439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12440 write!(formatter, "expected one of: {:?}", &FIELDS)
12441 }
12442
12443 #[allow(unused_variables)]
12444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12445 where
12446 E: serde::de::Error,
12447 {
12448 match value {
12449 "database" => Ok(GeneratedField::Database),
12450 "schema" => Ok(GeneratedField::Schema),
12451 "table" => Ok(GeneratedField::Table),
12452 "index" => Ok(GeneratedField::Index),
12453 "source" => Ok(GeneratedField::Source),
12454 "sink" => Ok(GeneratedField::Sink),
12455 "view" => Ok(GeneratedField::View),
12456 "function" => Ok(GeneratedField::Function),
12457 "connection" => Ok(GeneratedField::Connection),
12458 "subscription" => Ok(GeneratedField::Subscription),
12459 "secret" => Ok(GeneratedField::Secret),
12460 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12461 }
12462 }
12463 }
12464 deserializer.deserialize_identifier(GeneratedVisitor)
12465 }
12466 }
12467 struct GeneratedVisitor;
12468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12469 type Value = Object;
12470
12471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12472 formatter.write_str("struct meta.Object")
12473 }
12474
12475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12476 where
12477 V: serde::de::MapAccess<'de>,
12478 {
12479 let mut object_info__ = None;
12480 while let Some(k) = map_.next_key()? {
12481 match k {
12482 GeneratedField::Database => {
12483 if object_info__.is_some() {
12484 return Err(serde::de::Error::duplicate_field("database"));
12485 }
12486 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12487;
12488 }
12489 GeneratedField::Schema => {
12490 if object_info__.is_some() {
12491 return Err(serde::de::Error::duplicate_field("schema"));
12492 }
12493 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12494;
12495 }
12496 GeneratedField::Table => {
12497 if object_info__.is_some() {
12498 return Err(serde::de::Error::duplicate_field("table"));
12499 }
12500 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12501;
12502 }
12503 GeneratedField::Index => {
12504 if object_info__.is_some() {
12505 return Err(serde::de::Error::duplicate_field("index"));
12506 }
12507 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12508;
12509 }
12510 GeneratedField::Source => {
12511 if object_info__.is_some() {
12512 return Err(serde::de::Error::duplicate_field("source"));
12513 }
12514 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12515;
12516 }
12517 GeneratedField::Sink => {
12518 if object_info__.is_some() {
12519 return Err(serde::de::Error::duplicate_field("sink"));
12520 }
12521 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12522;
12523 }
12524 GeneratedField::View => {
12525 if object_info__.is_some() {
12526 return Err(serde::de::Error::duplicate_field("view"));
12527 }
12528 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12529;
12530 }
12531 GeneratedField::Function => {
12532 if object_info__.is_some() {
12533 return Err(serde::de::Error::duplicate_field("function"));
12534 }
12535 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12536;
12537 }
12538 GeneratedField::Connection => {
12539 if object_info__.is_some() {
12540 return Err(serde::de::Error::duplicate_field("connection"));
12541 }
12542 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12543;
12544 }
12545 GeneratedField::Subscription => {
12546 if object_info__.is_some() {
12547 return Err(serde::de::Error::duplicate_field("subscription"));
12548 }
12549 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12550;
12551 }
12552 GeneratedField::Secret => {
12553 if object_info__.is_some() {
12554 return Err(serde::de::Error::duplicate_field("secret"));
12555 }
12556 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12557;
12558 }
12559 }
12560 }
12561 Ok(Object {
12562 object_info: object_info__,
12563 })
12564 }
12565 }
12566 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12567 }
12568}
12569impl serde::Serialize for ObjectGroup {
12570 #[allow(deprecated)]
12571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12572 where
12573 S: serde::Serializer,
12574 {
12575 use serde::ser::SerializeStruct;
12576 let mut len = 0;
12577 if !self.objects.is_empty() {
12578 len += 1;
12579 }
12580 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12581 if !self.objects.is_empty() {
12582 struct_ser.serialize_field("objects", &self.objects)?;
12583 }
12584 struct_ser.end()
12585 }
12586}
12587impl<'de> serde::Deserialize<'de> for ObjectGroup {
12588 #[allow(deprecated)]
12589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12590 where
12591 D: serde::Deserializer<'de>,
12592 {
12593 const FIELDS: &[&str] = &[
12594 "objects",
12595 ];
12596
12597 #[allow(clippy::enum_variant_names)]
12598 enum GeneratedField {
12599 Objects,
12600 }
12601 impl<'de> serde::Deserialize<'de> for GeneratedField {
12602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12603 where
12604 D: serde::Deserializer<'de>,
12605 {
12606 struct GeneratedVisitor;
12607
12608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12609 type Value = GeneratedField;
12610
12611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12612 write!(formatter, "expected one of: {:?}", &FIELDS)
12613 }
12614
12615 #[allow(unused_variables)]
12616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12617 where
12618 E: serde::de::Error,
12619 {
12620 match value {
12621 "objects" => Ok(GeneratedField::Objects),
12622 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12623 }
12624 }
12625 }
12626 deserializer.deserialize_identifier(GeneratedVisitor)
12627 }
12628 }
12629 struct GeneratedVisitor;
12630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12631 type Value = ObjectGroup;
12632
12633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12634 formatter.write_str("struct meta.ObjectGroup")
12635 }
12636
12637 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12638 where
12639 V: serde::de::MapAccess<'de>,
12640 {
12641 let mut objects__ = None;
12642 while let Some(k) = map_.next_key()? {
12643 match k {
12644 GeneratedField::Objects => {
12645 if objects__.is_some() {
12646 return Err(serde::de::Error::duplicate_field("objects"));
12647 }
12648 objects__ = Some(map_.next_value()?);
12649 }
12650 }
12651 }
12652 Ok(ObjectGroup {
12653 objects: objects__.unwrap_or_default(),
12654 })
12655 }
12656 }
12657 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12658 }
12659}
12660impl serde::Serialize for PauseRequest {
12661 #[allow(deprecated)]
12662 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12663 where
12664 S: serde::Serializer,
12665 {
12666 use serde::ser::SerializeStruct;
12667 let len = 0;
12668 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12669 struct_ser.end()
12670 }
12671}
12672impl<'de> serde::Deserialize<'de> for PauseRequest {
12673 #[allow(deprecated)]
12674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12675 where
12676 D: serde::Deserializer<'de>,
12677 {
12678 const FIELDS: &[&str] = &[
12679 ];
12680
12681 #[allow(clippy::enum_variant_names)]
12682 enum GeneratedField {
12683 }
12684 impl<'de> serde::Deserialize<'de> for GeneratedField {
12685 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12686 where
12687 D: serde::Deserializer<'de>,
12688 {
12689 struct GeneratedVisitor;
12690
12691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12692 type Value = GeneratedField;
12693
12694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12695 write!(formatter, "expected one of: {:?}", &FIELDS)
12696 }
12697
12698 #[allow(unused_variables)]
12699 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12700 where
12701 E: serde::de::Error,
12702 {
12703 Err(serde::de::Error::unknown_field(value, FIELDS))
12704 }
12705 }
12706 deserializer.deserialize_identifier(GeneratedVisitor)
12707 }
12708 }
12709 struct GeneratedVisitor;
12710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12711 type Value = PauseRequest;
12712
12713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12714 formatter.write_str("struct meta.PauseRequest")
12715 }
12716
12717 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12718 where
12719 V: serde::de::MapAccess<'de>,
12720 {
12721 while map_.next_key::<GeneratedField>()?.is_some() {
12722 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12723 }
12724 Ok(PauseRequest {
12725 })
12726 }
12727 }
12728 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12729 }
12730}
12731impl serde::Serialize for PauseResponse {
12732 #[allow(deprecated)]
12733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12734 where
12735 S: serde::Serializer,
12736 {
12737 use serde::ser::SerializeStruct;
12738 let len = 0;
12739 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12740 struct_ser.end()
12741 }
12742}
12743impl<'de> serde::Deserialize<'de> for PauseResponse {
12744 #[allow(deprecated)]
12745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12746 where
12747 D: serde::Deserializer<'de>,
12748 {
12749 const FIELDS: &[&str] = &[
12750 ];
12751
12752 #[allow(clippy::enum_variant_names)]
12753 enum GeneratedField {
12754 }
12755 impl<'de> serde::Deserialize<'de> for GeneratedField {
12756 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12757 where
12758 D: serde::Deserializer<'de>,
12759 {
12760 struct GeneratedVisitor;
12761
12762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12763 type Value = GeneratedField;
12764
12765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12766 write!(formatter, "expected one of: {:?}", &FIELDS)
12767 }
12768
12769 #[allow(unused_variables)]
12770 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12771 where
12772 E: serde::de::Error,
12773 {
12774 Err(serde::de::Error::unknown_field(value, FIELDS))
12775 }
12776 }
12777 deserializer.deserialize_identifier(GeneratedVisitor)
12778 }
12779 }
12780 struct GeneratedVisitor;
12781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12782 type Value = PauseResponse;
12783
12784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12785 formatter.write_str("struct meta.PauseResponse")
12786 }
12787
12788 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12789 where
12790 V: serde::de::MapAccess<'de>,
12791 {
12792 while map_.next_key::<GeneratedField>()?.is_some() {
12793 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12794 }
12795 Ok(PauseResponse {
12796 })
12797 }
12798 }
12799 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12800 }
12801}
12802impl serde::Serialize for RecoverRequest {
12803 #[allow(deprecated)]
12804 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12805 where
12806 S: serde::Serializer,
12807 {
12808 use serde::ser::SerializeStruct;
12809 let len = 0;
12810 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12811 struct_ser.end()
12812 }
12813}
12814impl<'de> serde::Deserialize<'de> for RecoverRequest {
12815 #[allow(deprecated)]
12816 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12817 where
12818 D: serde::Deserializer<'de>,
12819 {
12820 const FIELDS: &[&str] = &[
12821 ];
12822
12823 #[allow(clippy::enum_variant_names)]
12824 enum GeneratedField {
12825 }
12826 impl<'de> serde::Deserialize<'de> for GeneratedField {
12827 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12828 where
12829 D: serde::Deserializer<'de>,
12830 {
12831 struct GeneratedVisitor;
12832
12833 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12834 type Value = GeneratedField;
12835
12836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12837 write!(formatter, "expected one of: {:?}", &FIELDS)
12838 }
12839
12840 #[allow(unused_variables)]
12841 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12842 where
12843 E: serde::de::Error,
12844 {
12845 Err(serde::de::Error::unknown_field(value, FIELDS))
12846 }
12847 }
12848 deserializer.deserialize_identifier(GeneratedVisitor)
12849 }
12850 }
12851 struct GeneratedVisitor;
12852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12853 type Value = RecoverRequest;
12854
12855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12856 formatter.write_str("struct meta.RecoverRequest")
12857 }
12858
12859 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12860 where
12861 V: serde::de::MapAccess<'de>,
12862 {
12863 while map_.next_key::<GeneratedField>()?.is_some() {
12864 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12865 }
12866 Ok(RecoverRequest {
12867 })
12868 }
12869 }
12870 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12871 }
12872}
12873impl serde::Serialize for RecoverResponse {
12874 #[allow(deprecated)]
12875 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12876 where
12877 S: serde::Serializer,
12878 {
12879 use serde::ser::SerializeStruct;
12880 let len = 0;
12881 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12882 struct_ser.end()
12883 }
12884}
12885impl<'de> serde::Deserialize<'de> for RecoverResponse {
12886 #[allow(deprecated)]
12887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12888 where
12889 D: serde::Deserializer<'de>,
12890 {
12891 const FIELDS: &[&str] = &[
12892 ];
12893
12894 #[allow(clippy::enum_variant_names)]
12895 enum GeneratedField {
12896 }
12897 impl<'de> serde::Deserialize<'de> for GeneratedField {
12898 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12899 where
12900 D: serde::Deserializer<'de>,
12901 {
12902 struct GeneratedVisitor;
12903
12904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12905 type Value = GeneratedField;
12906
12907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12908 write!(formatter, "expected one of: {:?}", &FIELDS)
12909 }
12910
12911 #[allow(unused_variables)]
12912 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12913 where
12914 E: serde::de::Error,
12915 {
12916 Err(serde::de::Error::unknown_field(value, FIELDS))
12917 }
12918 }
12919 deserializer.deserialize_identifier(GeneratedVisitor)
12920 }
12921 }
12922 struct GeneratedVisitor;
12923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12924 type Value = RecoverResponse;
12925
12926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12927 formatter.write_str("struct meta.RecoverResponse")
12928 }
12929
12930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12931 where
12932 V: serde::de::MapAccess<'de>,
12933 {
12934 while map_.next_key::<GeneratedField>()?.is_some() {
12935 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12936 }
12937 Ok(RecoverResponse {
12938 })
12939 }
12940 }
12941 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12942 }
12943}
12944impl serde::Serialize for Recovery {
12945 #[allow(deprecated)]
12946 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12947 where
12948 S: serde::Serializer,
12949 {
12950 use serde::ser::SerializeStruct;
12951 let len = 0;
12952 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12953 struct_ser.end()
12954 }
12955}
12956impl<'de> serde::Deserialize<'de> for Recovery {
12957 #[allow(deprecated)]
12958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12959 where
12960 D: serde::Deserializer<'de>,
12961 {
12962 const FIELDS: &[&str] = &[
12963 ];
12964
12965 #[allow(clippy::enum_variant_names)]
12966 enum GeneratedField {
12967 }
12968 impl<'de> serde::Deserialize<'de> for GeneratedField {
12969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12970 where
12971 D: serde::Deserializer<'de>,
12972 {
12973 struct GeneratedVisitor;
12974
12975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12976 type Value = GeneratedField;
12977
12978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12979 write!(formatter, "expected one of: {:?}", &FIELDS)
12980 }
12981
12982 #[allow(unused_variables)]
12983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12984 where
12985 E: serde::de::Error,
12986 {
12987 Err(serde::de::Error::unknown_field(value, FIELDS))
12988 }
12989 }
12990 deserializer.deserialize_identifier(GeneratedVisitor)
12991 }
12992 }
12993 struct GeneratedVisitor;
12994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12995 type Value = Recovery;
12996
12997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12998 formatter.write_str("struct meta.Recovery")
12999 }
13000
13001 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
13002 where
13003 V: serde::de::MapAccess<'de>,
13004 {
13005 while map_.next_key::<GeneratedField>()?.is_some() {
13006 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13007 }
13008 Ok(Recovery {
13009 })
13010 }
13011 }
13012 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
13013 }
13014}
13015impl serde::Serialize for RecoveryStatus {
13016 #[allow(deprecated)]
13017 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13018 where
13019 S: serde::Serializer,
13020 {
13021 let variant = match self {
13022 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
13023 Self::StatusStarting => "STATUS_STARTING",
13024 Self::StatusRecovering => "STATUS_RECOVERING",
13025 Self::StatusRunning => "STATUS_RUNNING",
13026 };
13027 serializer.serialize_str(variant)
13028 }
13029}
13030impl<'de> serde::Deserialize<'de> for RecoveryStatus {
13031 #[allow(deprecated)]
13032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13033 where
13034 D: serde::Deserializer<'de>,
13035 {
13036 const FIELDS: &[&str] = &[
13037 "STATUS_UNSPECIFIED",
13038 "STATUS_STARTING",
13039 "STATUS_RECOVERING",
13040 "STATUS_RUNNING",
13041 ];
13042
13043 struct GeneratedVisitor;
13044
13045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13046 type Value = RecoveryStatus;
13047
13048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13049 write!(formatter, "expected one of: {:?}", &FIELDS)
13050 }
13051
13052 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13053 where
13054 E: serde::de::Error,
13055 {
13056 i32::try_from(v)
13057 .ok()
13058 .and_then(|x| x.try_into().ok())
13059 .ok_or_else(|| {
13060 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13061 })
13062 }
13063
13064 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13065 where
13066 E: serde::de::Error,
13067 {
13068 i32::try_from(v)
13069 .ok()
13070 .and_then(|x| x.try_into().ok())
13071 .ok_or_else(|| {
13072 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13073 })
13074 }
13075
13076 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13077 where
13078 E: serde::de::Error,
13079 {
13080 match value {
13081 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
13082 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
13083 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
13084 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
13085 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13086 }
13087 }
13088 }
13089 deserializer.deserialize_any(GeneratedVisitor)
13090 }
13091}
13092impl serde::Serialize for RefreshRequest {
13093 #[allow(deprecated)]
13094 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13095 where
13096 S: serde::Serializer,
13097 {
13098 use serde::ser::SerializeStruct;
13099 let mut len = 0;
13100 if self.table_id != 0 {
13101 len += 1;
13102 }
13103 if self.associated_source_id != 0 {
13104 len += 1;
13105 }
13106 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
13107 if self.table_id != 0 {
13108 struct_ser.serialize_field("tableId", &self.table_id)?;
13109 }
13110 if self.associated_source_id != 0 {
13111 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
13112 }
13113 struct_ser.end()
13114 }
13115}
13116impl<'de> serde::Deserialize<'de> for RefreshRequest {
13117 #[allow(deprecated)]
13118 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13119 where
13120 D: serde::Deserializer<'de>,
13121 {
13122 const FIELDS: &[&str] = &[
13123 "table_id",
13124 "tableId",
13125 "associated_source_id",
13126 "associatedSourceId",
13127 ];
13128
13129 #[allow(clippy::enum_variant_names)]
13130 enum GeneratedField {
13131 TableId,
13132 AssociatedSourceId,
13133 }
13134 impl<'de> serde::Deserialize<'de> for GeneratedField {
13135 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13136 where
13137 D: serde::Deserializer<'de>,
13138 {
13139 struct GeneratedVisitor;
13140
13141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13142 type Value = GeneratedField;
13143
13144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13145 write!(formatter, "expected one of: {:?}", &FIELDS)
13146 }
13147
13148 #[allow(unused_variables)]
13149 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13150 where
13151 E: serde::de::Error,
13152 {
13153 match value {
13154 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13155 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
13156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13157 }
13158 }
13159 }
13160 deserializer.deserialize_identifier(GeneratedVisitor)
13161 }
13162 }
13163 struct GeneratedVisitor;
13164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13165 type Value = RefreshRequest;
13166
13167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13168 formatter.write_str("struct meta.RefreshRequest")
13169 }
13170
13171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
13172 where
13173 V: serde::de::MapAccess<'de>,
13174 {
13175 let mut table_id__ = None;
13176 let mut associated_source_id__ = None;
13177 while let Some(k) = map_.next_key()? {
13178 match k {
13179 GeneratedField::TableId => {
13180 if table_id__.is_some() {
13181 return Err(serde::de::Error::duplicate_field("tableId"));
13182 }
13183 table_id__ =
13184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13185 ;
13186 }
13187 GeneratedField::AssociatedSourceId => {
13188 if associated_source_id__.is_some() {
13189 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
13190 }
13191 associated_source_id__ =
13192 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13193 ;
13194 }
13195 }
13196 }
13197 Ok(RefreshRequest {
13198 table_id: table_id__.unwrap_or_default(),
13199 associated_source_id: associated_source_id__.unwrap_or_default(),
13200 })
13201 }
13202 }
13203 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
13204 }
13205}
13206impl serde::Serialize for RefreshResponse {
13207 #[allow(deprecated)]
13208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13209 where
13210 S: serde::Serializer,
13211 {
13212 use serde::ser::SerializeStruct;
13213 let mut len = 0;
13214 if self.status.is_some() {
13215 len += 1;
13216 }
13217 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
13218 if let Some(v) = self.status.as_ref() {
13219 struct_ser.serialize_field("status", v)?;
13220 }
13221 struct_ser.end()
13222 }
13223}
13224impl<'de> serde::Deserialize<'de> for RefreshResponse {
13225 #[allow(deprecated)]
13226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13227 where
13228 D: serde::Deserializer<'de>,
13229 {
13230 const FIELDS: &[&str] = &[
13231 "status",
13232 ];
13233
13234 #[allow(clippy::enum_variant_names)]
13235 enum GeneratedField {
13236 Status,
13237 }
13238 impl<'de> serde::Deserialize<'de> for GeneratedField {
13239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13240 where
13241 D: serde::Deserializer<'de>,
13242 {
13243 struct GeneratedVisitor;
13244
13245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13246 type Value = GeneratedField;
13247
13248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13249 write!(formatter, "expected one of: {:?}", &FIELDS)
13250 }
13251
13252 #[allow(unused_variables)]
13253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13254 where
13255 E: serde::de::Error,
13256 {
13257 match value {
13258 "status" => Ok(GeneratedField::Status),
13259 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13260 }
13261 }
13262 }
13263 deserializer.deserialize_identifier(GeneratedVisitor)
13264 }
13265 }
13266 struct GeneratedVisitor;
13267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13268 type Value = RefreshResponse;
13269
13270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13271 formatter.write_str("struct meta.RefreshResponse")
13272 }
13273
13274 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
13275 where
13276 V: serde::de::MapAccess<'de>,
13277 {
13278 let mut status__ = None;
13279 while let Some(k) = map_.next_key()? {
13280 match k {
13281 GeneratedField::Status => {
13282 if status__.is_some() {
13283 return Err(serde::de::Error::duplicate_field("status"));
13284 }
13285 status__ = map_.next_value()?;
13286 }
13287 }
13288 }
13289 Ok(RefreshResponse {
13290 status: status__,
13291 })
13292 }
13293 }
13294 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
13295 }
13296}
13297impl serde::Serialize for RelationIdInfos {
13298 #[allow(deprecated)]
13299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13300 where
13301 S: serde::Serializer,
13302 {
13303 use serde::ser::SerializeStruct;
13304 let mut len = 0;
13305 if !self.map.is_empty() {
13306 len += 1;
13307 }
13308 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
13309 if !self.map.is_empty() {
13310 struct_ser.serialize_field("map", &self.map)?;
13311 }
13312 struct_ser.end()
13313 }
13314}
13315impl<'de> serde::Deserialize<'de> for RelationIdInfos {
13316 #[allow(deprecated)]
13317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13318 where
13319 D: serde::Deserializer<'de>,
13320 {
13321 const FIELDS: &[&str] = &[
13322 "map",
13323 ];
13324
13325 #[allow(clippy::enum_variant_names)]
13326 enum GeneratedField {
13327 Map,
13328 }
13329 impl<'de> serde::Deserialize<'de> for GeneratedField {
13330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13331 where
13332 D: serde::Deserializer<'de>,
13333 {
13334 struct GeneratedVisitor;
13335
13336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13337 type Value = GeneratedField;
13338
13339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13340 write!(formatter, "expected one of: {:?}", &FIELDS)
13341 }
13342
13343 #[allow(unused_variables)]
13344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13345 where
13346 E: serde::de::Error,
13347 {
13348 match value {
13349 "map" => Ok(GeneratedField::Map),
13350 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13351 }
13352 }
13353 }
13354 deserializer.deserialize_identifier(GeneratedVisitor)
13355 }
13356 }
13357 struct GeneratedVisitor;
13358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13359 type Value = RelationIdInfos;
13360
13361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13362 formatter.write_str("struct meta.RelationIdInfos")
13363 }
13364
13365 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
13366 where
13367 V: serde::de::MapAccess<'de>,
13368 {
13369 let mut map__ = None;
13370 while let Some(k) = map_.next_key()? {
13371 match k {
13372 GeneratedField::Map => {
13373 if map__.is_some() {
13374 return Err(serde::de::Error::duplicate_field("map"));
13375 }
13376 map__ = Some(
13377 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13378 .into_iter().map(|(k,v)| (k.0, v)).collect()
13379 );
13380 }
13381 }
13382 }
13383 Ok(RelationIdInfos {
13384 map: map__.unwrap_or_default(),
13385 })
13386 }
13387 }
13388 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
13389 }
13390}
13391impl serde::Serialize for RescheduleRequest {
13392 #[allow(deprecated)]
13393 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13394 where
13395 S: serde::Serializer,
13396 {
13397 use serde::ser::SerializeStruct;
13398 let mut len = 0;
13399 if self.revision != 0 {
13400 len += 1;
13401 }
13402 if self.resolve_no_shuffle_upstream {
13403 len += 1;
13404 }
13405 if !self.worker_reschedules.is_empty() {
13406 len += 1;
13407 }
13408 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
13409 if self.revision != 0 {
13410 #[allow(clippy::needless_borrow)]
13411 #[allow(clippy::needless_borrows_for_generic_args)]
13412 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13413 }
13414 if self.resolve_no_shuffle_upstream {
13415 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
13416 }
13417 if !self.worker_reschedules.is_empty() {
13418 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
13419 }
13420 struct_ser.end()
13421 }
13422}
13423impl<'de> serde::Deserialize<'de> for RescheduleRequest {
13424 #[allow(deprecated)]
13425 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13426 where
13427 D: serde::Deserializer<'de>,
13428 {
13429 const FIELDS: &[&str] = &[
13430 "revision",
13431 "resolve_no_shuffle_upstream",
13432 "resolveNoShuffleUpstream",
13433 "worker_reschedules",
13434 "workerReschedules",
13435 ];
13436
13437 #[allow(clippy::enum_variant_names)]
13438 enum GeneratedField {
13439 Revision,
13440 ResolveNoShuffleUpstream,
13441 WorkerReschedules,
13442 }
13443 impl<'de> serde::Deserialize<'de> for GeneratedField {
13444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13445 where
13446 D: serde::Deserializer<'de>,
13447 {
13448 struct GeneratedVisitor;
13449
13450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13451 type Value = GeneratedField;
13452
13453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13454 write!(formatter, "expected one of: {:?}", &FIELDS)
13455 }
13456
13457 #[allow(unused_variables)]
13458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13459 where
13460 E: serde::de::Error,
13461 {
13462 match value {
13463 "revision" => Ok(GeneratedField::Revision),
13464 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
13465 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
13466 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13467 }
13468 }
13469 }
13470 deserializer.deserialize_identifier(GeneratedVisitor)
13471 }
13472 }
13473 struct GeneratedVisitor;
13474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13475 type Value = RescheduleRequest;
13476
13477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13478 formatter.write_str("struct meta.RescheduleRequest")
13479 }
13480
13481 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
13482 where
13483 V: serde::de::MapAccess<'de>,
13484 {
13485 let mut revision__ = None;
13486 let mut resolve_no_shuffle_upstream__ = None;
13487 let mut worker_reschedules__ = None;
13488 while let Some(k) = map_.next_key()? {
13489 match k {
13490 GeneratedField::Revision => {
13491 if revision__.is_some() {
13492 return Err(serde::de::Error::duplicate_field("revision"));
13493 }
13494 revision__ =
13495 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13496 ;
13497 }
13498 GeneratedField::ResolveNoShuffleUpstream => {
13499 if resolve_no_shuffle_upstream__.is_some() {
13500 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
13501 }
13502 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
13503 }
13504 GeneratedField::WorkerReschedules => {
13505 if worker_reschedules__.is_some() {
13506 return Err(serde::de::Error::duplicate_field("workerReschedules"));
13507 }
13508 worker_reschedules__ = Some(
13509 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13510 .into_iter().map(|(k,v)| (k.0, v)).collect()
13511 );
13512 }
13513 }
13514 }
13515 Ok(RescheduleRequest {
13516 revision: revision__.unwrap_or_default(),
13517 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
13518 worker_reschedules: worker_reschedules__.unwrap_or_default(),
13519 })
13520 }
13521 }
13522 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
13523 }
13524}
13525impl serde::Serialize for RescheduleResponse {
13526 #[allow(deprecated)]
13527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13528 where
13529 S: serde::Serializer,
13530 {
13531 use serde::ser::SerializeStruct;
13532 let mut len = 0;
13533 if self.success {
13534 len += 1;
13535 }
13536 if self.revision != 0 {
13537 len += 1;
13538 }
13539 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
13540 if self.success {
13541 struct_ser.serialize_field("success", &self.success)?;
13542 }
13543 if self.revision != 0 {
13544 #[allow(clippy::needless_borrow)]
13545 #[allow(clippy::needless_borrows_for_generic_args)]
13546 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13547 }
13548 struct_ser.end()
13549 }
13550}
13551impl<'de> serde::Deserialize<'de> for RescheduleResponse {
13552 #[allow(deprecated)]
13553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13554 where
13555 D: serde::Deserializer<'de>,
13556 {
13557 const FIELDS: &[&str] = &[
13558 "success",
13559 "revision",
13560 ];
13561
13562 #[allow(clippy::enum_variant_names)]
13563 enum GeneratedField {
13564 Success,
13565 Revision,
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 "success" => Ok(GeneratedField::Success),
13588 "revision" => Ok(GeneratedField::Revision),
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 = RescheduleResponse;
13599
13600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13601 formatter.write_str("struct meta.RescheduleResponse")
13602 }
13603
13604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
13605 where
13606 V: serde::de::MapAccess<'de>,
13607 {
13608 let mut success__ = None;
13609 let mut revision__ = None;
13610 while let Some(k) = map_.next_key()? {
13611 match k {
13612 GeneratedField::Success => {
13613 if success__.is_some() {
13614 return Err(serde::de::Error::duplicate_field("success"));
13615 }
13616 success__ = Some(map_.next_value()?);
13617 }
13618 GeneratedField::Revision => {
13619 if revision__.is_some() {
13620 return Err(serde::de::Error::duplicate_field("revision"));
13621 }
13622 revision__ =
13623 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13624 ;
13625 }
13626 }
13627 }
13628 Ok(RescheduleResponse {
13629 success: success__.unwrap_or_default(),
13630 revision: revision__.unwrap_or_default(),
13631 })
13632 }
13633 }
13634 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
13635 }
13636}
13637impl serde::Serialize for ResumeRequest {
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.ResumeRequest", len)?;
13646 struct_ser.end()
13647 }
13648}
13649impl<'de> serde::Deserialize<'de> for ResumeRequest {
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 = ResumeRequest;
13689
13690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13691 formatter.write_str("struct meta.ResumeRequest")
13692 }
13693
13694 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, 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(ResumeRequest {
13702 })
13703 }
13704 }
13705 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13706 }
13707}
13708impl serde::Serialize for ResumeResponse {
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 len = 0;
13716 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13717 struct_ser.end()
13718 }
13719}
13720impl<'de> serde::Deserialize<'de> for ResumeResponse {
13721 #[allow(deprecated)]
13722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13723 where
13724 D: serde::Deserializer<'de>,
13725 {
13726 const FIELDS: &[&str] = &[
13727 ];
13728
13729 #[allow(clippy::enum_variant_names)]
13730 enum GeneratedField {
13731 }
13732 impl<'de> serde::Deserialize<'de> for GeneratedField {
13733 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13734 where
13735 D: serde::Deserializer<'de>,
13736 {
13737 struct GeneratedVisitor;
13738
13739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13740 type Value = GeneratedField;
13741
13742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13743 write!(formatter, "expected one of: {:?}", &FIELDS)
13744 }
13745
13746 #[allow(unused_variables)]
13747 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13748 where
13749 E: serde::de::Error,
13750 {
13751 Err(serde::de::Error::unknown_field(value, FIELDS))
13752 }
13753 }
13754 deserializer.deserialize_identifier(GeneratedVisitor)
13755 }
13756 }
13757 struct GeneratedVisitor;
13758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13759 type Value = ResumeResponse;
13760
13761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13762 formatter.write_str("struct meta.ResumeResponse")
13763 }
13764
13765 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13766 where
13767 V: serde::de::MapAccess<'de>,
13768 {
13769 while map_.next_key::<GeneratedField>()?.is_some() {
13770 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13771 }
13772 Ok(ResumeResponse {
13773 })
13774 }
13775 }
13776 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13777 }
13778}
13779impl serde::Serialize for SetSessionParamRequest {
13780 #[allow(deprecated)]
13781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13782 where
13783 S: serde::Serializer,
13784 {
13785 use serde::ser::SerializeStruct;
13786 let mut len = 0;
13787 if !self.param.is_empty() {
13788 len += 1;
13789 }
13790 if self.value.is_some() {
13791 len += 1;
13792 }
13793 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13794 if !self.param.is_empty() {
13795 struct_ser.serialize_field("param", &self.param)?;
13796 }
13797 if let Some(v) = self.value.as_ref() {
13798 struct_ser.serialize_field("value", v)?;
13799 }
13800 struct_ser.end()
13801 }
13802}
13803impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13804 #[allow(deprecated)]
13805 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13806 where
13807 D: serde::Deserializer<'de>,
13808 {
13809 const FIELDS: &[&str] = &[
13810 "param",
13811 "value",
13812 ];
13813
13814 #[allow(clippy::enum_variant_names)]
13815 enum GeneratedField {
13816 Param,
13817 Value,
13818 }
13819 impl<'de> serde::Deserialize<'de> for GeneratedField {
13820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13821 where
13822 D: serde::Deserializer<'de>,
13823 {
13824 struct GeneratedVisitor;
13825
13826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13827 type Value = GeneratedField;
13828
13829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13830 write!(formatter, "expected one of: {:?}", &FIELDS)
13831 }
13832
13833 #[allow(unused_variables)]
13834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13835 where
13836 E: serde::de::Error,
13837 {
13838 match value {
13839 "param" => Ok(GeneratedField::Param),
13840 "value" => Ok(GeneratedField::Value),
13841 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13842 }
13843 }
13844 }
13845 deserializer.deserialize_identifier(GeneratedVisitor)
13846 }
13847 }
13848 struct GeneratedVisitor;
13849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13850 type Value = SetSessionParamRequest;
13851
13852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13853 formatter.write_str("struct meta.SetSessionParamRequest")
13854 }
13855
13856 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13857 where
13858 V: serde::de::MapAccess<'de>,
13859 {
13860 let mut param__ = None;
13861 let mut value__ = None;
13862 while let Some(k) = map_.next_key()? {
13863 match k {
13864 GeneratedField::Param => {
13865 if param__.is_some() {
13866 return Err(serde::de::Error::duplicate_field("param"));
13867 }
13868 param__ = Some(map_.next_value()?);
13869 }
13870 GeneratedField::Value => {
13871 if value__.is_some() {
13872 return Err(serde::de::Error::duplicate_field("value"));
13873 }
13874 value__ = map_.next_value()?;
13875 }
13876 }
13877 }
13878 Ok(SetSessionParamRequest {
13879 param: param__.unwrap_or_default(),
13880 value: value__,
13881 })
13882 }
13883 }
13884 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13885 }
13886}
13887impl serde::Serialize for SetSessionParamResponse {
13888 #[allow(deprecated)]
13889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13890 where
13891 S: serde::Serializer,
13892 {
13893 use serde::ser::SerializeStruct;
13894 let mut len = 0;
13895 if !self.param.is_empty() {
13896 len += 1;
13897 }
13898 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13899 if !self.param.is_empty() {
13900 struct_ser.serialize_field("param", &self.param)?;
13901 }
13902 struct_ser.end()
13903 }
13904}
13905impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13906 #[allow(deprecated)]
13907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13908 where
13909 D: serde::Deserializer<'de>,
13910 {
13911 const FIELDS: &[&str] = &[
13912 "param",
13913 ];
13914
13915 #[allow(clippy::enum_variant_names)]
13916 enum GeneratedField {
13917 Param,
13918 }
13919 impl<'de> serde::Deserialize<'de> for GeneratedField {
13920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13921 where
13922 D: serde::Deserializer<'de>,
13923 {
13924 struct GeneratedVisitor;
13925
13926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13927 type Value = GeneratedField;
13928
13929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13930 write!(formatter, "expected one of: {:?}", &FIELDS)
13931 }
13932
13933 #[allow(unused_variables)]
13934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13935 where
13936 E: serde::de::Error,
13937 {
13938 match value {
13939 "param" => Ok(GeneratedField::Param),
13940 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13941 }
13942 }
13943 }
13944 deserializer.deserialize_identifier(GeneratedVisitor)
13945 }
13946 }
13947 struct GeneratedVisitor;
13948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13949 type Value = SetSessionParamResponse;
13950
13951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13952 formatter.write_str("struct meta.SetSessionParamResponse")
13953 }
13954
13955 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13956 where
13957 V: serde::de::MapAccess<'de>,
13958 {
13959 let mut param__ = None;
13960 while let Some(k) = map_.next_key()? {
13961 match k {
13962 GeneratedField::Param => {
13963 if param__.is_some() {
13964 return Err(serde::de::Error::duplicate_field("param"));
13965 }
13966 param__ = Some(map_.next_value()?);
13967 }
13968 }
13969 }
13970 Ok(SetSessionParamResponse {
13971 param: param__.unwrap_or_default(),
13972 })
13973 }
13974 }
13975 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13976 }
13977}
13978impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13979 #[allow(deprecated)]
13980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13981 where
13982 S: serde::Serializer,
13983 {
13984 use serde::ser::SerializeStruct;
13985 let mut len = 0;
13986 if self.job_id != 0 {
13987 len += 1;
13988 }
13989 if self.aligned {
13990 len += 1;
13991 }
13992 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13993 if self.job_id != 0 {
13994 struct_ser.serialize_field("jobId", &self.job_id)?;
13995 }
13996 if self.aligned {
13997 struct_ser.serialize_field("aligned", &self.aligned)?;
13998 }
13999 struct_ser.end()
14000 }
14001}
14002impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
14003 #[allow(deprecated)]
14004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14005 where
14006 D: serde::Deserializer<'de>,
14007 {
14008 const FIELDS: &[&str] = &[
14009 "job_id",
14010 "jobId",
14011 "aligned",
14012 ];
14013
14014 #[allow(clippy::enum_variant_names)]
14015 enum GeneratedField {
14016 JobId,
14017 Aligned,
14018 }
14019 impl<'de> serde::Deserialize<'de> for GeneratedField {
14020 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14021 where
14022 D: serde::Deserializer<'de>,
14023 {
14024 struct GeneratedVisitor;
14025
14026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14027 type Value = GeneratedField;
14028
14029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14030 write!(formatter, "expected one of: {:?}", &FIELDS)
14031 }
14032
14033 #[allow(unused_variables)]
14034 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14035 where
14036 E: serde::de::Error,
14037 {
14038 match value {
14039 "jobId" | "job_id" => Ok(GeneratedField::JobId),
14040 "aligned" => Ok(GeneratedField::Aligned),
14041 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14042 }
14043 }
14044 }
14045 deserializer.deserialize_identifier(GeneratedVisitor)
14046 }
14047 }
14048 struct GeneratedVisitor;
14049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14050 type Value = SetSyncLogStoreAlignedRequest;
14051
14052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14053 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
14054 }
14055
14056 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
14057 where
14058 V: serde::de::MapAccess<'de>,
14059 {
14060 let mut job_id__ = None;
14061 let mut aligned__ = None;
14062 while let Some(k) = map_.next_key()? {
14063 match k {
14064 GeneratedField::JobId => {
14065 if job_id__.is_some() {
14066 return Err(serde::de::Error::duplicate_field("jobId"));
14067 }
14068 job_id__ =
14069 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14070 ;
14071 }
14072 GeneratedField::Aligned => {
14073 if aligned__.is_some() {
14074 return Err(serde::de::Error::duplicate_field("aligned"));
14075 }
14076 aligned__ = Some(map_.next_value()?);
14077 }
14078 }
14079 }
14080 Ok(SetSyncLogStoreAlignedRequest {
14081 job_id: job_id__.unwrap_or_default(),
14082 aligned: aligned__.unwrap_or_default(),
14083 })
14084 }
14085 }
14086 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
14087 }
14088}
14089impl serde::Serialize for SetSyncLogStoreAlignedResponse {
14090 #[allow(deprecated)]
14091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14092 where
14093 S: serde::Serializer,
14094 {
14095 use serde::ser::SerializeStruct;
14096 let len = 0;
14097 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
14098 struct_ser.end()
14099 }
14100}
14101impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
14102 #[allow(deprecated)]
14103 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14104 where
14105 D: serde::Deserializer<'de>,
14106 {
14107 const FIELDS: &[&str] = &[
14108 ];
14109
14110 #[allow(clippy::enum_variant_names)]
14111 enum GeneratedField {
14112 }
14113 impl<'de> serde::Deserialize<'de> for GeneratedField {
14114 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14115 where
14116 D: serde::Deserializer<'de>,
14117 {
14118 struct GeneratedVisitor;
14119
14120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14121 type Value = GeneratedField;
14122
14123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14124 write!(formatter, "expected one of: {:?}", &FIELDS)
14125 }
14126
14127 #[allow(unused_variables)]
14128 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14129 where
14130 E: serde::de::Error,
14131 {
14132 Err(serde::de::Error::unknown_field(value, FIELDS))
14133 }
14134 }
14135 deserializer.deserialize_identifier(GeneratedVisitor)
14136 }
14137 }
14138 struct GeneratedVisitor;
14139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14140 type Value = SetSyncLogStoreAlignedResponse;
14141
14142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14143 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
14144 }
14145
14146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
14147 where
14148 V: serde::de::MapAccess<'de>,
14149 {
14150 while map_.next_key::<GeneratedField>()?.is_some() {
14151 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14152 }
14153 Ok(SetSyncLogStoreAlignedResponse {
14154 })
14155 }
14156 }
14157 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
14158 }
14159}
14160impl serde::Serialize for SetSystemParamRequest {
14161 #[allow(deprecated)]
14162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14163 where
14164 S: serde::Serializer,
14165 {
14166 use serde::ser::SerializeStruct;
14167 let mut len = 0;
14168 if !self.param.is_empty() {
14169 len += 1;
14170 }
14171 if self.value.is_some() {
14172 len += 1;
14173 }
14174 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
14175 if !self.param.is_empty() {
14176 struct_ser.serialize_field("param", &self.param)?;
14177 }
14178 if let Some(v) = self.value.as_ref() {
14179 struct_ser.serialize_field("value", v)?;
14180 }
14181 struct_ser.end()
14182 }
14183}
14184impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
14185 #[allow(deprecated)]
14186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14187 where
14188 D: serde::Deserializer<'de>,
14189 {
14190 const FIELDS: &[&str] = &[
14191 "param",
14192 "value",
14193 ];
14194
14195 #[allow(clippy::enum_variant_names)]
14196 enum GeneratedField {
14197 Param,
14198 Value,
14199 }
14200 impl<'de> serde::Deserialize<'de> for GeneratedField {
14201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14202 where
14203 D: serde::Deserializer<'de>,
14204 {
14205 struct GeneratedVisitor;
14206
14207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14208 type Value = GeneratedField;
14209
14210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14211 write!(formatter, "expected one of: {:?}", &FIELDS)
14212 }
14213
14214 #[allow(unused_variables)]
14215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14216 where
14217 E: serde::de::Error,
14218 {
14219 match value {
14220 "param" => Ok(GeneratedField::Param),
14221 "value" => Ok(GeneratedField::Value),
14222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14223 }
14224 }
14225 }
14226 deserializer.deserialize_identifier(GeneratedVisitor)
14227 }
14228 }
14229 struct GeneratedVisitor;
14230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14231 type Value = SetSystemParamRequest;
14232
14233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14234 formatter.write_str("struct meta.SetSystemParamRequest")
14235 }
14236
14237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
14238 where
14239 V: serde::de::MapAccess<'de>,
14240 {
14241 let mut param__ = None;
14242 let mut value__ = None;
14243 while let Some(k) = map_.next_key()? {
14244 match k {
14245 GeneratedField::Param => {
14246 if param__.is_some() {
14247 return Err(serde::de::Error::duplicate_field("param"));
14248 }
14249 param__ = Some(map_.next_value()?);
14250 }
14251 GeneratedField::Value => {
14252 if value__.is_some() {
14253 return Err(serde::de::Error::duplicate_field("value"));
14254 }
14255 value__ = map_.next_value()?;
14256 }
14257 }
14258 }
14259 Ok(SetSystemParamRequest {
14260 param: param__.unwrap_or_default(),
14261 value: value__,
14262 })
14263 }
14264 }
14265 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
14266 }
14267}
14268impl serde::Serialize for SetSystemParamResponse {
14269 #[allow(deprecated)]
14270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14271 where
14272 S: serde::Serializer,
14273 {
14274 use serde::ser::SerializeStruct;
14275 let mut len = 0;
14276 if self.params.is_some() {
14277 len += 1;
14278 }
14279 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
14280 if let Some(v) = self.params.as_ref() {
14281 struct_ser.serialize_field("params", v)?;
14282 }
14283 struct_ser.end()
14284 }
14285}
14286impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
14287 #[allow(deprecated)]
14288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14289 where
14290 D: serde::Deserializer<'de>,
14291 {
14292 const FIELDS: &[&str] = &[
14293 "params",
14294 ];
14295
14296 #[allow(clippy::enum_variant_names)]
14297 enum GeneratedField {
14298 Params,
14299 }
14300 impl<'de> serde::Deserialize<'de> for GeneratedField {
14301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14302 where
14303 D: serde::Deserializer<'de>,
14304 {
14305 struct GeneratedVisitor;
14306
14307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14308 type Value = GeneratedField;
14309
14310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14311 write!(formatter, "expected one of: {:?}", &FIELDS)
14312 }
14313
14314 #[allow(unused_variables)]
14315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14316 where
14317 E: serde::de::Error,
14318 {
14319 match value {
14320 "params" => Ok(GeneratedField::Params),
14321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14322 }
14323 }
14324 }
14325 deserializer.deserialize_identifier(GeneratedVisitor)
14326 }
14327 }
14328 struct GeneratedVisitor;
14329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14330 type Value = SetSystemParamResponse;
14331
14332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14333 formatter.write_str("struct meta.SetSystemParamResponse")
14334 }
14335
14336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
14337 where
14338 V: serde::de::MapAccess<'de>,
14339 {
14340 let mut params__ = None;
14341 while let Some(k) = map_.next_key()? {
14342 match k {
14343 GeneratedField::Params => {
14344 if params__.is_some() {
14345 return Err(serde::de::Error::duplicate_field("params"));
14346 }
14347 params__ = map_.next_value()?;
14348 }
14349 }
14350 }
14351 Ok(SetSystemParamResponse {
14352 params: params__,
14353 })
14354 }
14355 }
14356 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
14357 }
14358}
14359impl serde::Serialize for SubscribeRequest {
14360 #[allow(deprecated)]
14361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14362 where
14363 S: serde::Serializer,
14364 {
14365 use serde::ser::SerializeStruct;
14366 let mut len = 0;
14367 if self.subscribe_type != 0 {
14368 len += 1;
14369 }
14370 if self.host.is_some() {
14371 len += 1;
14372 }
14373 if self.worker_id != 0 {
14374 len += 1;
14375 }
14376 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
14377 if self.subscribe_type != 0 {
14378 let v = SubscribeType::try_from(self.subscribe_type)
14379 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
14380 struct_ser.serialize_field("subscribeType", &v)?;
14381 }
14382 if let Some(v) = self.host.as_ref() {
14383 struct_ser.serialize_field("host", v)?;
14384 }
14385 if self.worker_id != 0 {
14386 struct_ser.serialize_field("workerId", &self.worker_id)?;
14387 }
14388 struct_ser.end()
14389 }
14390}
14391impl<'de> serde::Deserialize<'de> for SubscribeRequest {
14392 #[allow(deprecated)]
14393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14394 where
14395 D: serde::Deserializer<'de>,
14396 {
14397 const FIELDS: &[&str] = &[
14398 "subscribe_type",
14399 "subscribeType",
14400 "host",
14401 "worker_id",
14402 "workerId",
14403 ];
14404
14405 #[allow(clippy::enum_variant_names)]
14406 enum GeneratedField {
14407 SubscribeType,
14408 Host,
14409 WorkerId,
14410 }
14411 impl<'de> serde::Deserialize<'de> for GeneratedField {
14412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14413 where
14414 D: serde::Deserializer<'de>,
14415 {
14416 struct GeneratedVisitor;
14417
14418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14419 type Value = GeneratedField;
14420
14421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14422 write!(formatter, "expected one of: {:?}", &FIELDS)
14423 }
14424
14425 #[allow(unused_variables)]
14426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14427 where
14428 E: serde::de::Error,
14429 {
14430 match value {
14431 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
14432 "host" => Ok(GeneratedField::Host),
14433 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
14434 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14435 }
14436 }
14437 }
14438 deserializer.deserialize_identifier(GeneratedVisitor)
14439 }
14440 }
14441 struct GeneratedVisitor;
14442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14443 type Value = SubscribeRequest;
14444
14445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14446 formatter.write_str("struct meta.SubscribeRequest")
14447 }
14448
14449 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
14450 where
14451 V: serde::de::MapAccess<'de>,
14452 {
14453 let mut subscribe_type__ = None;
14454 let mut host__ = None;
14455 let mut worker_id__ = None;
14456 while let Some(k) = map_.next_key()? {
14457 match k {
14458 GeneratedField::SubscribeType => {
14459 if subscribe_type__.is_some() {
14460 return Err(serde::de::Error::duplicate_field("subscribeType"));
14461 }
14462 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
14463 }
14464 GeneratedField::Host => {
14465 if host__.is_some() {
14466 return Err(serde::de::Error::duplicate_field("host"));
14467 }
14468 host__ = map_.next_value()?;
14469 }
14470 GeneratedField::WorkerId => {
14471 if worker_id__.is_some() {
14472 return Err(serde::de::Error::duplicate_field("workerId"));
14473 }
14474 worker_id__ =
14475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14476 ;
14477 }
14478 }
14479 }
14480 Ok(SubscribeRequest {
14481 subscribe_type: subscribe_type__.unwrap_or_default(),
14482 host: host__,
14483 worker_id: worker_id__.unwrap_or_default(),
14484 })
14485 }
14486 }
14487 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
14488 }
14489}
14490impl serde::Serialize for SubscribeResponse {
14491 #[allow(deprecated)]
14492 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14493 where
14494 S: serde::Serializer,
14495 {
14496 use serde::ser::SerializeStruct;
14497 let mut len = 0;
14498 if self.status.is_some() {
14499 len += 1;
14500 }
14501 if self.operation != 0 {
14502 len += 1;
14503 }
14504 if self.version != 0 {
14505 len += 1;
14506 }
14507 if self.info.is_some() {
14508 len += 1;
14509 }
14510 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
14511 if let Some(v) = self.status.as_ref() {
14512 struct_ser.serialize_field("status", v)?;
14513 }
14514 if self.operation != 0 {
14515 let v = subscribe_response::Operation::try_from(self.operation)
14516 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
14517 struct_ser.serialize_field("operation", &v)?;
14518 }
14519 if self.version != 0 {
14520 #[allow(clippy::needless_borrow)]
14521 #[allow(clippy::needless_borrows_for_generic_args)]
14522 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
14523 }
14524 if let Some(v) = self.info.as_ref() {
14525 match v {
14526 subscribe_response::Info::Database(v) => {
14527 struct_ser.serialize_field("database", v)?;
14528 }
14529 subscribe_response::Info::Schema(v) => {
14530 struct_ser.serialize_field("schema", v)?;
14531 }
14532 subscribe_response::Info::Function(v) => {
14533 struct_ser.serialize_field("function", v)?;
14534 }
14535 subscribe_response::Info::User(v) => {
14536 struct_ser.serialize_field("user", v)?;
14537 }
14538 subscribe_response::Info::SessionParam(v) => {
14539 struct_ser.serialize_field("sessionParam", v)?;
14540 }
14541 subscribe_response::Info::Node(v) => {
14542 struct_ser.serialize_field("node", v)?;
14543 }
14544 subscribe_response::Info::HummockVersionDeltas(v) => {
14545 struct_ser.serialize_field("hummockVersionDeltas", v)?;
14546 }
14547 subscribe_response::Info::Snapshot(v) => {
14548 struct_ser.serialize_field("snapshot", v)?;
14549 }
14550 subscribe_response::Info::MetaBackupManifestId(v) => {
14551 struct_ser.serialize_field("metaBackupManifestId", v)?;
14552 }
14553 subscribe_response::Info::SystemParams(v) => {
14554 struct_ser.serialize_field("systemParams", v)?;
14555 }
14556 subscribe_response::Info::HummockWriteLimits(v) => {
14557 struct_ser.serialize_field("hummockWriteLimits", v)?;
14558 }
14559 subscribe_response::Info::ObjectGroup(v) => {
14560 struct_ser.serialize_field("objectGroup", v)?;
14561 }
14562 subscribe_response::Info::Connection(v) => {
14563 struct_ser.serialize_field("connection", v)?;
14564 }
14565 subscribe_response::Info::HummockStats(v) => {
14566 struct_ser.serialize_field("hummockStats", v)?;
14567 }
14568 subscribe_response::Info::Recovery(v) => {
14569 struct_ser.serialize_field("recovery", v)?;
14570 }
14571 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
14572 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
14573 }
14574 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
14575 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
14576 }
14577 subscribe_response::Info::Secret(v) => {
14578 struct_ser.serialize_field("secret", v)?;
14579 }
14580 subscribe_response::Info::ClusterResource(v) => {
14581 struct_ser.serialize_field("clusterResource", v)?;
14582 }
14583 }
14584 }
14585 struct_ser.end()
14586 }
14587}
14588impl<'de> serde::Deserialize<'de> for SubscribeResponse {
14589 #[allow(deprecated)]
14590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14591 where
14592 D: serde::Deserializer<'de>,
14593 {
14594 const FIELDS: &[&str] = &[
14595 "status",
14596 "operation",
14597 "version",
14598 "database",
14599 "schema",
14600 "function",
14601 "user",
14602 "session_param",
14603 "sessionParam",
14604 "node",
14605 "hummock_version_deltas",
14606 "hummockVersionDeltas",
14607 "snapshot",
14608 "meta_backup_manifest_id",
14609 "metaBackupManifestId",
14610 "system_params",
14611 "systemParams",
14612 "hummock_write_limits",
14613 "hummockWriteLimits",
14614 "object_group",
14615 "objectGroup",
14616 "connection",
14617 "hummock_stats",
14618 "hummockStats",
14619 "recovery",
14620 "streaming_worker_slot_mapping",
14621 "streamingWorkerSlotMapping",
14622 "serving_worker_slot_mappings",
14623 "servingWorkerSlotMappings",
14624 "secret",
14625 "cluster_resource",
14626 "clusterResource",
14627 ];
14628
14629 #[allow(clippy::enum_variant_names)]
14630 enum GeneratedField {
14631 Status,
14632 Operation,
14633 Version,
14634 Database,
14635 Schema,
14636 Function,
14637 User,
14638 SessionParam,
14639 Node,
14640 HummockVersionDeltas,
14641 Snapshot,
14642 MetaBackupManifestId,
14643 SystemParams,
14644 HummockWriteLimits,
14645 ObjectGroup,
14646 Connection,
14647 HummockStats,
14648 Recovery,
14649 StreamingWorkerSlotMapping,
14650 ServingWorkerSlotMappings,
14651 Secret,
14652 ClusterResource,
14653 }
14654 impl<'de> serde::Deserialize<'de> for GeneratedField {
14655 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14656 where
14657 D: serde::Deserializer<'de>,
14658 {
14659 struct GeneratedVisitor;
14660
14661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14662 type Value = GeneratedField;
14663
14664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14665 write!(formatter, "expected one of: {:?}", &FIELDS)
14666 }
14667
14668 #[allow(unused_variables)]
14669 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14670 where
14671 E: serde::de::Error,
14672 {
14673 match value {
14674 "status" => Ok(GeneratedField::Status),
14675 "operation" => Ok(GeneratedField::Operation),
14676 "version" => Ok(GeneratedField::Version),
14677 "database" => Ok(GeneratedField::Database),
14678 "schema" => Ok(GeneratedField::Schema),
14679 "function" => Ok(GeneratedField::Function),
14680 "user" => Ok(GeneratedField::User),
14681 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14682 "node" => Ok(GeneratedField::Node),
14683 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14684 "snapshot" => Ok(GeneratedField::Snapshot),
14685 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14686 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14687 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14688 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14689 "connection" => Ok(GeneratedField::Connection),
14690 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14691 "recovery" => Ok(GeneratedField::Recovery),
14692 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14693 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14694 "secret" => Ok(GeneratedField::Secret),
14695 "clusterResource" | "cluster_resource" => Ok(GeneratedField::ClusterResource),
14696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14697 }
14698 }
14699 }
14700 deserializer.deserialize_identifier(GeneratedVisitor)
14701 }
14702 }
14703 struct GeneratedVisitor;
14704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14705 type Value = SubscribeResponse;
14706
14707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14708 formatter.write_str("struct meta.SubscribeResponse")
14709 }
14710
14711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14712 where
14713 V: serde::de::MapAccess<'de>,
14714 {
14715 let mut status__ = None;
14716 let mut operation__ = None;
14717 let mut version__ = None;
14718 let mut info__ = None;
14719 while let Some(k) = map_.next_key()? {
14720 match k {
14721 GeneratedField::Status => {
14722 if status__.is_some() {
14723 return Err(serde::de::Error::duplicate_field("status"));
14724 }
14725 status__ = map_.next_value()?;
14726 }
14727 GeneratedField::Operation => {
14728 if operation__.is_some() {
14729 return Err(serde::de::Error::duplicate_field("operation"));
14730 }
14731 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14732 }
14733 GeneratedField::Version => {
14734 if version__.is_some() {
14735 return Err(serde::de::Error::duplicate_field("version"));
14736 }
14737 version__ =
14738 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14739 ;
14740 }
14741 GeneratedField::Database => {
14742 if info__.is_some() {
14743 return Err(serde::de::Error::duplicate_field("database"));
14744 }
14745 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14746;
14747 }
14748 GeneratedField::Schema => {
14749 if info__.is_some() {
14750 return Err(serde::de::Error::duplicate_field("schema"));
14751 }
14752 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14753;
14754 }
14755 GeneratedField::Function => {
14756 if info__.is_some() {
14757 return Err(serde::de::Error::duplicate_field("function"));
14758 }
14759 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14760;
14761 }
14762 GeneratedField::User => {
14763 if info__.is_some() {
14764 return Err(serde::de::Error::duplicate_field("user"));
14765 }
14766 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14767;
14768 }
14769 GeneratedField::SessionParam => {
14770 if info__.is_some() {
14771 return Err(serde::de::Error::duplicate_field("sessionParam"));
14772 }
14773 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14774;
14775 }
14776 GeneratedField::Node => {
14777 if info__.is_some() {
14778 return Err(serde::de::Error::duplicate_field("node"));
14779 }
14780 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14781;
14782 }
14783 GeneratedField::HummockVersionDeltas => {
14784 if info__.is_some() {
14785 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14786 }
14787 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14788;
14789 }
14790 GeneratedField::Snapshot => {
14791 if info__.is_some() {
14792 return Err(serde::de::Error::duplicate_field("snapshot"));
14793 }
14794 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14795;
14796 }
14797 GeneratedField::MetaBackupManifestId => {
14798 if info__.is_some() {
14799 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14800 }
14801 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14802;
14803 }
14804 GeneratedField::SystemParams => {
14805 if info__.is_some() {
14806 return Err(serde::de::Error::duplicate_field("systemParams"));
14807 }
14808 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14809;
14810 }
14811 GeneratedField::HummockWriteLimits => {
14812 if info__.is_some() {
14813 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14814 }
14815 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14816;
14817 }
14818 GeneratedField::ObjectGroup => {
14819 if info__.is_some() {
14820 return Err(serde::de::Error::duplicate_field("objectGroup"));
14821 }
14822 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14823;
14824 }
14825 GeneratedField::Connection => {
14826 if info__.is_some() {
14827 return Err(serde::de::Error::duplicate_field("connection"));
14828 }
14829 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14830;
14831 }
14832 GeneratedField::HummockStats => {
14833 if info__.is_some() {
14834 return Err(serde::de::Error::duplicate_field("hummockStats"));
14835 }
14836 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14837;
14838 }
14839 GeneratedField::Recovery => {
14840 if info__.is_some() {
14841 return Err(serde::de::Error::duplicate_field("recovery"));
14842 }
14843 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14844;
14845 }
14846 GeneratedField::StreamingWorkerSlotMapping => {
14847 if info__.is_some() {
14848 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14849 }
14850 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14851;
14852 }
14853 GeneratedField::ServingWorkerSlotMappings => {
14854 if info__.is_some() {
14855 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14856 }
14857 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14858;
14859 }
14860 GeneratedField::Secret => {
14861 if info__.is_some() {
14862 return Err(serde::de::Error::duplicate_field("secret"));
14863 }
14864 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14865;
14866 }
14867 GeneratedField::ClusterResource => {
14868 if info__.is_some() {
14869 return Err(serde::de::Error::duplicate_field("clusterResource"));
14870 }
14871 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ClusterResource)
14872;
14873 }
14874 }
14875 }
14876 Ok(SubscribeResponse {
14877 status: status__,
14878 operation: operation__.unwrap_or_default(),
14879 version: version__.unwrap_or_default(),
14880 info: info__,
14881 })
14882 }
14883 }
14884 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14885 }
14886}
14887impl serde::Serialize for subscribe_response::Operation {
14888 #[allow(deprecated)]
14889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14890 where
14891 S: serde::Serializer,
14892 {
14893 let variant = match self {
14894 Self::Unspecified => "UNSPECIFIED",
14895 Self::Add => "ADD",
14896 Self::Delete => "DELETE",
14897 Self::Update => "UPDATE",
14898 Self::Snapshot => "SNAPSHOT",
14899 };
14900 serializer.serialize_str(variant)
14901 }
14902}
14903impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14904 #[allow(deprecated)]
14905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14906 where
14907 D: serde::Deserializer<'de>,
14908 {
14909 const FIELDS: &[&str] = &[
14910 "UNSPECIFIED",
14911 "ADD",
14912 "DELETE",
14913 "UPDATE",
14914 "SNAPSHOT",
14915 ];
14916
14917 struct GeneratedVisitor;
14918
14919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14920 type Value = subscribe_response::Operation;
14921
14922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14923 write!(formatter, "expected one of: {:?}", &FIELDS)
14924 }
14925
14926 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14927 where
14928 E: serde::de::Error,
14929 {
14930 i32::try_from(v)
14931 .ok()
14932 .and_then(|x| x.try_into().ok())
14933 .ok_or_else(|| {
14934 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14935 })
14936 }
14937
14938 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14939 where
14940 E: serde::de::Error,
14941 {
14942 i32::try_from(v)
14943 .ok()
14944 .and_then(|x| x.try_into().ok())
14945 .ok_or_else(|| {
14946 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14947 })
14948 }
14949
14950 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14951 where
14952 E: serde::de::Error,
14953 {
14954 match value {
14955 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14956 "ADD" => Ok(subscribe_response::Operation::Add),
14957 "DELETE" => Ok(subscribe_response::Operation::Delete),
14958 "UPDATE" => Ok(subscribe_response::Operation::Update),
14959 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14960 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14961 }
14962 }
14963 }
14964 deserializer.deserialize_any(GeneratedVisitor)
14965 }
14966}
14967impl serde::Serialize for SubscribeType {
14968 #[allow(deprecated)]
14969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14970 where
14971 S: serde::Serializer,
14972 {
14973 let variant = match self {
14974 Self::Unspecified => "UNSPECIFIED",
14975 Self::Frontend => "FRONTEND",
14976 Self::Hummock => "HUMMOCK",
14977 Self::Compactor => "COMPACTOR",
14978 Self::Compute => "COMPUTE",
14979 };
14980 serializer.serialize_str(variant)
14981 }
14982}
14983impl<'de> serde::Deserialize<'de> for SubscribeType {
14984 #[allow(deprecated)]
14985 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14986 where
14987 D: serde::Deserializer<'de>,
14988 {
14989 const FIELDS: &[&str] = &[
14990 "UNSPECIFIED",
14991 "FRONTEND",
14992 "HUMMOCK",
14993 "COMPACTOR",
14994 "COMPUTE",
14995 ];
14996
14997 struct GeneratedVisitor;
14998
14999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15000 type Value = SubscribeType;
15001
15002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15003 write!(formatter, "expected one of: {:?}", &FIELDS)
15004 }
15005
15006 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15007 where
15008 E: serde::de::Error,
15009 {
15010 i32::try_from(v)
15011 .ok()
15012 .and_then(|x| x.try_into().ok())
15013 .ok_or_else(|| {
15014 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15015 })
15016 }
15017
15018 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15019 where
15020 E: serde::de::Error,
15021 {
15022 i32::try_from(v)
15023 .ok()
15024 .and_then(|x| x.try_into().ok())
15025 .ok_or_else(|| {
15026 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15027 })
15028 }
15029
15030 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15031 where
15032 E: serde::de::Error,
15033 {
15034 match value {
15035 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
15036 "FRONTEND" => Ok(SubscribeType::Frontend),
15037 "HUMMOCK" => Ok(SubscribeType::Hummock),
15038 "COMPACTOR" => Ok(SubscribeType::Compactor),
15039 "COMPUTE" => Ok(SubscribeType::Compute),
15040 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15041 }
15042 }
15043 }
15044 deserializer.deserialize_any(GeneratedVisitor)
15045 }
15046}
15047impl serde::Serialize for SystemParams {
15048 #[allow(deprecated)]
15049 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15050 where
15051 S: serde::Serializer,
15052 {
15053 use serde::ser::SerializeStruct;
15054 let mut len = 0;
15055 if self.barrier_interval_ms.is_some() {
15056 len += 1;
15057 }
15058 if self.checkpoint_frequency.is_some() {
15059 len += 1;
15060 }
15061 if self.sstable_size_mb.is_some() {
15062 len += 1;
15063 }
15064 if self.block_size_kb.is_some() {
15065 len += 1;
15066 }
15067 if self.bloom_false_positive.is_some() {
15068 len += 1;
15069 }
15070 if self.state_store.is_some() {
15071 len += 1;
15072 }
15073 if self.data_directory.is_some() {
15074 len += 1;
15075 }
15076 if self.backup_storage_url.is_some() {
15077 len += 1;
15078 }
15079 if self.backup_storage_directory.is_some() {
15080 len += 1;
15081 }
15082 if self.telemetry_enabled.is_some() {
15083 len += 1;
15084 }
15085 if self.parallel_compact_size_mb.is_some() {
15086 len += 1;
15087 }
15088 if self.max_concurrent_creating_streaming_jobs.is_some() {
15089 len += 1;
15090 }
15091 if self.pause_on_next_bootstrap.is_some() {
15092 len += 1;
15093 }
15094 if self.wasm_storage_url.is_some() {
15095 len += 1;
15096 }
15097 if self.enable_tracing.is_some() {
15098 len += 1;
15099 }
15100 if self.use_new_object_prefix_strategy.is_some() {
15101 len += 1;
15102 }
15103 if self.license_key.is_some() {
15104 len += 1;
15105 }
15106 if self.time_travel_retention_ms.is_some() {
15107 len += 1;
15108 }
15109 if self.adaptive_parallelism_strategy.is_some() {
15110 len += 1;
15111 }
15112 if self.per_database_isolation.is_some() {
15113 len += 1;
15114 }
15115 if self.enforce_secret.is_some() {
15116 len += 1;
15117 }
15118 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
15119 if let Some(v) = self.barrier_interval_ms.as_ref() {
15120 struct_ser.serialize_field("barrierIntervalMs", v)?;
15121 }
15122 if let Some(v) = self.checkpoint_frequency.as_ref() {
15123 #[allow(clippy::needless_borrow)]
15124 #[allow(clippy::needless_borrows_for_generic_args)]
15125 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
15126 }
15127 if let Some(v) = self.sstable_size_mb.as_ref() {
15128 struct_ser.serialize_field("sstableSizeMb", v)?;
15129 }
15130 if let Some(v) = self.block_size_kb.as_ref() {
15131 struct_ser.serialize_field("blockSizeKb", v)?;
15132 }
15133 if let Some(v) = self.bloom_false_positive.as_ref() {
15134 struct_ser.serialize_field("bloomFalsePositive", v)?;
15135 }
15136 if let Some(v) = self.state_store.as_ref() {
15137 struct_ser.serialize_field("stateStore", v)?;
15138 }
15139 if let Some(v) = self.data_directory.as_ref() {
15140 struct_ser.serialize_field("dataDirectory", v)?;
15141 }
15142 if let Some(v) = self.backup_storage_url.as_ref() {
15143 struct_ser.serialize_field("backupStorageUrl", v)?;
15144 }
15145 if let Some(v) = self.backup_storage_directory.as_ref() {
15146 struct_ser.serialize_field("backupStorageDirectory", v)?;
15147 }
15148 if let Some(v) = self.telemetry_enabled.as_ref() {
15149 struct_ser.serialize_field("telemetryEnabled", v)?;
15150 }
15151 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
15152 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
15153 }
15154 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
15155 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
15156 }
15157 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
15158 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
15159 }
15160 if let Some(v) = self.wasm_storage_url.as_ref() {
15161 struct_ser.serialize_field("wasmStorageUrl", v)?;
15162 }
15163 if let Some(v) = self.enable_tracing.as_ref() {
15164 struct_ser.serialize_field("enableTracing", v)?;
15165 }
15166 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
15167 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
15168 }
15169 if let Some(v) = self.license_key.as_ref() {
15170 struct_ser.serialize_field("licenseKey", v)?;
15171 }
15172 if let Some(v) = self.time_travel_retention_ms.as_ref() {
15173 #[allow(clippy::needless_borrow)]
15174 #[allow(clippy::needless_borrows_for_generic_args)]
15175 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
15176 }
15177 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
15178 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
15179 }
15180 if let Some(v) = self.per_database_isolation.as_ref() {
15181 struct_ser.serialize_field("perDatabaseIsolation", v)?;
15182 }
15183 if let Some(v) = self.enforce_secret.as_ref() {
15184 struct_ser.serialize_field("enforceSecret", v)?;
15185 }
15186 struct_ser.end()
15187 }
15188}
15189impl<'de> serde::Deserialize<'de> for SystemParams {
15190 #[allow(deprecated)]
15191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15192 where
15193 D: serde::Deserializer<'de>,
15194 {
15195 const FIELDS: &[&str] = &[
15196 "barrier_interval_ms",
15197 "barrierIntervalMs",
15198 "checkpoint_frequency",
15199 "checkpointFrequency",
15200 "sstable_size_mb",
15201 "sstableSizeMb",
15202 "block_size_kb",
15203 "blockSizeKb",
15204 "bloom_false_positive",
15205 "bloomFalsePositive",
15206 "state_store",
15207 "stateStore",
15208 "data_directory",
15209 "dataDirectory",
15210 "backup_storage_url",
15211 "backupStorageUrl",
15212 "backup_storage_directory",
15213 "backupStorageDirectory",
15214 "telemetry_enabled",
15215 "telemetryEnabled",
15216 "parallel_compact_size_mb",
15217 "parallelCompactSizeMb",
15218 "max_concurrent_creating_streaming_jobs",
15219 "maxConcurrentCreatingStreamingJobs",
15220 "pause_on_next_bootstrap",
15221 "pauseOnNextBootstrap",
15222 "wasm_storage_url",
15223 "wasmStorageUrl",
15224 "enable_tracing",
15225 "enableTracing",
15226 "use_new_object_prefix_strategy",
15227 "useNewObjectPrefixStrategy",
15228 "license_key",
15229 "licenseKey",
15230 "time_travel_retention_ms",
15231 "timeTravelRetentionMs",
15232 "adaptive_parallelism_strategy",
15233 "adaptiveParallelismStrategy",
15234 "per_database_isolation",
15235 "perDatabaseIsolation",
15236 "enforce_secret",
15237 "enforceSecret",
15238 ];
15239
15240 #[allow(clippy::enum_variant_names)]
15241 enum GeneratedField {
15242 BarrierIntervalMs,
15243 CheckpointFrequency,
15244 SstableSizeMb,
15245 BlockSizeKb,
15246 BloomFalsePositive,
15247 StateStore,
15248 DataDirectory,
15249 BackupStorageUrl,
15250 BackupStorageDirectory,
15251 TelemetryEnabled,
15252 ParallelCompactSizeMb,
15253 MaxConcurrentCreatingStreamingJobs,
15254 PauseOnNextBootstrap,
15255 WasmStorageUrl,
15256 EnableTracing,
15257 UseNewObjectPrefixStrategy,
15258 LicenseKey,
15259 TimeTravelRetentionMs,
15260 AdaptiveParallelismStrategy,
15261 PerDatabaseIsolation,
15262 EnforceSecret,
15263 }
15264 impl<'de> serde::Deserialize<'de> for GeneratedField {
15265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15266 where
15267 D: serde::Deserializer<'de>,
15268 {
15269 struct GeneratedVisitor;
15270
15271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15272 type Value = GeneratedField;
15273
15274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15275 write!(formatter, "expected one of: {:?}", &FIELDS)
15276 }
15277
15278 #[allow(unused_variables)]
15279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15280 where
15281 E: serde::de::Error,
15282 {
15283 match value {
15284 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
15285 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
15286 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
15287 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
15288 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
15289 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
15290 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
15291 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
15292 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
15293 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
15294 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
15295 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
15296 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
15297 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
15298 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
15299 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
15300 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
15301 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
15302 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15303 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
15304 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
15305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15306 }
15307 }
15308 }
15309 deserializer.deserialize_identifier(GeneratedVisitor)
15310 }
15311 }
15312 struct GeneratedVisitor;
15313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15314 type Value = SystemParams;
15315
15316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15317 formatter.write_str("struct meta.SystemParams")
15318 }
15319
15320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
15321 where
15322 V: serde::de::MapAccess<'de>,
15323 {
15324 let mut barrier_interval_ms__ = None;
15325 let mut checkpoint_frequency__ = None;
15326 let mut sstable_size_mb__ = None;
15327 let mut block_size_kb__ = None;
15328 let mut bloom_false_positive__ = None;
15329 let mut state_store__ = None;
15330 let mut data_directory__ = None;
15331 let mut backup_storage_url__ = None;
15332 let mut backup_storage_directory__ = None;
15333 let mut telemetry_enabled__ = None;
15334 let mut parallel_compact_size_mb__ = None;
15335 let mut max_concurrent_creating_streaming_jobs__ = None;
15336 let mut pause_on_next_bootstrap__ = None;
15337 let mut wasm_storage_url__ = None;
15338 let mut enable_tracing__ = None;
15339 let mut use_new_object_prefix_strategy__ = None;
15340 let mut license_key__ = None;
15341 let mut time_travel_retention_ms__ = None;
15342 let mut adaptive_parallelism_strategy__ = None;
15343 let mut per_database_isolation__ = None;
15344 let mut enforce_secret__ = None;
15345 while let Some(k) = map_.next_key()? {
15346 match k {
15347 GeneratedField::BarrierIntervalMs => {
15348 if barrier_interval_ms__.is_some() {
15349 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
15350 }
15351 barrier_interval_ms__ =
15352 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15353 ;
15354 }
15355 GeneratedField::CheckpointFrequency => {
15356 if checkpoint_frequency__.is_some() {
15357 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
15358 }
15359 checkpoint_frequency__ =
15360 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15361 ;
15362 }
15363 GeneratedField::SstableSizeMb => {
15364 if sstable_size_mb__.is_some() {
15365 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
15366 }
15367 sstable_size_mb__ =
15368 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15369 ;
15370 }
15371 GeneratedField::BlockSizeKb => {
15372 if block_size_kb__.is_some() {
15373 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
15374 }
15375 block_size_kb__ =
15376 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15377 ;
15378 }
15379 GeneratedField::BloomFalsePositive => {
15380 if bloom_false_positive__.is_some() {
15381 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
15382 }
15383 bloom_false_positive__ =
15384 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15385 ;
15386 }
15387 GeneratedField::StateStore => {
15388 if state_store__.is_some() {
15389 return Err(serde::de::Error::duplicate_field("stateStore"));
15390 }
15391 state_store__ = map_.next_value()?;
15392 }
15393 GeneratedField::DataDirectory => {
15394 if data_directory__.is_some() {
15395 return Err(serde::de::Error::duplicate_field("dataDirectory"));
15396 }
15397 data_directory__ = map_.next_value()?;
15398 }
15399 GeneratedField::BackupStorageUrl => {
15400 if backup_storage_url__.is_some() {
15401 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
15402 }
15403 backup_storage_url__ = map_.next_value()?;
15404 }
15405 GeneratedField::BackupStorageDirectory => {
15406 if backup_storage_directory__.is_some() {
15407 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
15408 }
15409 backup_storage_directory__ = map_.next_value()?;
15410 }
15411 GeneratedField::TelemetryEnabled => {
15412 if telemetry_enabled__.is_some() {
15413 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
15414 }
15415 telemetry_enabled__ = map_.next_value()?;
15416 }
15417 GeneratedField::ParallelCompactSizeMb => {
15418 if parallel_compact_size_mb__.is_some() {
15419 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
15420 }
15421 parallel_compact_size_mb__ =
15422 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15423 ;
15424 }
15425 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
15426 if max_concurrent_creating_streaming_jobs__.is_some() {
15427 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
15428 }
15429 max_concurrent_creating_streaming_jobs__ =
15430 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15431 ;
15432 }
15433 GeneratedField::PauseOnNextBootstrap => {
15434 if pause_on_next_bootstrap__.is_some() {
15435 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
15436 }
15437 pause_on_next_bootstrap__ = map_.next_value()?;
15438 }
15439 GeneratedField::WasmStorageUrl => {
15440 if wasm_storage_url__.is_some() {
15441 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
15442 }
15443 wasm_storage_url__ = map_.next_value()?;
15444 }
15445 GeneratedField::EnableTracing => {
15446 if enable_tracing__.is_some() {
15447 return Err(serde::de::Error::duplicate_field("enableTracing"));
15448 }
15449 enable_tracing__ = map_.next_value()?;
15450 }
15451 GeneratedField::UseNewObjectPrefixStrategy => {
15452 if use_new_object_prefix_strategy__.is_some() {
15453 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
15454 }
15455 use_new_object_prefix_strategy__ = map_.next_value()?;
15456 }
15457 GeneratedField::LicenseKey => {
15458 if license_key__.is_some() {
15459 return Err(serde::de::Error::duplicate_field("licenseKey"));
15460 }
15461 license_key__ = map_.next_value()?;
15462 }
15463 GeneratedField::TimeTravelRetentionMs => {
15464 if time_travel_retention_ms__.is_some() {
15465 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
15466 }
15467 time_travel_retention_ms__ =
15468 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15469 ;
15470 }
15471 GeneratedField::AdaptiveParallelismStrategy => {
15472 if adaptive_parallelism_strategy__.is_some() {
15473 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15474 }
15475 adaptive_parallelism_strategy__ = map_.next_value()?;
15476 }
15477 GeneratedField::PerDatabaseIsolation => {
15478 if per_database_isolation__.is_some() {
15479 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
15480 }
15481 per_database_isolation__ = map_.next_value()?;
15482 }
15483 GeneratedField::EnforceSecret => {
15484 if enforce_secret__.is_some() {
15485 return Err(serde::de::Error::duplicate_field("enforceSecret"));
15486 }
15487 enforce_secret__ = map_.next_value()?;
15488 }
15489 }
15490 }
15491 Ok(SystemParams {
15492 barrier_interval_ms: barrier_interval_ms__,
15493 checkpoint_frequency: checkpoint_frequency__,
15494 sstable_size_mb: sstable_size_mb__,
15495 block_size_kb: block_size_kb__,
15496 bloom_false_positive: bloom_false_positive__,
15497 state_store: state_store__,
15498 data_directory: data_directory__,
15499 backup_storage_url: backup_storage_url__,
15500 backup_storage_directory: backup_storage_directory__,
15501 telemetry_enabled: telemetry_enabled__,
15502 parallel_compact_size_mb: parallel_compact_size_mb__,
15503 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
15504 pause_on_next_bootstrap: pause_on_next_bootstrap__,
15505 wasm_storage_url: wasm_storage_url__,
15506 enable_tracing: enable_tracing__,
15507 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
15508 license_key: license_key__,
15509 time_travel_retention_ms: time_travel_retention_ms__,
15510 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
15511 per_database_isolation: per_database_isolation__,
15512 enforce_secret: enforce_secret__,
15513 })
15514 }
15515 }
15516 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
15517 }
15518}
15519impl serde::Serialize for TableFragments {
15520 #[allow(deprecated)]
15521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15522 where
15523 S: serde::Serializer,
15524 {
15525 use serde::ser::SerializeStruct;
15526 let mut len = 0;
15527 if self.table_id != 0 {
15528 len += 1;
15529 }
15530 if self.state != 0 {
15531 len += 1;
15532 }
15533 if !self.fragments.is_empty() {
15534 len += 1;
15535 }
15536 if !self.actor_status.is_empty() {
15537 len += 1;
15538 }
15539 if self.ctx.is_some() {
15540 len += 1;
15541 }
15542 if self.parallelism.is_some() {
15543 len += 1;
15544 }
15545 if self.max_parallelism.is_some() {
15546 len += 1;
15547 }
15548 if !self.node_label.is_empty() {
15549 len += 1;
15550 }
15551 if self.backfill_done {
15552 len += 1;
15553 }
15554 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
15555 if self.table_id != 0 {
15556 struct_ser.serialize_field("tableId", &self.table_id)?;
15557 }
15558 if self.state != 0 {
15559 let v = table_fragments::State::try_from(self.state)
15560 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15561 struct_ser.serialize_field("state", &v)?;
15562 }
15563 if !self.fragments.is_empty() {
15564 struct_ser.serialize_field("fragments", &self.fragments)?;
15565 }
15566 if !self.actor_status.is_empty() {
15567 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
15568 }
15569 if let Some(v) = self.ctx.as_ref() {
15570 struct_ser.serialize_field("ctx", v)?;
15571 }
15572 if let Some(v) = self.parallelism.as_ref() {
15573 struct_ser.serialize_field("parallelism", v)?;
15574 }
15575 if let Some(v) = self.max_parallelism.as_ref() {
15576 struct_ser.serialize_field("maxParallelism", v)?;
15577 }
15578 if !self.node_label.is_empty() {
15579 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15580 }
15581 if self.backfill_done {
15582 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
15583 }
15584 struct_ser.end()
15585 }
15586}
15587impl<'de> serde::Deserialize<'de> for TableFragments {
15588 #[allow(deprecated)]
15589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15590 where
15591 D: serde::Deserializer<'de>,
15592 {
15593 const FIELDS: &[&str] = &[
15594 "table_id",
15595 "tableId",
15596 "state",
15597 "fragments",
15598 "actor_status",
15599 "actorStatus",
15600 "ctx",
15601 "parallelism",
15602 "max_parallelism",
15603 "maxParallelism",
15604 "node_label",
15605 "nodeLabel",
15606 "backfill_done",
15607 "backfillDone",
15608 ];
15609
15610 #[allow(clippy::enum_variant_names)]
15611 enum GeneratedField {
15612 TableId,
15613 State,
15614 Fragments,
15615 ActorStatus,
15616 Ctx,
15617 Parallelism,
15618 MaxParallelism,
15619 NodeLabel,
15620 BackfillDone,
15621 }
15622 impl<'de> serde::Deserialize<'de> for GeneratedField {
15623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15624 where
15625 D: serde::Deserializer<'de>,
15626 {
15627 struct GeneratedVisitor;
15628
15629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15630 type Value = GeneratedField;
15631
15632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15633 write!(formatter, "expected one of: {:?}", &FIELDS)
15634 }
15635
15636 #[allow(unused_variables)]
15637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15638 where
15639 E: serde::de::Error,
15640 {
15641 match value {
15642 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15643 "state" => Ok(GeneratedField::State),
15644 "fragments" => Ok(GeneratedField::Fragments),
15645 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
15646 "ctx" => Ok(GeneratedField::Ctx),
15647 "parallelism" => Ok(GeneratedField::Parallelism),
15648 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15649 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15650 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15652 }
15653 }
15654 }
15655 deserializer.deserialize_identifier(GeneratedVisitor)
15656 }
15657 }
15658 struct GeneratedVisitor;
15659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15660 type Value = TableFragments;
15661
15662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15663 formatter.write_str("struct meta.TableFragments")
15664 }
15665
15666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15667 where
15668 V: serde::de::MapAccess<'de>,
15669 {
15670 let mut table_id__ = None;
15671 let mut state__ = None;
15672 let mut fragments__ = None;
15673 let mut actor_status__ = None;
15674 let mut ctx__ = None;
15675 let mut parallelism__ = None;
15676 let mut max_parallelism__ = None;
15677 let mut node_label__ = None;
15678 let mut backfill_done__ = None;
15679 while let Some(k) = map_.next_key()? {
15680 match k {
15681 GeneratedField::TableId => {
15682 if table_id__.is_some() {
15683 return Err(serde::de::Error::duplicate_field("tableId"));
15684 }
15685 table_id__ =
15686 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15687 ;
15688 }
15689 GeneratedField::State => {
15690 if state__.is_some() {
15691 return Err(serde::de::Error::duplicate_field("state"));
15692 }
15693 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15694 }
15695 GeneratedField::Fragments => {
15696 if fragments__.is_some() {
15697 return Err(serde::de::Error::duplicate_field("fragments"));
15698 }
15699 fragments__ = Some(
15700 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15701 .into_iter().map(|(k,v)| (k.0, v)).collect()
15702 );
15703 }
15704 GeneratedField::ActorStatus => {
15705 if actor_status__.is_some() {
15706 return Err(serde::de::Error::duplicate_field("actorStatus"));
15707 }
15708 actor_status__ = Some(
15709 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15710 .into_iter().map(|(k,v)| (k.0, v)).collect()
15711 );
15712 }
15713 GeneratedField::Ctx => {
15714 if ctx__.is_some() {
15715 return Err(serde::de::Error::duplicate_field("ctx"));
15716 }
15717 ctx__ = map_.next_value()?;
15718 }
15719 GeneratedField::Parallelism => {
15720 if parallelism__.is_some() {
15721 return Err(serde::de::Error::duplicate_field("parallelism"));
15722 }
15723 parallelism__ = map_.next_value()?;
15724 }
15725 GeneratedField::MaxParallelism => {
15726 if max_parallelism__.is_some() {
15727 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15728 }
15729 max_parallelism__ =
15730 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15731 ;
15732 }
15733 GeneratedField::NodeLabel => {
15734 if node_label__.is_some() {
15735 return Err(serde::de::Error::duplicate_field("nodeLabel"));
15736 }
15737 node_label__ = Some(map_.next_value()?);
15738 }
15739 GeneratedField::BackfillDone => {
15740 if backfill_done__.is_some() {
15741 return Err(serde::de::Error::duplicate_field("backfillDone"));
15742 }
15743 backfill_done__ = Some(map_.next_value()?);
15744 }
15745 }
15746 }
15747 Ok(TableFragments {
15748 table_id: table_id__.unwrap_or_default(),
15749 state: state__.unwrap_or_default(),
15750 fragments: fragments__.unwrap_or_default(),
15751 actor_status: actor_status__.unwrap_or_default(),
15752 ctx: ctx__,
15753 parallelism: parallelism__,
15754 max_parallelism: max_parallelism__,
15755 node_label: node_label__.unwrap_or_default(),
15756 backfill_done: backfill_done__.unwrap_or_default(),
15757 })
15758 }
15759 }
15760 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15761 }
15762}
15763impl serde::Serialize for table_fragments::ActorStatus {
15764 #[allow(deprecated)]
15765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15766 where
15767 S: serde::Serializer,
15768 {
15769 use serde::ser::SerializeStruct;
15770 let mut len = 0;
15771 if self.location.is_some() {
15772 len += 1;
15773 }
15774 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15775 if let Some(v) = self.location.as_ref() {
15776 struct_ser.serialize_field("location", v)?;
15777 }
15778 struct_ser.end()
15779 }
15780}
15781impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15782 #[allow(deprecated)]
15783 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15784 where
15785 D: serde::Deserializer<'de>,
15786 {
15787 const FIELDS: &[&str] = &[
15788 "location",
15789 ];
15790
15791 #[allow(clippy::enum_variant_names)]
15792 enum GeneratedField {
15793 Location,
15794 }
15795 impl<'de> serde::Deserialize<'de> for GeneratedField {
15796 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15797 where
15798 D: serde::Deserializer<'de>,
15799 {
15800 struct GeneratedVisitor;
15801
15802 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15803 type Value = GeneratedField;
15804
15805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15806 write!(formatter, "expected one of: {:?}", &FIELDS)
15807 }
15808
15809 #[allow(unused_variables)]
15810 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15811 where
15812 E: serde::de::Error,
15813 {
15814 match value {
15815 "location" => Ok(GeneratedField::Location),
15816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15817 }
15818 }
15819 }
15820 deserializer.deserialize_identifier(GeneratedVisitor)
15821 }
15822 }
15823 struct GeneratedVisitor;
15824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15825 type Value = table_fragments::ActorStatus;
15826
15827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15828 formatter.write_str("struct meta.TableFragments.ActorStatus")
15829 }
15830
15831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15832 where
15833 V: serde::de::MapAccess<'de>,
15834 {
15835 let mut location__ = None;
15836 while let Some(k) = map_.next_key()? {
15837 match k {
15838 GeneratedField::Location => {
15839 if location__.is_some() {
15840 return Err(serde::de::Error::duplicate_field("location"));
15841 }
15842 location__ = map_.next_value()?;
15843 }
15844 }
15845 }
15846 Ok(table_fragments::ActorStatus {
15847 location: location__,
15848 })
15849 }
15850 }
15851 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15852 }
15853}
15854impl serde::Serialize for table_fragments::Fragment {
15855 #[allow(deprecated)]
15856 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15857 where
15858 S: serde::Serializer,
15859 {
15860 use serde::ser::SerializeStruct;
15861 let mut len = 0;
15862 if self.fragment_id != 0 {
15863 len += 1;
15864 }
15865 if self.fragment_type_mask != 0 {
15866 len += 1;
15867 }
15868 if self.distribution_type != 0 {
15869 len += 1;
15870 }
15871 if !self.actors.is_empty() {
15872 len += 1;
15873 }
15874 if !self.state_table_ids.is_empty() {
15875 len += 1;
15876 }
15877 if !self.upstream_fragment_ids.is_empty() {
15878 len += 1;
15879 }
15880 if self.maybe_vnode_count.is_some() {
15881 len += 1;
15882 }
15883 if self.nodes.is_some() {
15884 len += 1;
15885 }
15886 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15887 if self.fragment_id != 0 {
15888 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15889 }
15890 if self.fragment_type_mask != 0 {
15891 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15892 }
15893 if self.distribution_type != 0 {
15894 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15895 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15896 struct_ser.serialize_field("distributionType", &v)?;
15897 }
15898 if !self.actors.is_empty() {
15899 struct_ser.serialize_field("actors", &self.actors)?;
15900 }
15901 if !self.state_table_ids.is_empty() {
15902 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
15903 }
15904 if !self.upstream_fragment_ids.is_empty() {
15905 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
15906 }
15907 if let Some(v) = self.maybe_vnode_count.as_ref() {
15908 struct_ser.serialize_field("maybeVnodeCount", v)?;
15909 }
15910 if let Some(v) = self.nodes.as_ref() {
15911 struct_ser.serialize_field("nodes", v)?;
15912 }
15913 struct_ser.end()
15914 }
15915}
15916impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
15917 #[allow(deprecated)]
15918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15919 where
15920 D: serde::Deserializer<'de>,
15921 {
15922 const FIELDS: &[&str] = &[
15923 "fragment_id",
15924 "fragmentId",
15925 "fragment_type_mask",
15926 "fragmentTypeMask",
15927 "distribution_type",
15928 "distributionType",
15929 "actors",
15930 "state_table_ids",
15931 "stateTableIds",
15932 "upstream_fragment_ids",
15933 "upstreamFragmentIds",
15934 "maybe_vnode_count",
15935 "maybeVnodeCount",
15936 "nodes",
15937 ];
15938
15939 #[allow(clippy::enum_variant_names)]
15940 enum GeneratedField {
15941 FragmentId,
15942 FragmentTypeMask,
15943 DistributionType,
15944 Actors,
15945 StateTableIds,
15946 UpstreamFragmentIds,
15947 MaybeVnodeCount,
15948 Nodes,
15949 }
15950 impl<'de> serde::Deserialize<'de> for GeneratedField {
15951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15952 where
15953 D: serde::Deserializer<'de>,
15954 {
15955 struct GeneratedVisitor;
15956
15957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15958 type Value = GeneratedField;
15959
15960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15961 write!(formatter, "expected one of: {:?}", &FIELDS)
15962 }
15963
15964 #[allow(unused_variables)]
15965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15966 where
15967 E: serde::de::Error,
15968 {
15969 match value {
15970 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15971 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15972 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
15973 "actors" => Ok(GeneratedField::Actors),
15974 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
15975 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
15976 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
15977 "nodes" => Ok(GeneratedField::Nodes),
15978 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15979 }
15980 }
15981 }
15982 deserializer.deserialize_identifier(GeneratedVisitor)
15983 }
15984 }
15985 struct GeneratedVisitor;
15986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15987 type Value = table_fragments::Fragment;
15988
15989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15990 formatter.write_str("struct meta.TableFragments.Fragment")
15991 }
15992
15993 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
15994 where
15995 V: serde::de::MapAccess<'de>,
15996 {
15997 let mut fragment_id__ = None;
15998 let mut fragment_type_mask__ = None;
15999 let mut distribution_type__ = None;
16000 let mut actors__ = None;
16001 let mut state_table_ids__ = None;
16002 let mut upstream_fragment_ids__ = None;
16003 let mut maybe_vnode_count__ = None;
16004 let mut nodes__ = None;
16005 while let Some(k) = map_.next_key()? {
16006 match k {
16007 GeneratedField::FragmentId => {
16008 if fragment_id__.is_some() {
16009 return Err(serde::de::Error::duplicate_field("fragmentId"));
16010 }
16011 fragment_id__ =
16012 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16013 ;
16014 }
16015 GeneratedField::FragmentTypeMask => {
16016 if fragment_type_mask__.is_some() {
16017 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
16018 }
16019 fragment_type_mask__ =
16020 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16021 ;
16022 }
16023 GeneratedField::DistributionType => {
16024 if distribution_type__.is_some() {
16025 return Err(serde::de::Error::duplicate_field("distributionType"));
16026 }
16027 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
16028 }
16029 GeneratedField::Actors => {
16030 if actors__.is_some() {
16031 return Err(serde::de::Error::duplicate_field("actors"));
16032 }
16033 actors__ = Some(map_.next_value()?);
16034 }
16035 GeneratedField::StateTableIds => {
16036 if state_table_ids__.is_some() {
16037 return Err(serde::de::Error::duplicate_field("stateTableIds"));
16038 }
16039 state_table_ids__ =
16040 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16041 .into_iter().map(|x| x.0).collect())
16042 ;
16043 }
16044 GeneratedField::UpstreamFragmentIds => {
16045 if upstream_fragment_ids__.is_some() {
16046 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
16047 }
16048 upstream_fragment_ids__ =
16049 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16050 .into_iter().map(|x| x.0).collect())
16051 ;
16052 }
16053 GeneratedField::MaybeVnodeCount => {
16054 if maybe_vnode_count__.is_some() {
16055 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
16056 }
16057 maybe_vnode_count__ =
16058 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16059 ;
16060 }
16061 GeneratedField::Nodes => {
16062 if nodes__.is_some() {
16063 return Err(serde::de::Error::duplicate_field("nodes"));
16064 }
16065 nodes__ = map_.next_value()?;
16066 }
16067 }
16068 }
16069 Ok(table_fragments::Fragment {
16070 fragment_id: fragment_id__.unwrap_or_default(),
16071 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16072 distribution_type: distribution_type__.unwrap_or_default(),
16073 actors: actors__.unwrap_or_default(),
16074 state_table_ids: state_table_ids__.unwrap_or_default(),
16075 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
16076 maybe_vnode_count: maybe_vnode_count__,
16077 nodes: nodes__,
16078 })
16079 }
16080 }
16081 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
16082 }
16083}
16084impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
16085 #[allow(deprecated)]
16086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16087 where
16088 S: serde::Serializer,
16089 {
16090 let variant = match self {
16091 Self::Unspecified => "UNSPECIFIED",
16092 Self::Single => "SINGLE",
16093 Self::Hash => "HASH",
16094 };
16095 serializer.serialize_str(variant)
16096 }
16097}
16098impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
16099 #[allow(deprecated)]
16100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16101 where
16102 D: serde::Deserializer<'de>,
16103 {
16104 const FIELDS: &[&str] = &[
16105 "UNSPECIFIED",
16106 "SINGLE",
16107 "HASH",
16108 ];
16109
16110 struct GeneratedVisitor;
16111
16112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16113 type Value = table_fragments::fragment::FragmentDistributionType;
16114
16115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16116 write!(formatter, "expected one of: {:?}", &FIELDS)
16117 }
16118
16119 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16120 where
16121 E: serde::de::Error,
16122 {
16123 i32::try_from(v)
16124 .ok()
16125 .and_then(|x| x.try_into().ok())
16126 .ok_or_else(|| {
16127 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16128 })
16129 }
16130
16131 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16132 where
16133 E: serde::de::Error,
16134 {
16135 i32::try_from(v)
16136 .ok()
16137 .and_then(|x| x.try_into().ok())
16138 .ok_or_else(|| {
16139 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16140 })
16141 }
16142
16143 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16144 where
16145 E: serde::de::Error,
16146 {
16147 match value {
16148 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
16149 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
16150 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
16151 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16152 }
16153 }
16154 }
16155 deserializer.deserialize_any(GeneratedVisitor)
16156 }
16157}
16158impl serde::Serialize for table_fragments::State {
16159 #[allow(deprecated)]
16160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16161 where
16162 S: serde::Serializer,
16163 {
16164 let variant = match self {
16165 Self::Unspecified => "UNSPECIFIED",
16166 Self::Initial => "INITIAL",
16167 Self::Creating => "CREATING",
16168 Self::Created => "CREATED",
16169 };
16170 serializer.serialize_str(variant)
16171 }
16172}
16173impl<'de> serde::Deserialize<'de> for table_fragments::State {
16174 #[allow(deprecated)]
16175 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16176 where
16177 D: serde::Deserializer<'de>,
16178 {
16179 const FIELDS: &[&str] = &[
16180 "UNSPECIFIED",
16181 "INITIAL",
16182 "CREATING",
16183 "CREATED",
16184 ];
16185
16186 struct GeneratedVisitor;
16187
16188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16189 type Value = table_fragments::State;
16190
16191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16192 write!(formatter, "expected one of: {:?}", &FIELDS)
16193 }
16194
16195 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16196 where
16197 E: serde::de::Error,
16198 {
16199 i32::try_from(v)
16200 .ok()
16201 .and_then(|x| x.try_into().ok())
16202 .ok_or_else(|| {
16203 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16204 })
16205 }
16206
16207 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16208 where
16209 E: serde::de::Error,
16210 {
16211 i32::try_from(v)
16212 .ok()
16213 .and_then(|x| x.try_into().ok())
16214 .ok_or_else(|| {
16215 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16216 })
16217 }
16218
16219 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16220 where
16221 E: serde::de::Error,
16222 {
16223 match value {
16224 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
16225 "INITIAL" => Ok(table_fragments::State::Initial),
16226 "CREATING" => Ok(table_fragments::State::Creating),
16227 "CREATED" => Ok(table_fragments::State::Created),
16228 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16229 }
16230 }
16231 }
16232 deserializer.deserialize_any(GeneratedVisitor)
16233 }
16234}
16235impl serde::Serialize for TableParallelism {
16236 #[allow(deprecated)]
16237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16238 where
16239 S: serde::Serializer,
16240 {
16241 use serde::ser::SerializeStruct;
16242 let mut len = 0;
16243 if self.parallelism.is_some() {
16244 len += 1;
16245 }
16246 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
16247 if let Some(v) = self.parallelism.as_ref() {
16248 match v {
16249 table_parallelism::Parallelism::Fixed(v) => {
16250 struct_ser.serialize_field("fixed", v)?;
16251 }
16252 table_parallelism::Parallelism::Auto(v) => {
16253 struct_ser.serialize_field("auto", v)?;
16254 }
16255 table_parallelism::Parallelism::Custom(v) => {
16256 struct_ser.serialize_field("custom", v)?;
16257 }
16258 table_parallelism::Parallelism::Adaptive(v) => {
16259 struct_ser.serialize_field("adaptive", v)?;
16260 }
16261 }
16262 }
16263 struct_ser.end()
16264 }
16265}
16266impl<'de> serde::Deserialize<'de> for TableParallelism {
16267 #[allow(deprecated)]
16268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16269 where
16270 D: serde::Deserializer<'de>,
16271 {
16272 const FIELDS: &[&str] = &[
16273 "fixed",
16274 "auto",
16275 "custom",
16276 "adaptive",
16277 ];
16278
16279 #[allow(clippy::enum_variant_names)]
16280 enum GeneratedField {
16281 Fixed,
16282 Auto,
16283 Custom,
16284 Adaptive,
16285 }
16286 impl<'de> serde::Deserialize<'de> for GeneratedField {
16287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16288 where
16289 D: serde::Deserializer<'de>,
16290 {
16291 struct GeneratedVisitor;
16292
16293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16294 type Value = GeneratedField;
16295
16296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16297 write!(formatter, "expected one of: {:?}", &FIELDS)
16298 }
16299
16300 #[allow(unused_variables)]
16301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16302 where
16303 E: serde::de::Error,
16304 {
16305 match value {
16306 "fixed" => Ok(GeneratedField::Fixed),
16307 "auto" => Ok(GeneratedField::Auto),
16308 "custom" => Ok(GeneratedField::Custom),
16309 "adaptive" => Ok(GeneratedField::Adaptive),
16310 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16311 }
16312 }
16313 }
16314 deserializer.deserialize_identifier(GeneratedVisitor)
16315 }
16316 }
16317 struct GeneratedVisitor;
16318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16319 type Value = TableParallelism;
16320
16321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16322 formatter.write_str("struct meta.TableParallelism")
16323 }
16324
16325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
16326 where
16327 V: serde::de::MapAccess<'de>,
16328 {
16329 let mut parallelism__ = None;
16330 while let Some(k) = map_.next_key()? {
16331 match k {
16332 GeneratedField::Fixed => {
16333 if parallelism__.is_some() {
16334 return Err(serde::de::Error::duplicate_field("fixed"));
16335 }
16336 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
16337;
16338 }
16339 GeneratedField::Auto => {
16340 if parallelism__.is_some() {
16341 return Err(serde::de::Error::duplicate_field("auto"));
16342 }
16343 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
16344;
16345 }
16346 GeneratedField::Custom => {
16347 if parallelism__.is_some() {
16348 return Err(serde::de::Error::duplicate_field("custom"));
16349 }
16350 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
16351;
16352 }
16353 GeneratedField::Adaptive => {
16354 if parallelism__.is_some() {
16355 return Err(serde::de::Error::duplicate_field("adaptive"));
16356 }
16357 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
16358;
16359 }
16360 }
16361 }
16362 Ok(TableParallelism {
16363 parallelism: parallelism__,
16364 })
16365 }
16366 }
16367 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
16368 }
16369}
16370impl serde::Serialize for table_parallelism::AdaptiveParallelism {
16371 #[allow(deprecated)]
16372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16373 where
16374 S: serde::Serializer,
16375 {
16376 use serde::ser::SerializeStruct;
16377 let len = 0;
16378 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
16379 struct_ser.end()
16380 }
16381}
16382impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
16383 #[allow(deprecated)]
16384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16385 where
16386 D: serde::Deserializer<'de>,
16387 {
16388 const FIELDS: &[&str] = &[
16389 ];
16390
16391 #[allow(clippy::enum_variant_names)]
16392 enum GeneratedField {
16393 }
16394 impl<'de> serde::Deserialize<'de> for GeneratedField {
16395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16396 where
16397 D: serde::Deserializer<'de>,
16398 {
16399 struct GeneratedVisitor;
16400
16401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16402 type Value = GeneratedField;
16403
16404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16405 write!(formatter, "expected one of: {:?}", &FIELDS)
16406 }
16407
16408 #[allow(unused_variables)]
16409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16410 where
16411 E: serde::de::Error,
16412 {
16413 Err(serde::de::Error::unknown_field(value, FIELDS))
16414 }
16415 }
16416 deserializer.deserialize_identifier(GeneratedVisitor)
16417 }
16418 }
16419 struct GeneratedVisitor;
16420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16421 type Value = table_parallelism::AdaptiveParallelism;
16422
16423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16424 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
16425 }
16426
16427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
16428 where
16429 V: serde::de::MapAccess<'de>,
16430 {
16431 while map_.next_key::<GeneratedField>()?.is_some() {
16432 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16433 }
16434 Ok(table_parallelism::AdaptiveParallelism {
16435 })
16436 }
16437 }
16438 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
16439 }
16440}
16441impl serde::Serialize for table_parallelism::AutoParallelism {
16442 #[allow(deprecated)]
16443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16444 where
16445 S: serde::Serializer,
16446 {
16447 use serde::ser::SerializeStruct;
16448 let len = 0;
16449 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
16450 struct_ser.end()
16451 }
16452}
16453impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
16454 #[allow(deprecated)]
16455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16456 where
16457 D: serde::Deserializer<'de>,
16458 {
16459 const FIELDS: &[&str] = &[
16460 ];
16461
16462 #[allow(clippy::enum_variant_names)]
16463 enum GeneratedField {
16464 }
16465 impl<'de> serde::Deserialize<'de> for GeneratedField {
16466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16467 where
16468 D: serde::Deserializer<'de>,
16469 {
16470 struct GeneratedVisitor;
16471
16472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16473 type Value = GeneratedField;
16474
16475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16476 write!(formatter, "expected one of: {:?}", &FIELDS)
16477 }
16478
16479 #[allow(unused_variables)]
16480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16481 where
16482 E: serde::de::Error,
16483 {
16484 Err(serde::de::Error::unknown_field(value, FIELDS))
16485 }
16486 }
16487 deserializer.deserialize_identifier(GeneratedVisitor)
16488 }
16489 }
16490 struct GeneratedVisitor;
16491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16492 type Value = table_parallelism::AutoParallelism;
16493
16494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16495 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
16496 }
16497
16498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
16499 where
16500 V: serde::de::MapAccess<'de>,
16501 {
16502 while map_.next_key::<GeneratedField>()?.is_some() {
16503 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16504 }
16505 Ok(table_parallelism::AutoParallelism {
16506 })
16507 }
16508 }
16509 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
16510 }
16511}
16512impl serde::Serialize for table_parallelism::CustomParallelism {
16513 #[allow(deprecated)]
16514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16515 where
16516 S: serde::Serializer,
16517 {
16518 use serde::ser::SerializeStruct;
16519 let len = 0;
16520 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
16521 struct_ser.end()
16522 }
16523}
16524impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
16525 #[allow(deprecated)]
16526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16527 where
16528 D: serde::Deserializer<'de>,
16529 {
16530 const FIELDS: &[&str] = &[
16531 ];
16532
16533 #[allow(clippy::enum_variant_names)]
16534 enum GeneratedField {
16535 }
16536 impl<'de> serde::Deserialize<'de> for GeneratedField {
16537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16538 where
16539 D: serde::Deserializer<'de>,
16540 {
16541 struct GeneratedVisitor;
16542
16543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16544 type Value = GeneratedField;
16545
16546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16547 write!(formatter, "expected one of: {:?}", &FIELDS)
16548 }
16549
16550 #[allow(unused_variables)]
16551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16552 where
16553 E: serde::de::Error,
16554 {
16555 Err(serde::de::Error::unknown_field(value, FIELDS))
16556 }
16557 }
16558 deserializer.deserialize_identifier(GeneratedVisitor)
16559 }
16560 }
16561 struct GeneratedVisitor;
16562 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16563 type Value = table_parallelism::CustomParallelism;
16564
16565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16566 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16567 }
16568
16569 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16570 where
16571 V: serde::de::MapAccess<'de>,
16572 {
16573 while map_.next_key::<GeneratedField>()?.is_some() {
16574 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16575 }
16576 Ok(table_parallelism::CustomParallelism {
16577 })
16578 }
16579 }
16580 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16581 }
16582}
16583impl serde::Serialize for table_parallelism::FixedParallelism {
16584 #[allow(deprecated)]
16585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16586 where
16587 S: serde::Serializer,
16588 {
16589 use serde::ser::SerializeStruct;
16590 let mut len = 0;
16591 if self.parallelism != 0 {
16592 len += 1;
16593 }
16594 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16595 if self.parallelism != 0 {
16596 struct_ser.serialize_field("parallelism", &self.parallelism)?;
16597 }
16598 struct_ser.end()
16599 }
16600}
16601impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16602 #[allow(deprecated)]
16603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16604 where
16605 D: serde::Deserializer<'de>,
16606 {
16607 const FIELDS: &[&str] = &[
16608 "parallelism",
16609 ];
16610
16611 #[allow(clippy::enum_variant_names)]
16612 enum GeneratedField {
16613 Parallelism,
16614 }
16615 impl<'de> serde::Deserialize<'de> for GeneratedField {
16616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16617 where
16618 D: serde::Deserializer<'de>,
16619 {
16620 struct GeneratedVisitor;
16621
16622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16623 type Value = GeneratedField;
16624
16625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16626 write!(formatter, "expected one of: {:?}", &FIELDS)
16627 }
16628
16629 #[allow(unused_variables)]
16630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16631 where
16632 E: serde::de::Error,
16633 {
16634 match value {
16635 "parallelism" => Ok(GeneratedField::Parallelism),
16636 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16637 }
16638 }
16639 }
16640 deserializer.deserialize_identifier(GeneratedVisitor)
16641 }
16642 }
16643 struct GeneratedVisitor;
16644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16645 type Value = table_parallelism::FixedParallelism;
16646
16647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16648 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16649 }
16650
16651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16652 where
16653 V: serde::de::MapAccess<'de>,
16654 {
16655 let mut parallelism__ = None;
16656 while let Some(k) = map_.next_key()? {
16657 match k {
16658 GeneratedField::Parallelism => {
16659 if parallelism__.is_some() {
16660 return Err(serde::de::Error::duplicate_field("parallelism"));
16661 }
16662 parallelism__ =
16663 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16664 ;
16665 }
16666 }
16667 }
16668 Ok(table_parallelism::FixedParallelism {
16669 parallelism: parallelism__.unwrap_or_default(),
16670 })
16671 }
16672 }
16673 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16674 }
16675}
16676impl serde::Serialize for TelemetryInfoResponse {
16677 #[allow(deprecated)]
16678 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16679 where
16680 S: serde::Serializer,
16681 {
16682 use serde::ser::SerializeStruct;
16683 let mut len = 0;
16684 if self.tracking_id.is_some() {
16685 len += 1;
16686 }
16687 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16688 if let Some(v) = self.tracking_id.as_ref() {
16689 struct_ser.serialize_field("trackingId", v)?;
16690 }
16691 struct_ser.end()
16692 }
16693}
16694impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16695 #[allow(deprecated)]
16696 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16697 where
16698 D: serde::Deserializer<'de>,
16699 {
16700 const FIELDS: &[&str] = &[
16701 "tracking_id",
16702 "trackingId",
16703 ];
16704
16705 #[allow(clippy::enum_variant_names)]
16706 enum GeneratedField {
16707 TrackingId,
16708 }
16709 impl<'de> serde::Deserialize<'de> for GeneratedField {
16710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16711 where
16712 D: serde::Deserializer<'de>,
16713 {
16714 struct GeneratedVisitor;
16715
16716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16717 type Value = GeneratedField;
16718
16719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16720 write!(formatter, "expected one of: {:?}", &FIELDS)
16721 }
16722
16723 #[allow(unused_variables)]
16724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16725 where
16726 E: serde::de::Error,
16727 {
16728 match value {
16729 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16731 }
16732 }
16733 }
16734 deserializer.deserialize_identifier(GeneratedVisitor)
16735 }
16736 }
16737 struct GeneratedVisitor;
16738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16739 type Value = TelemetryInfoResponse;
16740
16741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16742 formatter.write_str("struct meta.TelemetryInfoResponse")
16743 }
16744
16745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16746 where
16747 V: serde::de::MapAccess<'de>,
16748 {
16749 let mut tracking_id__ = None;
16750 while let Some(k) = map_.next_key()? {
16751 match k {
16752 GeneratedField::TrackingId => {
16753 if tracking_id__.is_some() {
16754 return Err(serde::de::Error::duplicate_field("trackingId"));
16755 }
16756 tracking_id__ = map_.next_value()?;
16757 }
16758 }
16759 }
16760 Ok(TelemetryInfoResponse {
16761 tracking_id: tracking_id__,
16762 })
16763 }
16764 }
16765 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16766 }
16767}
16768impl serde::Serialize for ThrottleTarget {
16769 #[allow(deprecated)]
16770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16771 where
16772 S: serde::Serializer,
16773 {
16774 let variant = match self {
16775 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16776 Self::Source => "SOURCE",
16777 Self::Mv => "MV",
16778 Self::TableWithSource => "TABLE_WITH_SOURCE",
16779 Self::CdcTable => "CDC_TABLE",
16780 Self::TableDml => "TABLE_DML",
16781 Self::Sink => "SINK",
16782 Self::Fragment => "FRAGMENT",
16783 };
16784 serializer.serialize_str(variant)
16785 }
16786}
16787impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16788 #[allow(deprecated)]
16789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16790 where
16791 D: serde::Deserializer<'de>,
16792 {
16793 const FIELDS: &[&str] = &[
16794 "THROTTLE_TARGET_UNSPECIFIED",
16795 "SOURCE",
16796 "MV",
16797 "TABLE_WITH_SOURCE",
16798 "CDC_TABLE",
16799 "TABLE_DML",
16800 "SINK",
16801 "FRAGMENT",
16802 ];
16803
16804 struct GeneratedVisitor;
16805
16806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16807 type Value = ThrottleTarget;
16808
16809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16810 write!(formatter, "expected one of: {:?}", &FIELDS)
16811 }
16812
16813 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16814 where
16815 E: serde::de::Error,
16816 {
16817 i32::try_from(v)
16818 .ok()
16819 .and_then(|x| x.try_into().ok())
16820 .ok_or_else(|| {
16821 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16822 })
16823 }
16824
16825 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16826 where
16827 E: serde::de::Error,
16828 {
16829 i32::try_from(v)
16830 .ok()
16831 .and_then(|x| x.try_into().ok())
16832 .ok_or_else(|| {
16833 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16834 })
16835 }
16836
16837 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16838 where
16839 E: serde::de::Error,
16840 {
16841 match value {
16842 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16843 "SOURCE" => Ok(ThrottleTarget::Source),
16844 "MV" => Ok(ThrottleTarget::Mv),
16845 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16846 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16847 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16848 "SINK" => Ok(ThrottleTarget::Sink),
16849 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16850 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16851 }
16852 }
16853 }
16854 deserializer.deserialize_any(GeneratedVisitor)
16855 }
16856}
16857impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16858 #[allow(deprecated)]
16859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16860 where
16861 S: serde::Serializer,
16862 {
16863 use serde::ser::SerializeStruct;
16864 let mut len = 0;
16865 if self.id != 0 {
16866 len += 1;
16867 }
16868 if !self.node_label.is_empty() {
16869 len += 1;
16870 }
16871 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16872 if self.id != 0 {
16873 struct_ser.serialize_field("id", &self.id)?;
16874 }
16875 if !self.node_label.is_empty() {
16876 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16877 }
16878 struct_ser.end()
16879 }
16880}
16881impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16882 #[allow(deprecated)]
16883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16884 where
16885 D: serde::Deserializer<'de>,
16886 {
16887 const FIELDS: &[&str] = &[
16888 "id",
16889 "node_label",
16890 "nodeLabel",
16891 ];
16892
16893 #[allow(clippy::enum_variant_names)]
16894 enum GeneratedField {
16895 Id,
16896 NodeLabel,
16897 }
16898 impl<'de> serde::Deserialize<'de> for GeneratedField {
16899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16900 where
16901 D: serde::Deserializer<'de>,
16902 {
16903 struct GeneratedVisitor;
16904
16905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16906 type Value = GeneratedField;
16907
16908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16909 write!(formatter, "expected one of: {:?}", &FIELDS)
16910 }
16911
16912 #[allow(unused_variables)]
16913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16914 where
16915 E: serde::de::Error,
16916 {
16917 match value {
16918 "id" => Ok(GeneratedField::Id),
16919 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16920 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16921 }
16922 }
16923 }
16924 deserializer.deserialize_identifier(GeneratedVisitor)
16925 }
16926 }
16927 struct GeneratedVisitor;
16928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16929 type Value = UpdateStreamingJobNodeLabelsRequest;
16930
16931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16932 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
16933 }
16934
16935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
16936 where
16937 V: serde::de::MapAccess<'de>,
16938 {
16939 let mut id__ = None;
16940 let mut node_label__ = None;
16941 while let Some(k) = map_.next_key()? {
16942 match k {
16943 GeneratedField::Id => {
16944 if id__.is_some() {
16945 return Err(serde::de::Error::duplicate_field("id"));
16946 }
16947 id__ =
16948 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16949 ;
16950 }
16951 GeneratedField::NodeLabel => {
16952 if node_label__.is_some() {
16953 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16954 }
16955 node_label__ = Some(map_.next_value()?);
16956 }
16957 }
16958 }
16959 Ok(UpdateStreamingJobNodeLabelsRequest {
16960 id: id__.unwrap_or_default(),
16961 node_label: node_label__.unwrap_or_default(),
16962 })
16963 }
16964 }
16965 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
16966 }
16967}
16968impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
16969 #[allow(deprecated)]
16970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16971 where
16972 S: serde::Serializer,
16973 {
16974 use serde::ser::SerializeStruct;
16975 let len = 0;
16976 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
16977 struct_ser.end()
16978 }
16979}
16980impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
16981 #[allow(deprecated)]
16982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16983 where
16984 D: serde::Deserializer<'de>,
16985 {
16986 const FIELDS: &[&str] = &[
16987 ];
16988
16989 #[allow(clippy::enum_variant_names)]
16990 enum GeneratedField {
16991 }
16992 impl<'de> serde::Deserialize<'de> for GeneratedField {
16993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16994 where
16995 D: serde::Deserializer<'de>,
16996 {
16997 struct GeneratedVisitor;
16998
16999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17000 type Value = GeneratedField;
17001
17002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17003 write!(formatter, "expected one of: {:?}", &FIELDS)
17004 }
17005
17006 #[allow(unused_variables)]
17007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17008 where
17009 E: serde::de::Error,
17010 {
17011 Err(serde::de::Error::unknown_field(value, FIELDS))
17012 }
17013 }
17014 deserializer.deserialize_identifier(GeneratedVisitor)
17015 }
17016 }
17017 struct GeneratedVisitor;
17018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17019 type Value = UpdateStreamingJobNodeLabelsResponse;
17020
17021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17022 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
17023 }
17024
17025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
17026 where
17027 V: serde::de::MapAccess<'de>,
17028 {
17029 while map_.next_key::<GeneratedField>()?.is_some() {
17030 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17031 }
17032 Ok(UpdateStreamingJobNodeLabelsResponse {
17033 })
17034 }
17035 }
17036 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
17037 }
17038}
17039impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
17040 #[allow(deprecated)]
17041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17042 where
17043 S: serde::Serializer,
17044 {
17045 use serde::ser::SerializeStruct;
17046 let mut len = 0;
17047 if !self.worker_ids.is_empty() {
17048 len += 1;
17049 }
17050 if self.schedulability != 0 {
17051 len += 1;
17052 }
17053 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
17054 if !self.worker_ids.is_empty() {
17055 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
17056 }
17057 if self.schedulability != 0 {
17058 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
17059 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
17060 struct_ser.serialize_field("schedulability", &v)?;
17061 }
17062 struct_ser.end()
17063 }
17064}
17065impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
17066 #[allow(deprecated)]
17067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17068 where
17069 D: serde::Deserializer<'de>,
17070 {
17071 const FIELDS: &[&str] = &[
17072 "worker_ids",
17073 "workerIds",
17074 "schedulability",
17075 ];
17076
17077 #[allow(clippy::enum_variant_names)]
17078 enum GeneratedField {
17079 WorkerIds,
17080 Schedulability,
17081 }
17082 impl<'de> serde::Deserialize<'de> for GeneratedField {
17083 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17084 where
17085 D: serde::Deserializer<'de>,
17086 {
17087 struct GeneratedVisitor;
17088
17089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17090 type Value = GeneratedField;
17091
17092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17093 write!(formatter, "expected one of: {:?}", &FIELDS)
17094 }
17095
17096 #[allow(unused_variables)]
17097 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17098 where
17099 E: serde::de::Error,
17100 {
17101 match value {
17102 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
17103 "schedulability" => Ok(GeneratedField::Schedulability),
17104 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17105 }
17106 }
17107 }
17108 deserializer.deserialize_identifier(GeneratedVisitor)
17109 }
17110 }
17111 struct GeneratedVisitor;
17112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17113 type Value = UpdateWorkerNodeSchedulabilityRequest;
17114
17115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17116 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
17117 }
17118
17119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
17120 where
17121 V: serde::de::MapAccess<'de>,
17122 {
17123 let mut worker_ids__ = None;
17124 let mut schedulability__ = None;
17125 while let Some(k) = map_.next_key()? {
17126 match k {
17127 GeneratedField::WorkerIds => {
17128 if worker_ids__.is_some() {
17129 return Err(serde::de::Error::duplicate_field("workerIds"));
17130 }
17131 worker_ids__ =
17132 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17133 .into_iter().map(|x| x.0).collect())
17134 ;
17135 }
17136 GeneratedField::Schedulability => {
17137 if schedulability__.is_some() {
17138 return Err(serde::de::Error::duplicate_field("schedulability"));
17139 }
17140 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
17141 }
17142 }
17143 }
17144 Ok(UpdateWorkerNodeSchedulabilityRequest {
17145 worker_ids: worker_ids__.unwrap_or_default(),
17146 schedulability: schedulability__.unwrap_or_default(),
17147 })
17148 }
17149 }
17150 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
17151 }
17152}
17153impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
17154 #[allow(deprecated)]
17155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17156 where
17157 S: serde::Serializer,
17158 {
17159 let variant = match self {
17160 Self::Unspecified => "UNSPECIFIED",
17161 Self::Schedulable => "SCHEDULABLE",
17162 Self::Unschedulable => "UNSCHEDULABLE",
17163 };
17164 serializer.serialize_str(variant)
17165 }
17166}
17167impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
17168 #[allow(deprecated)]
17169 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17170 where
17171 D: serde::Deserializer<'de>,
17172 {
17173 const FIELDS: &[&str] = &[
17174 "UNSPECIFIED",
17175 "SCHEDULABLE",
17176 "UNSCHEDULABLE",
17177 ];
17178
17179 struct GeneratedVisitor;
17180
17181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17182 type Value = update_worker_node_schedulability_request::Schedulability;
17183
17184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17185 write!(formatter, "expected one of: {:?}", &FIELDS)
17186 }
17187
17188 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17189 where
17190 E: serde::de::Error,
17191 {
17192 i32::try_from(v)
17193 .ok()
17194 .and_then(|x| x.try_into().ok())
17195 .ok_or_else(|| {
17196 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17197 })
17198 }
17199
17200 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17201 where
17202 E: serde::de::Error,
17203 {
17204 i32::try_from(v)
17205 .ok()
17206 .and_then(|x| x.try_into().ok())
17207 .ok_or_else(|| {
17208 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17209 })
17210 }
17211
17212 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17213 where
17214 E: serde::de::Error,
17215 {
17216 match value {
17217 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
17218 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
17219 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
17220 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17221 }
17222 }
17223 }
17224 deserializer.deserialize_any(GeneratedVisitor)
17225 }
17226}
17227impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
17228 #[allow(deprecated)]
17229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17230 where
17231 S: serde::Serializer,
17232 {
17233 use serde::ser::SerializeStruct;
17234 let mut len = 0;
17235 if self.status.is_some() {
17236 len += 1;
17237 }
17238 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
17239 if let Some(v) = self.status.as_ref() {
17240 struct_ser.serialize_field("status", v)?;
17241 }
17242 struct_ser.end()
17243 }
17244}
17245impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
17246 #[allow(deprecated)]
17247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17248 where
17249 D: serde::Deserializer<'de>,
17250 {
17251 const FIELDS: &[&str] = &[
17252 "status",
17253 ];
17254
17255 #[allow(clippy::enum_variant_names)]
17256 enum GeneratedField {
17257 Status,
17258 }
17259 impl<'de> serde::Deserialize<'de> for GeneratedField {
17260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17261 where
17262 D: serde::Deserializer<'de>,
17263 {
17264 struct GeneratedVisitor;
17265
17266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17267 type Value = GeneratedField;
17268
17269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17270 write!(formatter, "expected one of: {:?}", &FIELDS)
17271 }
17272
17273 #[allow(unused_variables)]
17274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17275 where
17276 E: serde::de::Error,
17277 {
17278 match value {
17279 "status" => Ok(GeneratedField::Status),
17280 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17281 }
17282 }
17283 }
17284 deserializer.deserialize_identifier(GeneratedVisitor)
17285 }
17286 }
17287 struct GeneratedVisitor;
17288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17289 type Value = UpdateWorkerNodeSchedulabilityResponse;
17290
17291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17292 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
17293 }
17294
17295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
17296 where
17297 V: serde::de::MapAccess<'de>,
17298 {
17299 let mut status__ = None;
17300 while let Some(k) = map_.next_key()? {
17301 match k {
17302 GeneratedField::Status => {
17303 if status__.is_some() {
17304 return Err(serde::de::Error::duplicate_field("status"));
17305 }
17306 status__ = map_.next_value()?;
17307 }
17308 }
17309 }
17310 Ok(UpdateWorkerNodeSchedulabilityResponse {
17311 status: status__,
17312 })
17313 }
17314 }
17315 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
17316 }
17317}
17318impl serde::Serialize for WorkerReschedule {
17319 #[allow(deprecated)]
17320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17321 where
17322 S: serde::Serializer,
17323 {
17324 use serde::ser::SerializeStruct;
17325 let mut len = 0;
17326 if !self.worker_actor_diff.is_empty() {
17327 len += 1;
17328 }
17329 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
17330 if !self.worker_actor_diff.is_empty() {
17331 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
17332 }
17333 struct_ser.end()
17334 }
17335}
17336impl<'de> serde::Deserialize<'de> for WorkerReschedule {
17337 #[allow(deprecated)]
17338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17339 where
17340 D: serde::Deserializer<'de>,
17341 {
17342 const FIELDS: &[&str] = &[
17343 "worker_actor_diff",
17344 "workerActorDiff",
17345 ];
17346
17347 #[allow(clippy::enum_variant_names)]
17348 enum GeneratedField {
17349 WorkerActorDiff,
17350 }
17351 impl<'de> serde::Deserialize<'de> for GeneratedField {
17352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17353 where
17354 D: serde::Deserializer<'de>,
17355 {
17356 struct GeneratedVisitor;
17357
17358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17359 type Value = GeneratedField;
17360
17361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17362 write!(formatter, "expected one of: {:?}", &FIELDS)
17363 }
17364
17365 #[allow(unused_variables)]
17366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17367 where
17368 E: serde::de::Error,
17369 {
17370 match value {
17371 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
17372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17373 }
17374 }
17375 }
17376 deserializer.deserialize_identifier(GeneratedVisitor)
17377 }
17378 }
17379 struct GeneratedVisitor;
17380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17381 type Value = WorkerReschedule;
17382
17383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17384 formatter.write_str("struct meta.WorkerReschedule")
17385 }
17386
17387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
17388 where
17389 V: serde::de::MapAccess<'de>,
17390 {
17391 let mut worker_actor_diff__ = None;
17392 while let Some(k) = map_.next_key()? {
17393 match k {
17394 GeneratedField::WorkerActorDiff => {
17395 if worker_actor_diff__.is_some() {
17396 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
17397 }
17398 worker_actor_diff__ = Some(
17399 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
17400 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17401 );
17402 }
17403 }
17404 }
17405 Ok(WorkerReschedule {
17406 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
17407 })
17408 }
17409 }
17410 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
17411 }
17412}