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 let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1139 if self.object_id != 0 {
1140 struct_ser.serialize_field("objectId", &self.object_id)?;
1141 }
1142 if !self.changed_props.is_empty() {
1143 struct_ser.serialize_field("changedProps", &self.changed_props)?;
1144 }
1145 if !self.changed_secret_refs.is_empty() {
1146 struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1147 }
1148 if let Some(v) = self.connector_conn_ref.as_ref() {
1149 struct_ser.serialize_field("connectorConnRef", v)?;
1150 }
1151 if self.object_type != 0 {
1152 let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1153 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1154 struct_ser.serialize_field("objectType", &v)?;
1155 }
1156 struct_ser.end()
1157 }
1158}
1159impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1160 #[allow(deprecated)]
1161 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1162 where
1163 D: serde::Deserializer<'de>,
1164 {
1165 const FIELDS: &[&str] = &[
1166 "object_id",
1167 "objectId",
1168 "changed_props",
1169 "changedProps",
1170 "changed_secret_refs",
1171 "changedSecretRefs",
1172 "connector_conn_ref",
1173 "connectorConnRef",
1174 "object_type",
1175 "objectType",
1176 ];
1177
1178 #[allow(clippy::enum_variant_names)]
1179 enum GeneratedField {
1180 ObjectId,
1181 ChangedProps,
1182 ChangedSecretRefs,
1183 ConnectorConnRef,
1184 ObjectType,
1185 }
1186 impl<'de> serde::Deserialize<'de> for GeneratedField {
1187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1188 where
1189 D: serde::Deserializer<'de>,
1190 {
1191 struct GeneratedVisitor;
1192
1193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1194 type Value = GeneratedField;
1195
1196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1197 write!(formatter, "expected one of: {:?}", &FIELDS)
1198 }
1199
1200 #[allow(unused_variables)]
1201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1202 where
1203 E: serde::de::Error,
1204 {
1205 match value {
1206 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1207 "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1208 "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1209 "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1210 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1211 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1212 }
1213 }
1214 }
1215 deserializer.deserialize_identifier(GeneratedVisitor)
1216 }
1217 }
1218 struct GeneratedVisitor;
1219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1220 type Value = AlterConnectorPropsRequest;
1221
1222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1223 formatter.write_str("struct meta.AlterConnectorPropsRequest")
1224 }
1225
1226 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1227 where
1228 V: serde::de::MapAccess<'de>,
1229 {
1230 let mut object_id__ = None;
1231 let mut changed_props__ = None;
1232 let mut changed_secret_refs__ = None;
1233 let mut connector_conn_ref__ = None;
1234 let mut object_type__ = None;
1235 while let Some(k) = map_.next_key()? {
1236 match k {
1237 GeneratedField::ObjectId => {
1238 if object_id__.is_some() {
1239 return Err(serde::de::Error::duplicate_field("objectId"));
1240 }
1241 object_id__ =
1242 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1243 ;
1244 }
1245 GeneratedField::ChangedProps => {
1246 if changed_props__.is_some() {
1247 return Err(serde::de::Error::duplicate_field("changedProps"));
1248 }
1249 changed_props__ = Some(
1250 map_.next_value::<std::collections::HashMap<_, _>>()?
1251 );
1252 }
1253 GeneratedField::ChangedSecretRefs => {
1254 if changed_secret_refs__.is_some() {
1255 return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1256 }
1257 changed_secret_refs__ = Some(
1258 map_.next_value::<std::collections::HashMap<_, _>>()?
1259 );
1260 }
1261 GeneratedField::ConnectorConnRef => {
1262 if connector_conn_ref__.is_some() {
1263 return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1264 }
1265 connector_conn_ref__ =
1266 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1267 ;
1268 }
1269 GeneratedField::ObjectType => {
1270 if object_type__.is_some() {
1271 return Err(serde::de::Error::duplicate_field("objectType"));
1272 }
1273 object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1274 }
1275 }
1276 }
1277 Ok(AlterConnectorPropsRequest {
1278 object_id: object_id__.unwrap_or_default(),
1279 changed_props: changed_props__.unwrap_or_default(),
1280 changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1281 connector_conn_ref: connector_conn_ref__,
1282 object_type: object_type__.unwrap_or_default(),
1283 })
1284 }
1285 }
1286 deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1287 }
1288}
1289impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1290 #[allow(deprecated)]
1291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1292 where
1293 S: serde::Serializer,
1294 {
1295 let variant = match self {
1296 Self::Unspecified => "UNSPECIFIED",
1297 Self::Source => "SOURCE",
1298 Self::Sink => "SINK",
1299 Self::Connection => "CONNECTION",
1300 };
1301 serializer.serialize_str(variant)
1302 }
1303}
1304impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1305 #[allow(deprecated)]
1306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1307 where
1308 D: serde::Deserializer<'de>,
1309 {
1310 const FIELDS: &[&str] = &[
1311 "UNSPECIFIED",
1312 "SOURCE",
1313 "SINK",
1314 "CONNECTION",
1315 ];
1316
1317 struct GeneratedVisitor;
1318
1319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1320 type Value = alter_connector_props_request::AlterConnectorPropsObject;
1321
1322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1323 write!(formatter, "expected one of: {:?}", &FIELDS)
1324 }
1325
1326 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1327 where
1328 E: serde::de::Error,
1329 {
1330 i32::try_from(v)
1331 .ok()
1332 .and_then(|x| x.try_into().ok())
1333 .ok_or_else(|| {
1334 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1335 })
1336 }
1337
1338 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1339 where
1340 E: serde::de::Error,
1341 {
1342 i32::try_from(v)
1343 .ok()
1344 .and_then(|x| x.try_into().ok())
1345 .ok_or_else(|| {
1346 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1347 })
1348 }
1349
1350 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1351 where
1352 E: serde::de::Error,
1353 {
1354 match value {
1355 "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1356 "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1357 "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1358 "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1359 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1360 }
1361 }
1362 }
1363 deserializer.deserialize_any(GeneratedVisitor)
1364 }
1365}
1366impl serde::Serialize for AlterConnectorPropsResponse {
1367 #[allow(deprecated)]
1368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1369 where
1370 S: serde::Serializer,
1371 {
1372 use serde::ser::SerializeStruct;
1373 let len = 0;
1374 let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1375 struct_ser.end()
1376 }
1377}
1378impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1379 #[allow(deprecated)]
1380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1381 where
1382 D: serde::Deserializer<'de>,
1383 {
1384 const FIELDS: &[&str] = &[
1385 ];
1386
1387 #[allow(clippy::enum_variant_names)]
1388 enum GeneratedField {
1389 }
1390 impl<'de> serde::Deserialize<'de> for GeneratedField {
1391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1392 where
1393 D: serde::Deserializer<'de>,
1394 {
1395 struct GeneratedVisitor;
1396
1397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1398 type Value = GeneratedField;
1399
1400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1401 write!(formatter, "expected one of: {:?}", &FIELDS)
1402 }
1403
1404 #[allow(unused_variables)]
1405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1406 where
1407 E: serde::de::Error,
1408 {
1409 Err(serde::de::Error::unknown_field(value, FIELDS))
1410 }
1411 }
1412 deserializer.deserialize_identifier(GeneratedVisitor)
1413 }
1414 }
1415 struct GeneratedVisitor;
1416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1417 type Value = AlterConnectorPropsResponse;
1418
1419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1420 formatter.write_str("struct meta.AlterConnectorPropsResponse")
1421 }
1422
1423 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1424 where
1425 V: serde::de::MapAccess<'de>,
1426 {
1427 while map_.next_key::<GeneratedField>()?.is_some() {
1428 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1429 }
1430 Ok(AlterConnectorPropsResponse {
1431 })
1432 }
1433 }
1434 deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1435 }
1436}
1437impl serde::Serialize for ApplyThrottleRequest {
1438 #[allow(deprecated)]
1439 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1440 where
1441 S: serde::Serializer,
1442 {
1443 use serde::ser::SerializeStruct;
1444 let mut len = 0;
1445 if self.kind != 0 {
1446 len += 1;
1447 }
1448 if self.id != 0 {
1449 len += 1;
1450 }
1451 if self.rate.is_some() {
1452 len += 1;
1453 }
1454 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1455 if self.kind != 0 {
1456 let v = ThrottleTarget::try_from(self.kind)
1457 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1458 struct_ser.serialize_field("kind", &v)?;
1459 }
1460 if self.id != 0 {
1461 struct_ser.serialize_field("id", &self.id)?;
1462 }
1463 if let Some(v) = self.rate.as_ref() {
1464 struct_ser.serialize_field("rate", v)?;
1465 }
1466 struct_ser.end()
1467 }
1468}
1469impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1470 #[allow(deprecated)]
1471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1472 where
1473 D: serde::Deserializer<'de>,
1474 {
1475 const FIELDS: &[&str] = &[
1476 "kind",
1477 "id",
1478 "rate",
1479 ];
1480
1481 #[allow(clippy::enum_variant_names)]
1482 enum GeneratedField {
1483 Kind,
1484 Id,
1485 Rate,
1486 }
1487 impl<'de> serde::Deserialize<'de> for GeneratedField {
1488 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1489 where
1490 D: serde::Deserializer<'de>,
1491 {
1492 struct GeneratedVisitor;
1493
1494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1495 type Value = GeneratedField;
1496
1497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1498 write!(formatter, "expected one of: {:?}", &FIELDS)
1499 }
1500
1501 #[allow(unused_variables)]
1502 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1503 where
1504 E: serde::de::Error,
1505 {
1506 match value {
1507 "kind" => Ok(GeneratedField::Kind),
1508 "id" => Ok(GeneratedField::Id),
1509 "rate" => Ok(GeneratedField::Rate),
1510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1511 }
1512 }
1513 }
1514 deserializer.deserialize_identifier(GeneratedVisitor)
1515 }
1516 }
1517 struct GeneratedVisitor;
1518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1519 type Value = ApplyThrottleRequest;
1520
1521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1522 formatter.write_str("struct meta.ApplyThrottleRequest")
1523 }
1524
1525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1526 where
1527 V: serde::de::MapAccess<'de>,
1528 {
1529 let mut kind__ = None;
1530 let mut id__ = None;
1531 let mut rate__ = None;
1532 while let Some(k) = map_.next_key()? {
1533 match k {
1534 GeneratedField::Kind => {
1535 if kind__.is_some() {
1536 return Err(serde::de::Error::duplicate_field("kind"));
1537 }
1538 kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1539 }
1540 GeneratedField::Id => {
1541 if id__.is_some() {
1542 return Err(serde::de::Error::duplicate_field("id"));
1543 }
1544 id__ =
1545 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1546 ;
1547 }
1548 GeneratedField::Rate => {
1549 if rate__.is_some() {
1550 return Err(serde::de::Error::duplicate_field("rate"));
1551 }
1552 rate__ =
1553 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1554 ;
1555 }
1556 }
1557 }
1558 Ok(ApplyThrottleRequest {
1559 kind: kind__.unwrap_or_default(),
1560 id: id__.unwrap_or_default(),
1561 rate: rate__,
1562 })
1563 }
1564 }
1565 deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1566 }
1567}
1568impl serde::Serialize for ApplyThrottleResponse {
1569 #[allow(deprecated)]
1570 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1571 where
1572 S: serde::Serializer,
1573 {
1574 use serde::ser::SerializeStruct;
1575 let mut len = 0;
1576 if self.status.is_some() {
1577 len += 1;
1578 }
1579 let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1580 if let Some(v) = self.status.as_ref() {
1581 struct_ser.serialize_field("status", v)?;
1582 }
1583 struct_ser.end()
1584 }
1585}
1586impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1587 #[allow(deprecated)]
1588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1589 where
1590 D: serde::Deserializer<'de>,
1591 {
1592 const FIELDS: &[&str] = &[
1593 "status",
1594 ];
1595
1596 #[allow(clippy::enum_variant_names)]
1597 enum GeneratedField {
1598 Status,
1599 }
1600 impl<'de> serde::Deserialize<'de> for GeneratedField {
1601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1602 where
1603 D: serde::Deserializer<'de>,
1604 {
1605 struct GeneratedVisitor;
1606
1607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1608 type Value = GeneratedField;
1609
1610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1611 write!(formatter, "expected one of: {:?}", &FIELDS)
1612 }
1613
1614 #[allow(unused_variables)]
1615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1616 where
1617 E: serde::de::Error,
1618 {
1619 match value {
1620 "status" => Ok(GeneratedField::Status),
1621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1622 }
1623 }
1624 }
1625 deserializer.deserialize_identifier(GeneratedVisitor)
1626 }
1627 }
1628 struct GeneratedVisitor;
1629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1630 type Value = ApplyThrottleResponse;
1631
1632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1633 formatter.write_str("struct meta.ApplyThrottleResponse")
1634 }
1635
1636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1637 where
1638 V: serde::de::MapAccess<'de>,
1639 {
1640 let mut status__ = None;
1641 while let Some(k) = map_.next_key()? {
1642 match k {
1643 GeneratedField::Status => {
1644 if status__.is_some() {
1645 return Err(serde::de::Error::duplicate_field("status"));
1646 }
1647 status__ = map_.next_value()?;
1648 }
1649 }
1650 }
1651 Ok(ApplyThrottleResponse {
1652 status: status__,
1653 })
1654 }
1655 }
1656 deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1657 }
1658}
1659impl serde::Serialize for CancelCreatingJobsRequest {
1660 #[allow(deprecated)]
1661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1662 where
1663 S: serde::Serializer,
1664 {
1665 use serde::ser::SerializeStruct;
1666 let mut len = 0;
1667 if self.jobs.is_some() {
1668 len += 1;
1669 }
1670 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1671 if let Some(v) = self.jobs.as_ref() {
1672 match v {
1673 cancel_creating_jobs_request::Jobs::Infos(v) => {
1674 struct_ser.serialize_field("infos", v)?;
1675 }
1676 cancel_creating_jobs_request::Jobs::Ids(v) => {
1677 struct_ser.serialize_field("ids", v)?;
1678 }
1679 }
1680 }
1681 struct_ser.end()
1682 }
1683}
1684impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1685 #[allow(deprecated)]
1686 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1687 where
1688 D: serde::Deserializer<'de>,
1689 {
1690 const FIELDS: &[&str] = &[
1691 "infos",
1692 "ids",
1693 ];
1694
1695 #[allow(clippy::enum_variant_names)]
1696 enum GeneratedField {
1697 Infos,
1698 Ids,
1699 }
1700 impl<'de> serde::Deserialize<'de> for GeneratedField {
1701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1702 where
1703 D: serde::Deserializer<'de>,
1704 {
1705 struct GeneratedVisitor;
1706
1707 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1708 type Value = GeneratedField;
1709
1710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1711 write!(formatter, "expected one of: {:?}", &FIELDS)
1712 }
1713
1714 #[allow(unused_variables)]
1715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1716 where
1717 E: serde::de::Error,
1718 {
1719 match value {
1720 "infos" => Ok(GeneratedField::Infos),
1721 "ids" => Ok(GeneratedField::Ids),
1722 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1723 }
1724 }
1725 }
1726 deserializer.deserialize_identifier(GeneratedVisitor)
1727 }
1728 }
1729 struct GeneratedVisitor;
1730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1731 type Value = CancelCreatingJobsRequest;
1732
1733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1734 formatter.write_str("struct meta.CancelCreatingJobsRequest")
1735 }
1736
1737 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1738 where
1739 V: serde::de::MapAccess<'de>,
1740 {
1741 let mut jobs__ = None;
1742 while let Some(k) = map_.next_key()? {
1743 match k {
1744 GeneratedField::Infos => {
1745 if jobs__.is_some() {
1746 return Err(serde::de::Error::duplicate_field("infos"));
1747 }
1748 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1749;
1750 }
1751 GeneratedField::Ids => {
1752 if jobs__.is_some() {
1753 return Err(serde::de::Error::duplicate_field("ids"));
1754 }
1755 jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1756;
1757 }
1758 }
1759 }
1760 Ok(CancelCreatingJobsRequest {
1761 jobs: jobs__,
1762 })
1763 }
1764 }
1765 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1766 }
1767}
1768impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1769 #[allow(deprecated)]
1770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1771 where
1772 S: serde::Serializer,
1773 {
1774 use serde::ser::SerializeStruct;
1775 let mut len = 0;
1776 if !self.job_ids.is_empty() {
1777 len += 1;
1778 }
1779 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1780 if !self.job_ids.is_empty() {
1781 struct_ser.serialize_field("jobIds", &self.job_ids)?;
1782 }
1783 struct_ser.end()
1784 }
1785}
1786impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1787 #[allow(deprecated)]
1788 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1789 where
1790 D: serde::Deserializer<'de>,
1791 {
1792 const FIELDS: &[&str] = &[
1793 "job_ids",
1794 "jobIds",
1795 ];
1796
1797 #[allow(clippy::enum_variant_names)]
1798 enum GeneratedField {
1799 JobIds,
1800 }
1801 impl<'de> serde::Deserialize<'de> for GeneratedField {
1802 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1803 where
1804 D: serde::Deserializer<'de>,
1805 {
1806 struct GeneratedVisitor;
1807
1808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1809 type Value = GeneratedField;
1810
1811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1812 write!(formatter, "expected one of: {:?}", &FIELDS)
1813 }
1814
1815 #[allow(unused_variables)]
1816 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1817 where
1818 E: serde::de::Error,
1819 {
1820 match value {
1821 "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1823 }
1824 }
1825 }
1826 deserializer.deserialize_identifier(GeneratedVisitor)
1827 }
1828 }
1829 struct GeneratedVisitor;
1830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1831 type Value = cancel_creating_jobs_request::CreatingJobIds;
1832
1833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1834 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1835 }
1836
1837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1838 where
1839 V: serde::de::MapAccess<'de>,
1840 {
1841 let mut job_ids__ = None;
1842 while let Some(k) = map_.next_key()? {
1843 match k {
1844 GeneratedField::JobIds => {
1845 if job_ids__.is_some() {
1846 return Err(serde::de::Error::duplicate_field("jobIds"));
1847 }
1848 job_ids__ =
1849 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1850 .into_iter().map(|x| x.0).collect())
1851 ;
1852 }
1853 }
1854 }
1855 Ok(cancel_creating_jobs_request::CreatingJobIds {
1856 job_ids: job_ids__.unwrap_or_default(),
1857 })
1858 }
1859 }
1860 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
1861 }
1862}
1863impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
1864 #[allow(deprecated)]
1865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1866 where
1867 S: serde::Serializer,
1868 {
1869 use serde::ser::SerializeStruct;
1870 let mut len = 0;
1871 if self.database_id != 0 {
1872 len += 1;
1873 }
1874 if self.schema_id != 0 {
1875 len += 1;
1876 }
1877 if !self.name.is_empty() {
1878 len += 1;
1879 }
1880 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
1881 if self.database_id != 0 {
1882 struct_ser.serialize_field("databaseId", &self.database_id)?;
1883 }
1884 if self.schema_id != 0 {
1885 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1886 }
1887 if !self.name.is_empty() {
1888 struct_ser.serialize_field("name", &self.name)?;
1889 }
1890 struct_ser.end()
1891 }
1892}
1893impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
1894 #[allow(deprecated)]
1895 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1896 where
1897 D: serde::Deserializer<'de>,
1898 {
1899 const FIELDS: &[&str] = &[
1900 "database_id",
1901 "databaseId",
1902 "schema_id",
1903 "schemaId",
1904 "name",
1905 ];
1906
1907 #[allow(clippy::enum_variant_names)]
1908 enum GeneratedField {
1909 DatabaseId,
1910 SchemaId,
1911 Name,
1912 }
1913 impl<'de> serde::Deserialize<'de> for GeneratedField {
1914 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1915 where
1916 D: serde::Deserializer<'de>,
1917 {
1918 struct GeneratedVisitor;
1919
1920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1921 type Value = GeneratedField;
1922
1923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1924 write!(formatter, "expected one of: {:?}", &FIELDS)
1925 }
1926
1927 #[allow(unused_variables)]
1928 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1929 where
1930 E: serde::de::Error,
1931 {
1932 match value {
1933 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1934 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1935 "name" => Ok(GeneratedField::Name),
1936 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1937 }
1938 }
1939 }
1940 deserializer.deserialize_identifier(GeneratedVisitor)
1941 }
1942 }
1943 struct GeneratedVisitor;
1944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1945 type Value = cancel_creating_jobs_request::CreatingJobInfo;
1946
1947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1948 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
1949 }
1950
1951 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
1952 where
1953 V: serde::de::MapAccess<'de>,
1954 {
1955 let mut database_id__ = None;
1956 let mut schema_id__ = None;
1957 let mut name__ = None;
1958 while let Some(k) = map_.next_key()? {
1959 match k {
1960 GeneratedField::DatabaseId => {
1961 if database_id__.is_some() {
1962 return Err(serde::de::Error::duplicate_field("databaseId"));
1963 }
1964 database_id__ =
1965 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1966 ;
1967 }
1968 GeneratedField::SchemaId => {
1969 if schema_id__.is_some() {
1970 return Err(serde::de::Error::duplicate_field("schemaId"));
1971 }
1972 schema_id__ =
1973 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1974 ;
1975 }
1976 GeneratedField::Name => {
1977 if name__.is_some() {
1978 return Err(serde::de::Error::duplicate_field("name"));
1979 }
1980 name__ = Some(map_.next_value()?);
1981 }
1982 }
1983 }
1984 Ok(cancel_creating_jobs_request::CreatingJobInfo {
1985 database_id: database_id__.unwrap_or_default(),
1986 schema_id: schema_id__.unwrap_or_default(),
1987 name: name__.unwrap_or_default(),
1988 })
1989 }
1990 }
1991 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
1992 }
1993}
1994impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
1995 #[allow(deprecated)]
1996 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1997 where
1998 S: serde::Serializer,
1999 {
2000 use serde::ser::SerializeStruct;
2001 let mut len = 0;
2002 if !self.infos.is_empty() {
2003 len += 1;
2004 }
2005 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2006 if !self.infos.is_empty() {
2007 struct_ser.serialize_field("infos", &self.infos)?;
2008 }
2009 struct_ser.end()
2010 }
2011}
2012impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2013 #[allow(deprecated)]
2014 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2015 where
2016 D: serde::Deserializer<'de>,
2017 {
2018 const FIELDS: &[&str] = &[
2019 "infos",
2020 ];
2021
2022 #[allow(clippy::enum_variant_names)]
2023 enum GeneratedField {
2024 Infos,
2025 }
2026 impl<'de> serde::Deserialize<'de> for GeneratedField {
2027 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2028 where
2029 D: serde::Deserializer<'de>,
2030 {
2031 struct GeneratedVisitor;
2032
2033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2034 type Value = GeneratedField;
2035
2036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2037 write!(formatter, "expected one of: {:?}", &FIELDS)
2038 }
2039
2040 #[allow(unused_variables)]
2041 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2042 where
2043 E: serde::de::Error,
2044 {
2045 match value {
2046 "infos" => Ok(GeneratedField::Infos),
2047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2048 }
2049 }
2050 }
2051 deserializer.deserialize_identifier(GeneratedVisitor)
2052 }
2053 }
2054 struct GeneratedVisitor;
2055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2056 type Value = cancel_creating_jobs_request::CreatingJobInfos;
2057
2058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2059 formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2060 }
2061
2062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2063 where
2064 V: serde::de::MapAccess<'de>,
2065 {
2066 let mut infos__ = None;
2067 while let Some(k) = map_.next_key()? {
2068 match k {
2069 GeneratedField::Infos => {
2070 if infos__.is_some() {
2071 return Err(serde::de::Error::duplicate_field("infos"));
2072 }
2073 infos__ = Some(map_.next_value()?);
2074 }
2075 }
2076 }
2077 Ok(cancel_creating_jobs_request::CreatingJobInfos {
2078 infos: infos__.unwrap_or_default(),
2079 })
2080 }
2081 }
2082 deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2083 }
2084}
2085impl serde::Serialize for CancelCreatingJobsResponse {
2086 #[allow(deprecated)]
2087 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2088 where
2089 S: serde::Serializer,
2090 {
2091 use serde::ser::SerializeStruct;
2092 let mut len = 0;
2093 if self.status.is_some() {
2094 len += 1;
2095 }
2096 if !self.canceled_jobs.is_empty() {
2097 len += 1;
2098 }
2099 let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2100 if let Some(v) = self.status.as_ref() {
2101 struct_ser.serialize_field("status", v)?;
2102 }
2103 if !self.canceled_jobs.is_empty() {
2104 struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2105 }
2106 struct_ser.end()
2107 }
2108}
2109impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2110 #[allow(deprecated)]
2111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2112 where
2113 D: serde::Deserializer<'de>,
2114 {
2115 const FIELDS: &[&str] = &[
2116 "status",
2117 "canceled_jobs",
2118 "canceledJobs",
2119 ];
2120
2121 #[allow(clippy::enum_variant_names)]
2122 enum GeneratedField {
2123 Status,
2124 CanceledJobs,
2125 }
2126 impl<'de> serde::Deserialize<'de> for GeneratedField {
2127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2128 where
2129 D: serde::Deserializer<'de>,
2130 {
2131 struct GeneratedVisitor;
2132
2133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2134 type Value = GeneratedField;
2135
2136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2137 write!(formatter, "expected one of: {:?}", &FIELDS)
2138 }
2139
2140 #[allow(unused_variables)]
2141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2142 where
2143 E: serde::de::Error,
2144 {
2145 match value {
2146 "status" => Ok(GeneratedField::Status),
2147 "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2148 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2149 }
2150 }
2151 }
2152 deserializer.deserialize_identifier(GeneratedVisitor)
2153 }
2154 }
2155 struct GeneratedVisitor;
2156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2157 type Value = CancelCreatingJobsResponse;
2158
2159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2160 formatter.write_str("struct meta.CancelCreatingJobsResponse")
2161 }
2162
2163 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2164 where
2165 V: serde::de::MapAccess<'de>,
2166 {
2167 let mut status__ = None;
2168 let mut canceled_jobs__ = None;
2169 while let Some(k) = map_.next_key()? {
2170 match k {
2171 GeneratedField::Status => {
2172 if status__.is_some() {
2173 return Err(serde::de::Error::duplicate_field("status"));
2174 }
2175 status__ = map_.next_value()?;
2176 }
2177 GeneratedField::CanceledJobs => {
2178 if canceled_jobs__.is_some() {
2179 return Err(serde::de::Error::duplicate_field("canceledJobs"));
2180 }
2181 canceled_jobs__ =
2182 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2183 .into_iter().map(|x| x.0).collect())
2184 ;
2185 }
2186 }
2187 }
2188 Ok(CancelCreatingJobsResponse {
2189 status: status__,
2190 canceled_jobs: canceled_jobs__.unwrap_or_default(),
2191 })
2192 }
2193 }
2194 deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2195 }
2196}
2197impl serde::Serialize for ClusterLimit {
2198 #[allow(deprecated)]
2199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2200 where
2201 S: serde::Serializer,
2202 {
2203 use serde::ser::SerializeStruct;
2204 let mut len = 0;
2205 if self.limit.is_some() {
2206 len += 1;
2207 }
2208 let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2209 if let Some(v) = self.limit.as_ref() {
2210 match v {
2211 cluster_limit::Limit::ActorCount(v) => {
2212 struct_ser.serialize_field("actorCount", v)?;
2213 }
2214 }
2215 }
2216 struct_ser.end()
2217 }
2218}
2219impl<'de> serde::Deserialize<'de> for ClusterLimit {
2220 #[allow(deprecated)]
2221 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2222 where
2223 D: serde::Deserializer<'de>,
2224 {
2225 const FIELDS: &[&str] = &[
2226 "actor_count",
2227 "actorCount",
2228 ];
2229
2230 #[allow(clippy::enum_variant_names)]
2231 enum GeneratedField {
2232 ActorCount,
2233 }
2234 impl<'de> serde::Deserialize<'de> for GeneratedField {
2235 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2236 where
2237 D: serde::Deserializer<'de>,
2238 {
2239 struct GeneratedVisitor;
2240
2241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2242 type Value = GeneratedField;
2243
2244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2245 write!(formatter, "expected one of: {:?}", &FIELDS)
2246 }
2247
2248 #[allow(unused_variables)]
2249 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2250 where
2251 E: serde::de::Error,
2252 {
2253 match value {
2254 "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2255 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2256 }
2257 }
2258 }
2259 deserializer.deserialize_identifier(GeneratedVisitor)
2260 }
2261 }
2262 struct GeneratedVisitor;
2263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2264 type Value = ClusterLimit;
2265
2266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2267 formatter.write_str("struct meta.ClusterLimit")
2268 }
2269
2270 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2271 where
2272 V: serde::de::MapAccess<'de>,
2273 {
2274 let mut limit__ = None;
2275 while let Some(k) = map_.next_key()? {
2276 match k {
2277 GeneratedField::ActorCount => {
2278 if limit__.is_some() {
2279 return Err(serde::de::Error::duplicate_field("actorCount"));
2280 }
2281 limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2282;
2283 }
2284 }
2285 }
2286 Ok(ClusterLimit {
2287 limit: limit__,
2288 })
2289 }
2290 }
2291 deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2292 }
2293}
2294impl serde::Serialize for DeleteWorkerNodeRequest {
2295 #[allow(deprecated)]
2296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2297 where
2298 S: serde::Serializer,
2299 {
2300 use serde::ser::SerializeStruct;
2301 let mut len = 0;
2302 if self.host.is_some() {
2303 len += 1;
2304 }
2305 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2306 if let Some(v) = self.host.as_ref() {
2307 struct_ser.serialize_field("host", v)?;
2308 }
2309 struct_ser.end()
2310 }
2311}
2312impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2313 #[allow(deprecated)]
2314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2315 where
2316 D: serde::Deserializer<'de>,
2317 {
2318 const FIELDS: &[&str] = &[
2319 "host",
2320 ];
2321
2322 #[allow(clippy::enum_variant_names)]
2323 enum GeneratedField {
2324 Host,
2325 }
2326 impl<'de> serde::Deserialize<'de> for GeneratedField {
2327 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2328 where
2329 D: serde::Deserializer<'de>,
2330 {
2331 struct GeneratedVisitor;
2332
2333 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2334 type Value = GeneratedField;
2335
2336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2337 write!(formatter, "expected one of: {:?}", &FIELDS)
2338 }
2339
2340 #[allow(unused_variables)]
2341 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2342 where
2343 E: serde::de::Error,
2344 {
2345 match value {
2346 "host" => Ok(GeneratedField::Host),
2347 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2348 }
2349 }
2350 }
2351 deserializer.deserialize_identifier(GeneratedVisitor)
2352 }
2353 }
2354 struct GeneratedVisitor;
2355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2356 type Value = DeleteWorkerNodeRequest;
2357
2358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2359 formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2360 }
2361
2362 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2363 where
2364 V: serde::de::MapAccess<'de>,
2365 {
2366 let mut host__ = None;
2367 while let Some(k) = map_.next_key()? {
2368 match k {
2369 GeneratedField::Host => {
2370 if host__.is_some() {
2371 return Err(serde::de::Error::duplicate_field("host"));
2372 }
2373 host__ = map_.next_value()?;
2374 }
2375 }
2376 }
2377 Ok(DeleteWorkerNodeRequest {
2378 host: host__,
2379 })
2380 }
2381 }
2382 deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2383 }
2384}
2385impl serde::Serialize for DeleteWorkerNodeResponse {
2386 #[allow(deprecated)]
2387 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2388 where
2389 S: serde::Serializer,
2390 {
2391 use serde::ser::SerializeStruct;
2392 let mut len = 0;
2393 if self.status.is_some() {
2394 len += 1;
2395 }
2396 let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2397 if let Some(v) = self.status.as_ref() {
2398 struct_ser.serialize_field("status", v)?;
2399 }
2400 struct_ser.end()
2401 }
2402}
2403impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2404 #[allow(deprecated)]
2405 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2406 where
2407 D: serde::Deserializer<'de>,
2408 {
2409 const FIELDS: &[&str] = &[
2410 "status",
2411 ];
2412
2413 #[allow(clippy::enum_variant_names)]
2414 enum GeneratedField {
2415 Status,
2416 }
2417 impl<'de> serde::Deserialize<'de> for GeneratedField {
2418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2419 where
2420 D: serde::Deserializer<'de>,
2421 {
2422 struct GeneratedVisitor;
2423
2424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2425 type Value = GeneratedField;
2426
2427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2428 write!(formatter, "expected one of: {:?}", &FIELDS)
2429 }
2430
2431 #[allow(unused_variables)]
2432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2433 where
2434 E: serde::de::Error,
2435 {
2436 match value {
2437 "status" => Ok(GeneratedField::Status),
2438 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2439 }
2440 }
2441 }
2442 deserializer.deserialize_identifier(GeneratedVisitor)
2443 }
2444 }
2445 struct GeneratedVisitor;
2446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2447 type Value = DeleteWorkerNodeResponse;
2448
2449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2450 formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2451 }
2452
2453 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2454 where
2455 V: serde::de::MapAccess<'de>,
2456 {
2457 let mut status__ = None;
2458 while let Some(k) = map_.next_key()? {
2459 match k {
2460 GeneratedField::Status => {
2461 if status__.is_some() {
2462 return Err(serde::de::Error::duplicate_field("status"));
2463 }
2464 status__ = map_.next_value()?;
2465 }
2466 }
2467 }
2468 Ok(DeleteWorkerNodeResponse {
2469 status: status__,
2470 })
2471 }
2472 }
2473 deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2474 }
2475}
2476impl serde::Serialize for EventLog {
2477 #[allow(deprecated)]
2478 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2479 where
2480 S: serde::Serializer,
2481 {
2482 use serde::ser::SerializeStruct;
2483 let mut len = 0;
2484 if self.unique_id.is_some() {
2485 len += 1;
2486 }
2487 if self.timestamp.is_some() {
2488 len += 1;
2489 }
2490 if self.event.is_some() {
2491 len += 1;
2492 }
2493 let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2494 if let Some(v) = self.unique_id.as_ref() {
2495 struct_ser.serialize_field("uniqueId", v)?;
2496 }
2497 if let Some(v) = self.timestamp.as_ref() {
2498 #[allow(clippy::needless_borrow)]
2499 #[allow(clippy::needless_borrows_for_generic_args)]
2500 struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2501 }
2502 if let Some(v) = self.event.as_ref() {
2503 match v {
2504 event_log::Event::CreateStreamJobFail(v) => {
2505 struct_ser.serialize_field("createStreamJobFail", v)?;
2506 }
2507 event_log::Event::DirtyStreamJobClear(v) => {
2508 struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2509 }
2510 event_log::Event::MetaNodeStart(v) => {
2511 struct_ser.serialize_field("metaNodeStart", v)?;
2512 }
2513 event_log::Event::BarrierComplete(v) => {
2514 struct_ser.serialize_field("barrierComplete", v)?;
2515 }
2516 event_log::Event::InjectBarrierFail(v) => {
2517 struct_ser.serialize_field("injectBarrierFail", v)?;
2518 }
2519 event_log::Event::CollectBarrierFail(v) => {
2520 struct_ser.serialize_field("collectBarrierFail", v)?;
2521 }
2522 event_log::Event::WorkerNodePanic(v) => {
2523 struct_ser.serialize_field("workerNodePanic", v)?;
2524 }
2525 event_log::Event::AutoSchemaChangeFail(v) => {
2526 struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2527 }
2528 event_log::Event::SinkFail(v) => {
2529 struct_ser.serialize_field("sinkFail", v)?;
2530 }
2531 event_log::Event::Recovery(v) => {
2532 struct_ser.serialize_field("recovery", v)?;
2533 }
2534 }
2535 }
2536 struct_ser.end()
2537 }
2538}
2539impl<'de> serde::Deserialize<'de> for EventLog {
2540 #[allow(deprecated)]
2541 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2542 where
2543 D: serde::Deserializer<'de>,
2544 {
2545 const FIELDS: &[&str] = &[
2546 "unique_id",
2547 "uniqueId",
2548 "timestamp",
2549 "create_stream_job_fail",
2550 "createStreamJobFail",
2551 "dirty_stream_job_clear",
2552 "dirtyStreamJobClear",
2553 "meta_node_start",
2554 "metaNodeStart",
2555 "barrier_complete",
2556 "barrierComplete",
2557 "inject_barrier_fail",
2558 "injectBarrierFail",
2559 "collect_barrier_fail",
2560 "collectBarrierFail",
2561 "worker_node_panic",
2562 "workerNodePanic",
2563 "auto_schema_change_fail",
2564 "autoSchemaChangeFail",
2565 "sink_fail",
2566 "sinkFail",
2567 "recovery",
2568 ];
2569
2570 #[allow(clippy::enum_variant_names)]
2571 enum GeneratedField {
2572 UniqueId,
2573 Timestamp,
2574 CreateStreamJobFail,
2575 DirtyStreamJobClear,
2576 MetaNodeStart,
2577 BarrierComplete,
2578 InjectBarrierFail,
2579 CollectBarrierFail,
2580 WorkerNodePanic,
2581 AutoSchemaChangeFail,
2582 SinkFail,
2583 Recovery,
2584 }
2585 impl<'de> serde::Deserialize<'de> for GeneratedField {
2586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2587 where
2588 D: serde::Deserializer<'de>,
2589 {
2590 struct GeneratedVisitor;
2591
2592 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2593 type Value = GeneratedField;
2594
2595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2596 write!(formatter, "expected one of: {:?}", &FIELDS)
2597 }
2598
2599 #[allow(unused_variables)]
2600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2601 where
2602 E: serde::de::Error,
2603 {
2604 match value {
2605 "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2606 "timestamp" => Ok(GeneratedField::Timestamp),
2607 "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2608 "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2609 "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2610 "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2611 "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2612 "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2613 "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2614 "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2615 "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2616 "recovery" => Ok(GeneratedField::Recovery),
2617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2618 }
2619 }
2620 }
2621 deserializer.deserialize_identifier(GeneratedVisitor)
2622 }
2623 }
2624 struct GeneratedVisitor;
2625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2626 type Value = EventLog;
2627
2628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2629 formatter.write_str("struct meta.EventLog")
2630 }
2631
2632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2633 where
2634 V: serde::de::MapAccess<'de>,
2635 {
2636 let mut unique_id__ = None;
2637 let mut timestamp__ = None;
2638 let mut event__ = None;
2639 while let Some(k) = map_.next_key()? {
2640 match k {
2641 GeneratedField::UniqueId => {
2642 if unique_id__.is_some() {
2643 return Err(serde::de::Error::duplicate_field("uniqueId"));
2644 }
2645 unique_id__ = map_.next_value()?;
2646 }
2647 GeneratedField::Timestamp => {
2648 if timestamp__.is_some() {
2649 return Err(serde::de::Error::duplicate_field("timestamp"));
2650 }
2651 timestamp__ =
2652 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2653 ;
2654 }
2655 GeneratedField::CreateStreamJobFail => {
2656 if event__.is_some() {
2657 return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2658 }
2659 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2660;
2661 }
2662 GeneratedField::DirtyStreamJobClear => {
2663 if event__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2665 }
2666 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2667;
2668 }
2669 GeneratedField::MetaNodeStart => {
2670 if event__.is_some() {
2671 return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2672 }
2673 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2674;
2675 }
2676 GeneratedField::BarrierComplete => {
2677 if event__.is_some() {
2678 return Err(serde::de::Error::duplicate_field("barrierComplete"));
2679 }
2680 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2681;
2682 }
2683 GeneratedField::InjectBarrierFail => {
2684 if event__.is_some() {
2685 return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2686 }
2687 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2688;
2689 }
2690 GeneratedField::CollectBarrierFail => {
2691 if event__.is_some() {
2692 return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2693 }
2694 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2695;
2696 }
2697 GeneratedField::WorkerNodePanic => {
2698 if event__.is_some() {
2699 return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2700 }
2701 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2702;
2703 }
2704 GeneratedField::AutoSchemaChangeFail => {
2705 if event__.is_some() {
2706 return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2707 }
2708 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2709;
2710 }
2711 GeneratedField::SinkFail => {
2712 if event__.is_some() {
2713 return Err(serde::de::Error::duplicate_field("sinkFail"));
2714 }
2715 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2716;
2717 }
2718 GeneratedField::Recovery => {
2719 if event__.is_some() {
2720 return Err(serde::de::Error::duplicate_field("recovery"));
2721 }
2722 event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2723;
2724 }
2725 }
2726 }
2727 Ok(EventLog {
2728 unique_id: unique_id__,
2729 timestamp: timestamp__,
2730 event: event__,
2731 })
2732 }
2733 }
2734 deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2735 }
2736}
2737impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2738 #[allow(deprecated)]
2739 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2740 where
2741 S: serde::Serializer,
2742 {
2743 use serde::ser::SerializeStruct;
2744 let mut len = 0;
2745 if self.table_id != 0 {
2746 len += 1;
2747 }
2748 if !self.table_name.is_empty() {
2749 len += 1;
2750 }
2751 if !self.cdc_table_id.is_empty() {
2752 len += 1;
2753 }
2754 if !self.upstream_ddl.is_empty() {
2755 len += 1;
2756 }
2757 if !self.fail_info.is_empty() {
2758 len += 1;
2759 }
2760 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2761 if self.table_id != 0 {
2762 struct_ser.serialize_field("tableId", &self.table_id)?;
2763 }
2764 if !self.table_name.is_empty() {
2765 struct_ser.serialize_field("tableName", &self.table_name)?;
2766 }
2767 if !self.cdc_table_id.is_empty() {
2768 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2769 }
2770 if !self.upstream_ddl.is_empty() {
2771 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2772 }
2773 if !self.fail_info.is_empty() {
2774 struct_ser.serialize_field("failInfo", &self.fail_info)?;
2775 }
2776 struct_ser.end()
2777 }
2778}
2779impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2780 #[allow(deprecated)]
2781 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2782 where
2783 D: serde::Deserializer<'de>,
2784 {
2785 const FIELDS: &[&str] = &[
2786 "table_id",
2787 "tableId",
2788 "table_name",
2789 "tableName",
2790 "cdc_table_id",
2791 "cdcTableId",
2792 "upstream_ddl",
2793 "upstreamDdl",
2794 "fail_info",
2795 "failInfo",
2796 ];
2797
2798 #[allow(clippy::enum_variant_names)]
2799 enum GeneratedField {
2800 TableId,
2801 TableName,
2802 CdcTableId,
2803 UpstreamDdl,
2804 FailInfo,
2805 }
2806 impl<'de> serde::Deserialize<'de> for GeneratedField {
2807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2808 where
2809 D: serde::Deserializer<'de>,
2810 {
2811 struct GeneratedVisitor;
2812
2813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2814 type Value = GeneratedField;
2815
2816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2817 write!(formatter, "expected one of: {:?}", &FIELDS)
2818 }
2819
2820 #[allow(unused_variables)]
2821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2822 where
2823 E: serde::de::Error,
2824 {
2825 match value {
2826 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2827 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2828 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2829 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2830 "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
2831 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2832 }
2833 }
2834 }
2835 deserializer.deserialize_identifier(GeneratedVisitor)
2836 }
2837 }
2838 struct GeneratedVisitor;
2839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2840 type Value = event_log::EventAutoSchemaChangeFail;
2841
2842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2843 formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2844 }
2845
2846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2847 where
2848 V: serde::de::MapAccess<'de>,
2849 {
2850 let mut table_id__ = None;
2851 let mut table_name__ = None;
2852 let mut cdc_table_id__ = None;
2853 let mut upstream_ddl__ = None;
2854 let mut fail_info__ = None;
2855 while let Some(k) = map_.next_key()? {
2856 match k {
2857 GeneratedField::TableId => {
2858 if table_id__.is_some() {
2859 return Err(serde::de::Error::duplicate_field("tableId"));
2860 }
2861 table_id__ =
2862 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2863 ;
2864 }
2865 GeneratedField::TableName => {
2866 if table_name__.is_some() {
2867 return Err(serde::de::Error::duplicate_field("tableName"));
2868 }
2869 table_name__ = Some(map_.next_value()?);
2870 }
2871 GeneratedField::CdcTableId => {
2872 if cdc_table_id__.is_some() {
2873 return Err(serde::de::Error::duplicate_field("cdcTableId"));
2874 }
2875 cdc_table_id__ = Some(map_.next_value()?);
2876 }
2877 GeneratedField::UpstreamDdl => {
2878 if upstream_ddl__.is_some() {
2879 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
2880 }
2881 upstream_ddl__ = Some(map_.next_value()?);
2882 }
2883 GeneratedField::FailInfo => {
2884 if fail_info__.is_some() {
2885 return Err(serde::de::Error::duplicate_field("failInfo"));
2886 }
2887 fail_info__ = Some(map_.next_value()?);
2888 }
2889 }
2890 }
2891 Ok(event_log::EventAutoSchemaChangeFail {
2892 table_id: table_id__.unwrap_or_default(),
2893 table_name: table_name__.unwrap_or_default(),
2894 cdc_table_id: cdc_table_id__.unwrap_or_default(),
2895 upstream_ddl: upstream_ddl__.unwrap_or_default(),
2896 fail_info: fail_info__.unwrap_or_default(),
2897 })
2898 }
2899 }
2900 deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
2901 }
2902}
2903impl serde::Serialize for event_log::EventBarrierComplete {
2904 #[allow(deprecated)]
2905 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2906 where
2907 S: serde::Serializer,
2908 {
2909 use serde::ser::SerializeStruct;
2910 let mut len = 0;
2911 if self.prev_epoch != 0 {
2912 len += 1;
2913 }
2914 if self.cur_epoch != 0 {
2915 len += 1;
2916 }
2917 if self.duration_sec != 0. {
2918 len += 1;
2919 }
2920 if !self.command.is_empty() {
2921 len += 1;
2922 }
2923 if !self.barrier_kind.is_empty() {
2924 len += 1;
2925 }
2926 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
2927 if self.prev_epoch != 0 {
2928 #[allow(clippy::needless_borrow)]
2929 #[allow(clippy::needless_borrows_for_generic_args)]
2930 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
2931 }
2932 if self.cur_epoch != 0 {
2933 #[allow(clippy::needless_borrow)]
2934 #[allow(clippy::needless_borrows_for_generic_args)]
2935 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
2936 }
2937 if self.duration_sec != 0. {
2938 struct_ser.serialize_field("durationSec", &self.duration_sec)?;
2939 }
2940 if !self.command.is_empty() {
2941 struct_ser.serialize_field("command", &self.command)?;
2942 }
2943 if !self.barrier_kind.is_empty() {
2944 struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
2945 }
2946 struct_ser.end()
2947 }
2948}
2949impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
2950 #[allow(deprecated)]
2951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2952 where
2953 D: serde::Deserializer<'de>,
2954 {
2955 const FIELDS: &[&str] = &[
2956 "prev_epoch",
2957 "prevEpoch",
2958 "cur_epoch",
2959 "curEpoch",
2960 "duration_sec",
2961 "durationSec",
2962 "command",
2963 "barrier_kind",
2964 "barrierKind",
2965 ];
2966
2967 #[allow(clippy::enum_variant_names)]
2968 enum GeneratedField {
2969 PrevEpoch,
2970 CurEpoch,
2971 DurationSec,
2972 Command,
2973 BarrierKind,
2974 }
2975 impl<'de> serde::Deserialize<'de> for GeneratedField {
2976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2977 where
2978 D: serde::Deserializer<'de>,
2979 {
2980 struct GeneratedVisitor;
2981
2982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2983 type Value = GeneratedField;
2984
2985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2986 write!(formatter, "expected one of: {:?}", &FIELDS)
2987 }
2988
2989 #[allow(unused_variables)]
2990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2991 where
2992 E: serde::de::Error,
2993 {
2994 match value {
2995 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
2996 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
2997 "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
2998 "command" => Ok(GeneratedField::Command),
2999 "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3001 }
3002 }
3003 }
3004 deserializer.deserialize_identifier(GeneratedVisitor)
3005 }
3006 }
3007 struct GeneratedVisitor;
3008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3009 type Value = event_log::EventBarrierComplete;
3010
3011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3012 formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3013 }
3014
3015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3016 where
3017 V: serde::de::MapAccess<'de>,
3018 {
3019 let mut prev_epoch__ = None;
3020 let mut cur_epoch__ = None;
3021 let mut duration_sec__ = None;
3022 let mut command__ = None;
3023 let mut barrier_kind__ = None;
3024 while let Some(k) = map_.next_key()? {
3025 match k {
3026 GeneratedField::PrevEpoch => {
3027 if prev_epoch__.is_some() {
3028 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3029 }
3030 prev_epoch__ =
3031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3032 ;
3033 }
3034 GeneratedField::CurEpoch => {
3035 if cur_epoch__.is_some() {
3036 return Err(serde::de::Error::duplicate_field("curEpoch"));
3037 }
3038 cur_epoch__ =
3039 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3040 ;
3041 }
3042 GeneratedField::DurationSec => {
3043 if duration_sec__.is_some() {
3044 return Err(serde::de::Error::duplicate_field("durationSec"));
3045 }
3046 duration_sec__ =
3047 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3048 ;
3049 }
3050 GeneratedField::Command => {
3051 if command__.is_some() {
3052 return Err(serde::de::Error::duplicate_field("command"));
3053 }
3054 command__ = Some(map_.next_value()?);
3055 }
3056 GeneratedField::BarrierKind => {
3057 if barrier_kind__.is_some() {
3058 return Err(serde::de::Error::duplicate_field("barrierKind"));
3059 }
3060 barrier_kind__ = Some(map_.next_value()?);
3061 }
3062 }
3063 }
3064 Ok(event_log::EventBarrierComplete {
3065 prev_epoch: prev_epoch__.unwrap_or_default(),
3066 cur_epoch: cur_epoch__.unwrap_or_default(),
3067 duration_sec: duration_sec__.unwrap_or_default(),
3068 command: command__.unwrap_or_default(),
3069 barrier_kind: barrier_kind__.unwrap_or_default(),
3070 })
3071 }
3072 }
3073 deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3074 }
3075}
3076impl serde::Serialize for event_log::EventCollectBarrierFail {
3077 #[allow(deprecated)]
3078 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3079 where
3080 S: serde::Serializer,
3081 {
3082 use serde::ser::SerializeStruct;
3083 let mut len = 0;
3084 if !self.error.is_empty() {
3085 len += 1;
3086 }
3087 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3088 if !self.error.is_empty() {
3089 struct_ser.serialize_field("error", &self.error)?;
3090 }
3091 struct_ser.end()
3092 }
3093}
3094impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3095 #[allow(deprecated)]
3096 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3097 where
3098 D: serde::Deserializer<'de>,
3099 {
3100 const FIELDS: &[&str] = &[
3101 "error",
3102 ];
3103
3104 #[allow(clippy::enum_variant_names)]
3105 enum GeneratedField {
3106 Error,
3107 }
3108 impl<'de> serde::Deserialize<'de> for GeneratedField {
3109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3110 where
3111 D: serde::Deserializer<'de>,
3112 {
3113 struct GeneratedVisitor;
3114
3115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3116 type Value = GeneratedField;
3117
3118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3119 write!(formatter, "expected one of: {:?}", &FIELDS)
3120 }
3121
3122 #[allow(unused_variables)]
3123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3124 where
3125 E: serde::de::Error,
3126 {
3127 match value {
3128 "error" => Ok(GeneratedField::Error),
3129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3130 }
3131 }
3132 }
3133 deserializer.deserialize_identifier(GeneratedVisitor)
3134 }
3135 }
3136 struct GeneratedVisitor;
3137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3138 type Value = event_log::EventCollectBarrierFail;
3139
3140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3141 formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3142 }
3143
3144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3145 where
3146 V: serde::de::MapAccess<'de>,
3147 {
3148 let mut error__ = None;
3149 while let Some(k) = map_.next_key()? {
3150 match k {
3151 GeneratedField::Error => {
3152 if error__.is_some() {
3153 return Err(serde::de::Error::duplicate_field("error"));
3154 }
3155 error__ = Some(map_.next_value()?);
3156 }
3157 }
3158 }
3159 Ok(event_log::EventCollectBarrierFail {
3160 error: error__.unwrap_or_default(),
3161 })
3162 }
3163 }
3164 deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3165 }
3166}
3167impl serde::Serialize for event_log::EventCreateStreamJobFail {
3168 #[allow(deprecated)]
3169 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3170 where
3171 S: serde::Serializer,
3172 {
3173 use serde::ser::SerializeStruct;
3174 let mut len = 0;
3175 if self.id != 0 {
3176 len += 1;
3177 }
3178 if !self.name.is_empty() {
3179 len += 1;
3180 }
3181 if !self.definition.is_empty() {
3182 len += 1;
3183 }
3184 if !self.error.is_empty() {
3185 len += 1;
3186 }
3187 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3188 if self.id != 0 {
3189 struct_ser.serialize_field("id", &self.id)?;
3190 }
3191 if !self.name.is_empty() {
3192 struct_ser.serialize_field("name", &self.name)?;
3193 }
3194 if !self.definition.is_empty() {
3195 struct_ser.serialize_field("definition", &self.definition)?;
3196 }
3197 if !self.error.is_empty() {
3198 struct_ser.serialize_field("error", &self.error)?;
3199 }
3200 struct_ser.end()
3201 }
3202}
3203impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3204 #[allow(deprecated)]
3205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3206 where
3207 D: serde::Deserializer<'de>,
3208 {
3209 const FIELDS: &[&str] = &[
3210 "id",
3211 "name",
3212 "definition",
3213 "error",
3214 ];
3215
3216 #[allow(clippy::enum_variant_names)]
3217 enum GeneratedField {
3218 Id,
3219 Name,
3220 Definition,
3221 Error,
3222 }
3223 impl<'de> serde::Deserialize<'de> for GeneratedField {
3224 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3225 where
3226 D: serde::Deserializer<'de>,
3227 {
3228 struct GeneratedVisitor;
3229
3230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3231 type Value = GeneratedField;
3232
3233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3234 write!(formatter, "expected one of: {:?}", &FIELDS)
3235 }
3236
3237 #[allow(unused_variables)]
3238 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3239 where
3240 E: serde::de::Error,
3241 {
3242 match value {
3243 "id" => Ok(GeneratedField::Id),
3244 "name" => Ok(GeneratedField::Name),
3245 "definition" => Ok(GeneratedField::Definition),
3246 "error" => Ok(GeneratedField::Error),
3247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3248 }
3249 }
3250 }
3251 deserializer.deserialize_identifier(GeneratedVisitor)
3252 }
3253 }
3254 struct GeneratedVisitor;
3255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256 type Value = event_log::EventCreateStreamJobFail;
3257
3258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259 formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3260 }
3261
3262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3263 where
3264 V: serde::de::MapAccess<'de>,
3265 {
3266 let mut id__ = None;
3267 let mut name__ = None;
3268 let mut definition__ = None;
3269 let mut error__ = None;
3270 while let Some(k) = map_.next_key()? {
3271 match k {
3272 GeneratedField::Id => {
3273 if id__.is_some() {
3274 return Err(serde::de::Error::duplicate_field("id"));
3275 }
3276 id__ =
3277 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3278 ;
3279 }
3280 GeneratedField::Name => {
3281 if name__.is_some() {
3282 return Err(serde::de::Error::duplicate_field("name"));
3283 }
3284 name__ = Some(map_.next_value()?);
3285 }
3286 GeneratedField::Definition => {
3287 if definition__.is_some() {
3288 return Err(serde::de::Error::duplicate_field("definition"));
3289 }
3290 definition__ = Some(map_.next_value()?);
3291 }
3292 GeneratedField::Error => {
3293 if error__.is_some() {
3294 return Err(serde::de::Error::duplicate_field("error"));
3295 }
3296 error__ = Some(map_.next_value()?);
3297 }
3298 }
3299 }
3300 Ok(event_log::EventCreateStreamJobFail {
3301 id: id__.unwrap_or_default(),
3302 name: name__.unwrap_or_default(),
3303 definition: definition__.unwrap_or_default(),
3304 error: error__.unwrap_or_default(),
3305 })
3306 }
3307 }
3308 deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3309 }
3310}
3311impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3312 #[allow(deprecated)]
3313 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3314 where
3315 S: serde::Serializer,
3316 {
3317 use serde::ser::SerializeStruct;
3318 let mut len = 0;
3319 if self.id != 0 {
3320 len += 1;
3321 }
3322 if !self.name.is_empty() {
3323 len += 1;
3324 }
3325 if !self.definition.is_empty() {
3326 len += 1;
3327 }
3328 if !self.error.is_empty() {
3329 len += 1;
3330 }
3331 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3332 if self.id != 0 {
3333 struct_ser.serialize_field("id", &self.id)?;
3334 }
3335 if !self.name.is_empty() {
3336 struct_ser.serialize_field("name", &self.name)?;
3337 }
3338 if !self.definition.is_empty() {
3339 struct_ser.serialize_field("definition", &self.definition)?;
3340 }
3341 if !self.error.is_empty() {
3342 struct_ser.serialize_field("error", &self.error)?;
3343 }
3344 struct_ser.end()
3345 }
3346}
3347impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3348 #[allow(deprecated)]
3349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3350 where
3351 D: serde::Deserializer<'de>,
3352 {
3353 const FIELDS: &[&str] = &[
3354 "id",
3355 "name",
3356 "definition",
3357 "error",
3358 ];
3359
3360 #[allow(clippy::enum_variant_names)]
3361 enum GeneratedField {
3362 Id,
3363 Name,
3364 Definition,
3365 Error,
3366 }
3367 impl<'de> serde::Deserialize<'de> for GeneratedField {
3368 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3369 where
3370 D: serde::Deserializer<'de>,
3371 {
3372 struct GeneratedVisitor;
3373
3374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3375 type Value = GeneratedField;
3376
3377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3378 write!(formatter, "expected one of: {:?}", &FIELDS)
3379 }
3380
3381 #[allow(unused_variables)]
3382 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3383 where
3384 E: serde::de::Error,
3385 {
3386 match value {
3387 "id" => Ok(GeneratedField::Id),
3388 "name" => Ok(GeneratedField::Name),
3389 "definition" => Ok(GeneratedField::Definition),
3390 "error" => Ok(GeneratedField::Error),
3391 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3392 }
3393 }
3394 }
3395 deserializer.deserialize_identifier(GeneratedVisitor)
3396 }
3397 }
3398 struct GeneratedVisitor;
3399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3400 type Value = event_log::EventDirtyStreamJobClear;
3401
3402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3403 formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3404 }
3405
3406 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3407 where
3408 V: serde::de::MapAccess<'de>,
3409 {
3410 let mut id__ = None;
3411 let mut name__ = None;
3412 let mut definition__ = None;
3413 let mut error__ = None;
3414 while let Some(k) = map_.next_key()? {
3415 match k {
3416 GeneratedField::Id => {
3417 if id__.is_some() {
3418 return Err(serde::de::Error::duplicate_field("id"));
3419 }
3420 id__ =
3421 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3422 ;
3423 }
3424 GeneratedField::Name => {
3425 if name__.is_some() {
3426 return Err(serde::de::Error::duplicate_field("name"));
3427 }
3428 name__ = Some(map_.next_value()?);
3429 }
3430 GeneratedField::Definition => {
3431 if definition__.is_some() {
3432 return Err(serde::de::Error::duplicate_field("definition"));
3433 }
3434 definition__ = Some(map_.next_value()?);
3435 }
3436 GeneratedField::Error => {
3437 if error__.is_some() {
3438 return Err(serde::de::Error::duplicate_field("error"));
3439 }
3440 error__ = Some(map_.next_value()?);
3441 }
3442 }
3443 }
3444 Ok(event_log::EventDirtyStreamJobClear {
3445 id: id__.unwrap_or_default(),
3446 name: name__.unwrap_or_default(),
3447 definition: definition__.unwrap_or_default(),
3448 error: error__.unwrap_or_default(),
3449 })
3450 }
3451 }
3452 deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3453 }
3454}
3455impl serde::Serialize for event_log::EventInjectBarrierFail {
3456 #[allow(deprecated)]
3457 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3458 where
3459 S: serde::Serializer,
3460 {
3461 use serde::ser::SerializeStruct;
3462 let mut len = 0;
3463 if self.prev_epoch != 0 {
3464 len += 1;
3465 }
3466 if self.cur_epoch != 0 {
3467 len += 1;
3468 }
3469 if !self.error.is_empty() {
3470 len += 1;
3471 }
3472 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3473 if self.prev_epoch != 0 {
3474 #[allow(clippy::needless_borrow)]
3475 #[allow(clippy::needless_borrows_for_generic_args)]
3476 struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3477 }
3478 if self.cur_epoch != 0 {
3479 #[allow(clippy::needless_borrow)]
3480 #[allow(clippy::needless_borrows_for_generic_args)]
3481 struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3482 }
3483 if !self.error.is_empty() {
3484 struct_ser.serialize_field("error", &self.error)?;
3485 }
3486 struct_ser.end()
3487 }
3488}
3489impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3490 #[allow(deprecated)]
3491 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3492 where
3493 D: serde::Deserializer<'de>,
3494 {
3495 const FIELDS: &[&str] = &[
3496 "prev_epoch",
3497 "prevEpoch",
3498 "cur_epoch",
3499 "curEpoch",
3500 "error",
3501 ];
3502
3503 #[allow(clippy::enum_variant_names)]
3504 enum GeneratedField {
3505 PrevEpoch,
3506 CurEpoch,
3507 Error,
3508 }
3509 impl<'de> serde::Deserialize<'de> for GeneratedField {
3510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3511 where
3512 D: serde::Deserializer<'de>,
3513 {
3514 struct GeneratedVisitor;
3515
3516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3517 type Value = GeneratedField;
3518
3519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3520 write!(formatter, "expected one of: {:?}", &FIELDS)
3521 }
3522
3523 #[allow(unused_variables)]
3524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3525 where
3526 E: serde::de::Error,
3527 {
3528 match value {
3529 "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3530 "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3531 "error" => Ok(GeneratedField::Error),
3532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3533 }
3534 }
3535 }
3536 deserializer.deserialize_identifier(GeneratedVisitor)
3537 }
3538 }
3539 struct GeneratedVisitor;
3540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3541 type Value = event_log::EventInjectBarrierFail;
3542
3543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3544 formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3545 }
3546
3547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3548 where
3549 V: serde::de::MapAccess<'de>,
3550 {
3551 let mut prev_epoch__ = None;
3552 let mut cur_epoch__ = None;
3553 let mut error__ = None;
3554 while let Some(k) = map_.next_key()? {
3555 match k {
3556 GeneratedField::PrevEpoch => {
3557 if prev_epoch__.is_some() {
3558 return Err(serde::de::Error::duplicate_field("prevEpoch"));
3559 }
3560 prev_epoch__ =
3561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3562 ;
3563 }
3564 GeneratedField::CurEpoch => {
3565 if cur_epoch__.is_some() {
3566 return Err(serde::de::Error::duplicate_field("curEpoch"));
3567 }
3568 cur_epoch__ =
3569 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3570 ;
3571 }
3572 GeneratedField::Error => {
3573 if error__.is_some() {
3574 return Err(serde::de::Error::duplicate_field("error"));
3575 }
3576 error__ = Some(map_.next_value()?);
3577 }
3578 }
3579 }
3580 Ok(event_log::EventInjectBarrierFail {
3581 prev_epoch: prev_epoch__.unwrap_or_default(),
3582 cur_epoch: cur_epoch__.unwrap_or_default(),
3583 error: error__.unwrap_or_default(),
3584 })
3585 }
3586 }
3587 deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3588 }
3589}
3590impl serde::Serialize for event_log::EventMetaNodeStart {
3591 #[allow(deprecated)]
3592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3593 where
3594 S: serde::Serializer,
3595 {
3596 use serde::ser::SerializeStruct;
3597 let mut len = 0;
3598 if !self.advertise_addr.is_empty() {
3599 len += 1;
3600 }
3601 if !self.listen_addr.is_empty() {
3602 len += 1;
3603 }
3604 if !self.opts.is_empty() {
3605 len += 1;
3606 }
3607 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3608 if !self.advertise_addr.is_empty() {
3609 struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3610 }
3611 if !self.listen_addr.is_empty() {
3612 struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3613 }
3614 if !self.opts.is_empty() {
3615 struct_ser.serialize_field("opts", &self.opts)?;
3616 }
3617 struct_ser.end()
3618 }
3619}
3620impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3621 #[allow(deprecated)]
3622 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3623 where
3624 D: serde::Deserializer<'de>,
3625 {
3626 const FIELDS: &[&str] = &[
3627 "advertise_addr",
3628 "advertiseAddr",
3629 "listen_addr",
3630 "listenAddr",
3631 "opts",
3632 ];
3633
3634 #[allow(clippy::enum_variant_names)]
3635 enum GeneratedField {
3636 AdvertiseAddr,
3637 ListenAddr,
3638 Opts,
3639 }
3640 impl<'de> serde::Deserialize<'de> for GeneratedField {
3641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3642 where
3643 D: serde::Deserializer<'de>,
3644 {
3645 struct GeneratedVisitor;
3646
3647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3648 type Value = GeneratedField;
3649
3650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3651 write!(formatter, "expected one of: {:?}", &FIELDS)
3652 }
3653
3654 #[allow(unused_variables)]
3655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3656 where
3657 E: serde::de::Error,
3658 {
3659 match value {
3660 "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3661 "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3662 "opts" => Ok(GeneratedField::Opts),
3663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3664 }
3665 }
3666 }
3667 deserializer.deserialize_identifier(GeneratedVisitor)
3668 }
3669 }
3670 struct GeneratedVisitor;
3671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3672 type Value = event_log::EventMetaNodeStart;
3673
3674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3675 formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3676 }
3677
3678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3679 where
3680 V: serde::de::MapAccess<'de>,
3681 {
3682 let mut advertise_addr__ = None;
3683 let mut listen_addr__ = None;
3684 let mut opts__ = None;
3685 while let Some(k) = map_.next_key()? {
3686 match k {
3687 GeneratedField::AdvertiseAddr => {
3688 if advertise_addr__.is_some() {
3689 return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3690 }
3691 advertise_addr__ = Some(map_.next_value()?);
3692 }
3693 GeneratedField::ListenAddr => {
3694 if listen_addr__.is_some() {
3695 return Err(serde::de::Error::duplicate_field("listenAddr"));
3696 }
3697 listen_addr__ = Some(map_.next_value()?);
3698 }
3699 GeneratedField::Opts => {
3700 if opts__.is_some() {
3701 return Err(serde::de::Error::duplicate_field("opts"));
3702 }
3703 opts__ = Some(map_.next_value()?);
3704 }
3705 }
3706 }
3707 Ok(event_log::EventMetaNodeStart {
3708 advertise_addr: advertise_addr__.unwrap_or_default(),
3709 listen_addr: listen_addr__.unwrap_or_default(),
3710 opts: opts__.unwrap_or_default(),
3711 })
3712 }
3713 }
3714 deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3715 }
3716}
3717impl serde::Serialize for event_log::EventRecovery {
3718 #[allow(deprecated)]
3719 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3720 where
3721 S: serde::Serializer,
3722 {
3723 use serde::ser::SerializeStruct;
3724 let mut len = 0;
3725 if self.recovery_event.is_some() {
3726 len += 1;
3727 }
3728 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3729 if let Some(v) = self.recovery_event.as_ref() {
3730 match v {
3731 event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3732 struct_ser.serialize_field("globalStart", v)?;
3733 }
3734 event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3735 struct_ser.serialize_field("globalSuccess", v)?;
3736 }
3737 event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3738 struct_ser.serialize_field("globalFailure", v)?;
3739 }
3740 event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3741 struct_ser.serialize_field("databaseStart", v)?;
3742 }
3743 event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3744 struct_ser.serialize_field("databaseFailure", v)?;
3745 }
3746 event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3747 struct_ser.serialize_field("databaseSuccess", v)?;
3748 }
3749 }
3750 }
3751 struct_ser.end()
3752 }
3753}
3754impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3755 #[allow(deprecated)]
3756 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3757 where
3758 D: serde::Deserializer<'de>,
3759 {
3760 const FIELDS: &[&str] = &[
3761 "global_start",
3762 "globalStart",
3763 "global_success",
3764 "globalSuccess",
3765 "global_failure",
3766 "globalFailure",
3767 "database_start",
3768 "databaseStart",
3769 "database_failure",
3770 "databaseFailure",
3771 "database_success",
3772 "databaseSuccess",
3773 ];
3774
3775 #[allow(clippy::enum_variant_names)]
3776 enum GeneratedField {
3777 GlobalStart,
3778 GlobalSuccess,
3779 GlobalFailure,
3780 DatabaseStart,
3781 DatabaseFailure,
3782 DatabaseSuccess,
3783 }
3784 impl<'de> serde::Deserialize<'de> for GeneratedField {
3785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3786 where
3787 D: serde::Deserializer<'de>,
3788 {
3789 struct GeneratedVisitor;
3790
3791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3792 type Value = GeneratedField;
3793
3794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3795 write!(formatter, "expected one of: {:?}", &FIELDS)
3796 }
3797
3798 #[allow(unused_variables)]
3799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3800 where
3801 E: serde::de::Error,
3802 {
3803 match value {
3804 "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3805 "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3806 "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3807 "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3808 "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3809 "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3811 }
3812 }
3813 }
3814 deserializer.deserialize_identifier(GeneratedVisitor)
3815 }
3816 }
3817 struct GeneratedVisitor;
3818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3819 type Value = event_log::EventRecovery;
3820
3821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3822 formatter.write_str("struct meta.EventLog.EventRecovery")
3823 }
3824
3825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3826 where
3827 V: serde::de::MapAccess<'de>,
3828 {
3829 let mut recovery_event__ = None;
3830 while let Some(k) = map_.next_key()? {
3831 match k {
3832 GeneratedField::GlobalStart => {
3833 if recovery_event__.is_some() {
3834 return Err(serde::de::Error::duplicate_field("globalStart"));
3835 }
3836 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3837;
3838 }
3839 GeneratedField::GlobalSuccess => {
3840 if recovery_event__.is_some() {
3841 return Err(serde::de::Error::duplicate_field("globalSuccess"));
3842 }
3843 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3844;
3845 }
3846 GeneratedField::GlobalFailure => {
3847 if recovery_event__.is_some() {
3848 return Err(serde::de::Error::duplicate_field("globalFailure"));
3849 }
3850 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3851;
3852 }
3853 GeneratedField::DatabaseStart => {
3854 if recovery_event__.is_some() {
3855 return Err(serde::de::Error::duplicate_field("databaseStart"));
3856 }
3857 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3858;
3859 }
3860 GeneratedField::DatabaseFailure => {
3861 if recovery_event__.is_some() {
3862 return Err(serde::de::Error::duplicate_field("databaseFailure"));
3863 }
3864 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
3865;
3866 }
3867 GeneratedField::DatabaseSuccess => {
3868 if recovery_event__.is_some() {
3869 return Err(serde::de::Error::duplicate_field("databaseSuccess"));
3870 }
3871 recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
3872;
3873 }
3874 }
3875 }
3876 Ok(event_log::EventRecovery {
3877 recovery_event: recovery_event__,
3878 })
3879 }
3880 }
3881 deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
3882 }
3883}
3884impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
3885 #[allow(deprecated)]
3886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3887 where
3888 S: serde::Serializer,
3889 {
3890 use serde::ser::SerializeStruct;
3891 let mut len = 0;
3892 if self.database_id != 0 {
3893 len += 1;
3894 }
3895 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
3896 if self.database_id != 0 {
3897 struct_ser.serialize_field("databaseId", &self.database_id)?;
3898 }
3899 struct_ser.end()
3900 }
3901}
3902impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
3903 #[allow(deprecated)]
3904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3905 where
3906 D: serde::Deserializer<'de>,
3907 {
3908 const FIELDS: &[&str] = &[
3909 "database_id",
3910 "databaseId",
3911 ];
3912
3913 #[allow(clippy::enum_variant_names)]
3914 enum GeneratedField {
3915 DatabaseId,
3916 }
3917 impl<'de> serde::Deserialize<'de> for GeneratedField {
3918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3919 where
3920 D: serde::Deserializer<'de>,
3921 {
3922 struct GeneratedVisitor;
3923
3924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3925 type Value = GeneratedField;
3926
3927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3928 write!(formatter, "expected one of: {:?}", &FIELDS)
3929 }
3930
3931 #[allow(unused_variables)]
3932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3933 where
3934 E: serde::de::Error,
3935 {
3936 match value {
3937 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3939 }
3940 }
3941 }
3942 deserializer.deserialize_identifier(GeneratedVisitor)
3943 }
3944 }
3945 struct GeneratedVisitor;
3946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3947 type Value = event_log::event_recovery::DatabaseRecoveryFailure;
3948
3949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3950 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
3951 }
3952
3953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
3954 where
3955 V: serde::de::MapAccess<'de>,
3956 {
3957 let mut database_id__ = None;
3958 while let Some(k) = map_.next_key()? {
3959 match k {
3960 GeneratedField::DatabaseId => {
3961 if database_id__.is_some() {
3962 return Err(serde::de::Error::duplicate_field("databaseId"));
3963 }
3964 database_id__ =
3965 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3966 ;
3967 }
3968 }
3969 }
3970 Ok(event_log::event_recovery::DatabaseRecoveryFailure {
3971 database_id: database_id__.unwrap_or_default(),
3972 })
3973 }
3974 }
3975 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
3976 }
3977}
3978impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
3979 #[allow(deprecated)]
3980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3981 where
3982 S: serde::Serializer,
3983 {
3984 use serde::ser::SerializeStruct;
3985 let mut len = 0;
3986 if self.database_id != 0 {
3987 len += 1;
3988 }
3989 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
3990 if self.database_id != 0 {
3991 struct_ser.serialize_field("databaseId", &self.database_id)?;
3992 }
3993 struct_ser.end()
3994 }
3995}
3996impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
3997 #[allow(deprecated)]
3998 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3999 where
4000 D: serde::Deserializer<'de>,
4001 {
4002 const FIELDS: &[&str] = &[
4003 "database_id",
4004 "databaseId",
4005 ];
4006
4007 #[allow(clippy::enum_variant_names)]
4008 enum GeneratedField {
4009 DatabaseId,
4010 }
4011 impl<'de> serde::Deserialize<'de> for GeneratedField {
4012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4013 where
4014 D: serde::Deserializer<'de>,
4015 {
4016 struct GeneratedVisitor;
4017
4018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4019 type Value = GeneratedField;
4020
4021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4022 write!(formatter, "expected one of: {:?}", &FIELDS)
4023 }
4024
4025 #[allow(unused_variables)]
4026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4027 where
4028 E: serde::de::Error,
4029 {
4030 match value {
4031 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4032 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4033 }
4034 }
4035 }
4036 deserializer.deserialize_identifier(GeneratedVisitor)
4037 }
4038 }
4039 struct GeneratedVisitor;
4040 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4041 type Value = event_log::event_recovery::DatabaseRecoveryStart;
4042
4043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4044 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4045 }
4046
4047 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4048 where
4049 V: serde::de::MapAccess<'de>,
4050 {
4051 let mut database_id__ = None;
4052 while let Some(k) = map_.next_key()? {
4053 match k {
4054 GeneratedField::DatabaseId => {
4055 if database_id__.is_some() {
4056 return Err(serde::de::Error::duplicate_field("databaseId"));
4057 }
4058 database_id__ =
4059 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4060 ;
4061 }
4062 }
4063 }
4064 Ok(event_log::event_recovery::DatabaseRecoveryStart {
4065 database_id: database_id__.unwrap_or_default(),
4066 })
4067 }
4068 }
4069 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4070 }
4071}
4072impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4073 #[allow(deprecated)]
4074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4075 where
4076 S: serde::Serializer,
4077 {
4078 use serde::ser::SerializeStruct;
4079 let mut len = 0;
4080 if self.database_id != 0 {
4081 len += 1;
4082 }
4083 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4084 if self.database_id != 0 {
4085 struct_ser.serialize_field("databaseId", &self.database_id)?;
4086 }
4087 struct_ser.end()
4088 }
4089}
4090impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4091 #[allow(deprecated)]
4092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4093 where
4094 D: serde::Deserializer<'de>,
4095 {
4096 const FIELDS: &[&str] = &[
4097 "database_id",
4098 "databaseId",
4099 ];
4100
4101 #[allow(clippy::enum_variant_names)]
4102 enum GeneratedField {
4103 DatabaseId,
4104 }
4105 impl<'de> serde::Deserialize<'de> for GeneratedField {
4106 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4107 where
4108 D: serde::Deserializer<'de>,
4109 {
4110 struct GeneratedVisitor;
4111
4112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4113 type Value = GeneratedField;
4114
4115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4116 write!(formatter, "expected one of: {:?}", &FIELDS)
4117 }
4118
4119 #[allow(unused_variables)]
4120 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4121 where
4122 E: serde::de::Error,
4123 {
4124 match value {
4125 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4127 }
4128 }
4129 }
4130 deserializer.deserialize_identifier(GeneratedVisitor)
4131 }
4132 }
4133 struct GeneratedVisitor;
4134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4135 type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4136
4137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4138 formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4139 }
4140
4141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4142 where
4143 V: serde::de::MapAccess<'de>,
4144 {
4145 let mut database_id__ = None;
4146 while let Some(k) = map_.next_key()? {
4147 match k {
4148 GeneratedField::DatabaseId => {
4149 if database_id__.is_some() {
4150 return Err(serde::de::Error::duplicate_field("databaseId"));
4151 }
4152 database_id__ =
4153 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4154 ;
4155 }
4156 }
4157 }
4158 Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4159 database_id: database_id__.unwrap_or_default(),
4160 })
4161 }
4162 }
4163 deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4164 }
4165}
4166impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4167 #[allow(deprecated)]
4168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4169 where
4170 S: serde::Serializer,
4171 {
4172 use serde::ser::SerializeStruct;
4173 let mut len = 0;
4174 if !self.reason.is_empty() {
4175 len += 1;
4176 }
4177 if !self.error.is_empty() {
4178 len += 1;
4179 }
4180 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4181 if !self.reason.is_empty() {
4182 struct_ser.serialize_field("reason", &self.reason)?;
4183 }
4184 if !self.error.is_empty() {
4185 struct_ser.serialize_field("error", &self.error)?;
4186 }
4187 struct_ser.end()
4188 }
4189}
4190impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4191 #[allow(deprecated)]
4192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4193 where
4194 D: serde::Deserializer<'de>,
4195 {
4196 const FIELDS: &[&str] = &[
4197 "reason",
4198 "error",
4199 ];
4200
4201 #[allow(clippy::enum_variant_names)]
4202 enum GeneratedField {
4203 Reason,
4204 Error,
4205 }
4206 impl<'de> serde::Deserialize<'de> for GeneratedField {
4207 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4208 where
4209 D: serde::Deserializer<'de>,
4210 {
4211 struct GeneratedVisitor;
4212
4213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4214 type Value = GeneratedField;
4215
4216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4217 write!(formatter, "expected one of: {:?}", &FIELDS)
4218 }
4219
4220 #[allow(unused_variables)]
4221 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4222 where
4223 E: serde::de::Error,
4224 {
4225 match value {
4226 "reason" => Ok(GeneratedField::Reason),
4227 "error" => Ok(GeneratedField::Error),
4228 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4229 }
4230 }
4231 }
4232 deserializer.deserialize_identifier(GeneratedVisitor)
4233 }
4234 }
4235 struct GeneratedVisitor;
4236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4237 type Value = event_log::event_recovery::GlobalRecoveryFailure;
4238
4239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4240 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4241 }
4242
4243 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4244 where
4245 V: serde::de::MapAccess<'de>,
4246 {
4247 let mut reason__ = None;
4248 let mut error__ = None;
4249 while let Some(k) = map_.next_key()? {
4250 match k {
4251 GeneratedField::Reason => {
4252 if reason__.is_some() {
4253 return Err(serde::de::Error::duplicate_field("reason"));
4254 }
4255 reason__ = Some(map_.next_value()?);
4256 }
4257 GeneratedField::Error => {
4258 if error__.is_some() {
4259 return Err(serde::de::Error::duplicate_field("error"));
4260 }
4261 error__ = Some(map_.next_value()?);
4262 }
4263 }
4264 }
4265 Ok(event_log::event_recovery::GlobalRecoveryFailure {
4266 reason: reason__.unwrap_or_default(),
4267 error: error__.unwrap_or_default(),
4268 })
4269 }
4270 }
4271 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4272 }
4273}
4274impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4275 #[allow(deprecated)]
4276 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4277 where
4278 S: serde::Serializer,
4279 {
4280 use serde::ser::SerializeStruct;
4281 let mut len = 0;
4282 if !self.reason.is_empty() {
4283 len += 1;
4284 }
4285 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4286 if !self.reason.is_empty() {
4287 struct_ser.serialize_field("reason", &self.reason)?;
4288 }
4289 struct_ser.end()
4290 }
4291}
4292impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4293 #[allow(deprecated)]
4294 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4295 where
4296 D: serde::Deserializer<'de>,
4297 {
4298 const FIELDS: &[&str] = &[
4299 "reason",
4300 ];
4301
4302 #[allow(clippy::enum_variant_names)]
4303 enum GeneratedField {
4304 Reason,
4305 }
4306 impl<'de> serde::Deserialize<'de> for GeneratedField {
4307 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4308 where
4309 D: serde::Deserializer<'de>,
4310 {
4311 struct GeneratedVisitor;
4312
4313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4314 type Value = GeneratedField;
4315
4316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4317 write!(formatter, "expected one of: {:?}", &FIELDS)
4318 }
4319
4320 #[allow(unused_variables)]
4321 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4322 where
4323 E: serde::de::Error,
4324 {
4325 match value {
4326 "reason" => Ok(GeneratedField::Reason),
4327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4328 }
4329 }
4330 }
4331 deserializer.deserialize_identifier(GeneratedVisitor)
4332 }
4333 }
4334 struct GeneratedVisitor;
4335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4336 type Value = event_log::event_recovery::GlobalRecoveryStart;
4337
4338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4339 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4340 }
4341
4342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4343 where
4344 V: serde::de::MapAccess<'de>,
4345 {
4346 let mut reason__ = None;
4347 while let Some(k) = map_.next_key()? {
4348 match k {
4349 GeneratedField::Reason => {
4350 if reason__.is_some() {
4351 return Err(serde::de::Error::duplicate_field("reason"));
4352 }
4353 reason__ = Some(map_.next_value()?);
4354 }
4355 }
4356 }
4357 Ok(event_log::event_recovery::GlobalRecoveryStart {
4358 reason: reason__.unwrap_or_default(),
4359 })
4360 }
4361 }
4362 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4363 }
4364}
4365impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4366 #[allow(deprecated)]
4367 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4368 where
4369 S: serde::Serializer,
4370 {
4371 use serde::ser::SerializeStruct;
4372 let mut len = 0;
4373 if !self.reason.is_empty() {
4374 len += 1;
4375 }
4376 if self.duration_secs != 0. {
4377 len += 1;
4378 }
4379 if !self.running_database_ids.is_empty() {
4380 len += 1;
4381 }
4382 if !self.recovering_database_ids.is_empty() {
4383 len += 1;
4384 }
4385 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4386 if !self.reason.is_empty() {
4387 struct_ser.serialize_field("reason", &self.reason)?;
4388 }
4389 if self.duration_secs != 0. {
4390 struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4391 }
4392 if !self.running_database_ids.is_empty() {
4393 struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4394 }
4395 if !self.recovering_database_ids.is_empty() {
4396 struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4397 }
4398 struct_ser.end()
4399 }
4400}
4401impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4402 #[allow(deprecated)]
4403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4404 where
4405 D: serde::Deserializer<'de>,
4406 {
4407 const FIELDS: &[&str] = &[
4408 "reason",
4409 "duration_secs",
4410 "durationSecs",
4411 "running_database_ids",
4412 "runningDatabaseIds",
4413 "recovering_database_ids",
4414 "recoveringDatabaseIds",
4415 ];
4416
4417 #[allow(clippy::enum_variant_names)]
4418 enum GeneratedField {
4419 Reason,
4420 DurationSecs,
4421 RunningDatabaseIds,
4422 RecoveringDatabaseIds,
4423 }
4424 impl<'de> serde::Deserialize<'de> for GeneratedField {
4425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4426 where
4427 D: serde::Deserializer<'de>,
4428 {
4429 struct GeneratedVisitor;
4430
4431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4432 type Value = GeneratedField;
4433
4434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4435 write!(formatter, "expected one of: {:?}", &FIELDS)
4436 }
4437
4438 #[allow(unused_variables)]
4439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4440 where
4441 E: serde::de::Error,
4442 {
4443 match value {
4444 "reason" => Ok(GeneratedField::Reason),
4445 "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4446 "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4447 "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4448 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4449 }
4450 }
4451 }
4452 deserializer.deserialize_identifier(GeneratedVisitor)
4453 }
4454 }
4455 struct GeneratedVisitor;
4456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4457 type Value = event_log::event_recovery::GlobalRecoverySuccess;
4458
4459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4460 formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4461 }
4462
4463 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4464 where
4465 V: serde::de::MapAccess<'de>,
4466 {
4467 let mut reason__ = None;
4468 let mut duration_secs__ = None;
4469 let mut running_database_ids__ = None;
4470 let mut recovering_database_ids__ = None;
4471 while let Some(k) = map_.next_key()? {
4472 match k {
4473 GeneratedField::Reason => {
4474 if reason__.is_some() {
4475 return Err(serde::de::Error::duplicate_field("reason"));
4476 }
4477 reason__ = Some(map_.next_value()?);
4478 }
4479 GeneratedField::DurationSecs => {
4480 if duration_secs__.is_some() {
4481 return Err(serde::de::Error::duplicate_field("durationSecs"));
4482 }
4483 duration_secs__ =
4484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4485 ;
4486 }
4487 GeneratedField::RunningDatabaseIds => {
4488 if running_database_ids__.is_some() {
4489 return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4490 }
4491 running_database_ids__ =
4492 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4493 .into_iter().map(|x| x.0).collect())
4494 ;
4495 }
4496 GeneratedField::RecoveringDatabaseIds => {
4497 if recovering_database_ids__.is_some() {
4498 return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4499 }
4500 recovering_database_ids__ =
4501 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4502 .into_iter().map(|x| x.0).collect())
4503 ;
4504 }
4505 }
4506 }
4507 Ok(event_log::event_recovery::GlobalRecoverySuccess {
4508 reason: reason__.unwrap_or_default(),
4509 duration_secs: duration_secs__.unwrap_or_default(),
4510 running_database_ids: running_database_ids__.unwrap_or_default(),
4511 recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4512 })
4513 }
4514 }
4515 deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4516 }
4517}
4518impl serde::Serialize for event_log::EventSinkFail {
4519 #[allow(deprecated)]
4520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4521 where
4522 S: serde::Serializer,
4523 {
4524 use serde::ser::SerializeStruct;
4525 let mut len = 0;
4526 if self.sink_id != 0 {
4527 len += 1;
4528 }
4529 if !self.sink_name.is_empty() {
4530 len += 1;
4531 }
4532 if !self.connector.is_empty() {
4533 len += 1;
4534 }
4535 if !self.error.is_empty() {
4536 len += 1;
4537 }
4538 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4539 if self.sink_id != 0 {
4540 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4541 }
4542 if !self.sink_name.is_empty() {
4543 struct_ser.serialize_field("sinkName", &self.sink_name)?;
4544 }
4545 if !self.connector.is_empty() {
4546 struct_ser.serialize_field("connector", &self.connector)?;
4547 }
4548 if !self.error.is_empty() {
4549 struct_ser.serialize_field("error", &self.error)?;
4550 }
4551 struct_ser.end()
4552 }
4553}
4554impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4555 #[allow(deprecated)]
4556 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4557 where
4558 D: serde::Deserializer<'de>,
4559 {
4560 const FIELDS: &[&str] = &[
4561 "sink_id",
4562 "sinkId",
4563 "sink_name",
4564 "sinkName",
4565 "connector",
4566 "error",
4567 ];
4568
4569 #[allow(clippy::enum_variant_names)]
4570 enum GeneratedField {
4571 SinkId,
4572 SinkName,
4573 Connector,
4574 Error,
4575 }
4576 impl<'de> serde::Deserialize<'de> for GeneratedField {
4577 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4578 where
4579 D: serde::Deserializer<'de>,
4580 {
4581 struct GeneratedVisitor;
4582
4583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4584 type Value = GeneratedField;
4585
4586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4587 write!(formatter, "expected one of: {:?}", &FIELDS)
4588 }
4589
4590 #[allow(unused_variables)]
4591 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4592 where
4593 E: serde::de::Error,
4594 {
4595 match value {
4596 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4597 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4598 "connector" => Ok(GeneratedField::Connector),
4599 "error" => Ok(GeneratedField::Error),
4600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4601 }
4602 }
4603 }
4604 deserializer.deserialize_identifier(GeneratedVisitor)
4605 }
4606 }
4607 struct GeneratedVisitor;
4608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4609 type Value = event_log::EventSinkFail;
4610
4611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4612 formatter.write_str("struct meta.EventLog.EventSinkFail")
4613 }
4614
4615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4616 where
4617 V: serde::de::MapAccess<'de>,
4618 {
4619 let mut sink_id__ = None;
4620 let mut sink_name__ = None;
4621 let mut connector__ = None;
4622 let mut error__ = None;
4623 while let Some(k) = map_.next_key()? {
4624 match k {
4625 GeneratedField::SinkId => {
4626 if sink_id__.is_some() {
4627 return Err(serde::de::Error::duplicate_field("sinkId"));
4628 }
4629 sink_id__ =
4630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4631 ;
4632 }
4633 GeneratedField::SinkName => {
4634 if sink_name__.is_some() {
4635 return Err(serde::de::Error::duplicate_field("sinkName"));
4636 }
4637 sink_name__ = Some(map_.next_value()?);
4638 }
4639 GeneratedField::Connector => {
4640 if connector__.is_some() {
4641 return Err(serde::de::Error::duplicate_field("connector"));
4642 }
4643 connector__ = Some(map_.next_value()?);
4644 }
4645 GeneratedField::Error => {
4646 if error__.is_some() {
4647 return Err(serde::de::Error::duplicate_field("error"));
4648 }
4649 error__ = Some(map_.next_value()?);
4650 }
4651 }
4652 }
4653 Ok(event_log::EventSinkFail {
4654 sink_id: sink_id__.unwrap_or_default(),
4655 sink_name: sink_name__.unwrap_or_default(),
4656 connector: connector__.unwrap_or_default(),
4657 error: error__.unwrap_or_default(),
4658 })
4659 }
4660 }
4661 deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4662 }
4663}
4664impl serde::Serialize for event_log::EventWorkerNodePanic {
4665 #[allow(deprecated)]
4666 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4667 where
4668 S: serde::Serializer,
4669 {
4670 use serde::ser::SerializeStruct;
4671 let mut len = 0;
4672 if self.worker_id != 0 {
4673 len += 1;
4674 }
4675 if self.worker_type != 0 {
4676 len += 1;
4677 }
4678 if self.host_addr.is_some() {
4679 len += 1;
4680 }
4681 if !self.panic_info.is_empty() {
4682 len += 1;
4683 }
4684 let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4685 if self.worker_id != 0 {
4686 struct_ser.serialize_field("workerId", &self.worker_id)?;
4687 }
4688 if self.worker_type != 0 {
4689 let v = super::common::WorkerType::try_from(self.worker_type)
4690 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4691 struct_ser.serialize_field("workerType", &v)?;
4692 }
4693 if let Some(v) = self.host_addr.as_ref() {
4694 struct_ser.serialize_field("hostAddr", v)?;
4695 }
4696 if !self.panic_info.is_empty() {
4697 struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4698 }
4699 struct_ser.end()
4700 }
4701}
4702impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4703 #[allow(deprecated)]
4704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4705 where
4706 D: serde::Deserializer<'de>,
4707 {
4708 const FIELDS: &[&str] = &[
4709 "worker_id",
4710 "workerId",
4711 "worker_type",
4712 "workerType",
4713 "host_addr",
4714 "hostAddr",
4715 "panic_info",
4716 "panicInfo",
4717 ];
4718
4719 #[allow(clippy::enum_variant_names)]
4720 enum GeneratedField {
4721 WorkerId,
4722 WorkerType,
4723 HostAddr,
4724 PanicInfo,
4725 }
4726 impl<'de> serde::Deserialize<'de> for GeneratedField {
4727 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4728 where
4729 D: serde::Deserializer<'de>,
4730 {
4731 struct GeneratedVisitor;
4732
4733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4734 type Value = GeneratedField;
4735
4736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4737 write!(formatter, "expected one of: {:?}", &FIELDS)
4738 }
4739
4740 #[allow(unused_variables)]
4741 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4742 where
4743 E: serde::de::Error,
4744 {
4745 match value {
4746 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4747 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4748 "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4749 "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4750 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4751 }
4752 }
4753 }
4754 deserializer.deserialize_identifier(GeneratedVisitor)
4755 }
4756 }
4757 struct GeneratedVisitor;
4758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4759 type Value = event_log::EventWorkerNodePanic;
4760
4761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4762 formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4763 }
4764
4765 fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4766 where
4767 V: serde::de::MapAccess<'de>,
4768 {
4769 let mut worker_id__ = None;
4770 let mut worker_type__ = None;
4771 let mut host_addr__ = None;
4772 let mut panic_info__ = None;
4773 while let Some(k) = map_.next_key()? {
4774 match k {
4775 GeneratedField::WorkerId => {
4776 if worker_id__.is_some() {
4777 return Err(serde::de::Error::duplicate_field("workerId"));
4778 }
4779 worker_id__ =
4780 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4781 ;
4782 }
4783 GeneratedField::WorkerType => {
4784 if worker_type__.is_some() {
4785 return Err(serde::de::Error::duplicate_field("workerType"));
4786 }
4787 worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4788 }
4789 GeneratedField::HostAddr => {
4790 if host_addr__.is_some() {
4791 return Err(serde::de::Error::duplicate_field("hostAddr"));
4792 }
4793 host_addr__ = map_.next_value()?;
4794 }
4795 GeneratedField::PanicInfo => {
4796 if panic_info__.is_some() {
4797 return Err(serde::de::Error::duplicate_field("panicInfo"));
4798 }
4799 panic_info__ = Some(map_.next_value()?);
4800 }
4801 }
4802 }
4803 Ok(event_log::EventWorkerNodePanic {
4804 worker_id: worker_id__.unwrap_or_default(),
4805 worker_type: worker_type__.unwrap_or_default(),
4806 host_addr: host_addr__,
4807 panic_info: panic_info__.unwrap_or_default(),
4808 })
4809 }
4810 }
4811 deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4812 }
4813}
4814impl serde::Serialize for FlushRequest {
4815 #[allow(deprecated)]
4816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4817 where
4818 S: serde::Serializer,
4819 {
4820 use serde::ser::SerializeStruct;
4821 let mut len = 0;
4822 if self.database_id != 0 {
4823 len += 1;
4824 }
4825 let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4826 if self.database_id != 0 {
4827 struct_ser.serialize_field("databaseId", &self.database_id)?;
4828 }
4829 struct_ser.end()
4830 }
4831}
4832impl<'de> serde::Deserialize<'de> for FlushRequest {
4833 #[allow(deprecated)]
4834 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4835 where
4836 D: serde::Deserializer<'de>,
4837 {
4838 const FIELDS: &[&str] = &[
4839 "database_id",
4840 "databaseId",
4841 ];
4842
4843 #[allow(clippy::enum_variant_names)]
4844 enum GeneratedField {
4845 DatabaseId,
4846 }
4847 impl<'de> serde::Deserialize<'de> for GeneratedField {
4848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4849 where
4850 D: serde::Deserializer<'de>,
4851 {
4852 struct GeneratedVisitor;
4853
4854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4855 type Value = GeneratedField;
4856
4857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4858 write!(formatter, "expected one of: {:?}", &FIELDS)
4859 }
4860
4861 #[allow(unused_variables)]
4862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4863 where
4864 E: serde::de::Error,
4865 {
4866 match value {
4867 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4868 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4869 }
4870 }
4871 }
4872 deserializer.deserialize_identifier(GeneratedVisitor)
4873 }
4874 }
4875 struct GeneratedVisitor;
4876 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4877 type Value = FlushRequest;
4878
4879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4880 formatter.write_str("struct meta.FlushRequest")
4881 }
4882
4883 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
4884 where
4885 V: serde::de::MapAccess<'de>,
4886 {
4887 let mut database_id__ = None;
4888 while let Some(k) = map_.next_key()? {
4889 match k {
4890 GeneratedField::DatabaseId => {
4891 if database_id__.is_some() {
4892 return Err(serde::de::Error::duplicate_field("databaseId"));
4893 }
4894 database_id__ =
4895 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4896 ;
4897 }
4898 }
4899 }
4900 Ok(FlushRequest {
4901 database_id: database_id__.unwrap_or_default(),
4902 })
4903 }
4904 }
4905 deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
4906 }
4907}
4908impl serde::Serialize for FlushResponse {
4909 #[allow(deprecated)]
4910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4911 where
4912 S: serde::Serializer,
4913 {
4914 use serde::ser::SerializeStruct;
4915 let mut len = 0;
4916 if self.status.is_some() {
4917 len += 1;
4918 }
4919 if self.hummock_version_id != 0 {
4920 len += 1;
4921 }
4922 let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
4923 if let Some(v) = self.status.as_ref() {
4924 struct_ser.serialize_field("status", v)?;
4925 }
4926 if self.hummock_version_id != 0 {
4927 #[allow(clippy::needless_borrow)]
4928 #[allow(clippy::needless_borrows_for_generic_args)]
4929 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
4930 }
4931 struct_ser.end()
4932 }
4933}
4934impl<'de> serde::Deserialize<'de> for FlushResponse {
4935 #[allow(deprecated)]
4936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4937 where
4938 D: serde::Deserializer<'de>,
4939 {
4940 const FIELDS: &[&str] = &[
4941 "status",
4942 "hummock_version_id",
4943 "hummockVersionId",
4944 ];
4945
4946 #[allow(clippy::enum_variant_names)]
4947 enum GeneratedField {
4948 Status,
4949 HummockVersionId,
4950 }
4951 impl<'de> serde::Deserialize<'de> for GeneratedField {
4952 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4953 where
4954 D: serde::Deserializer<'de>,
4955 {
4956 struct GeneratedVisitor;
4957
4958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4959 type Value = GeneratedField;
4960
4961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4962 write!(formatter, "expected one of: {:?}", &FIELDS)
4963 }
4964
4965 #[allow(unused_variables)]
4966 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4967 where
4968 E: serde::de::Error,
4969 {
4970 match value {
4971 "status" => Ok(GeneratedField::Status),
4972 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
4973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4974 }
4975 }
4976 }
4977 deserializer.deserialize_identifier(GeneratedVisitor)
4978 }
4979 }
4980 struct GeneratedVisitor;
4981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4982 type Value = FlushResponse;
4983
4984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4985 formatter.write_str("struct meta.FlushResponse")
4986 }
4987
4988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
4989 where
4990 V: serde::de::MapAccess<'de>,
4991 {
4992 let mut status__ = None;
4993 let mut hummock_version_id__ = None;
4994 while let Some(k) = map_.next_key()? {
4995 match k {
4996 GeneratedField::Status => {
4997 if status__.is_some() {
4998 return Err(serde::de::Error::duplicate_field("status"));
4999 }
5000 status__ = map_.next_value()?;
5001 }
5002 GeneratedField::HummockVersionId => {
5003 if hummock_version_id__.is_some() {
5004 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5005 }
5006 hummock_version_id__ =
5007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5008 ;
5009 }
5010 }
5011 }
5012 Ok(FlushResponse {
5013 status: status__,
5014 hummock_version_id: hummock_version_id__.unwrap_or_default(),
5015 })
5016 }
5017 }
5018 deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5019 }
5020}
5021impl serde::Serialize for FragmentDistribution {
5022 #[allow(deprecated)]
5023 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5024 where
5025 S: serde::Serializer,
5026 {
5027 use serde::ser::SerializeStruct;
5028 let mut len = 0;
5029 if self.fragment_id != 0 {
5030 len += 1;
5031 }
5032 if self.table_id != 0 {
5033 len += 1;
5034 }
5035 if self.distribution_type != 0 {
5036 len += 1;
5037 }
5038 if !self.state_table_ids.is_empty() {
5039 len += 1;
5040 }
5041 if !self.upstream_fragment_ids.is_empty() {
5042 len += 1;
5043 }
5044 if self.fragment_type_mask != 0 {
5045 len += 1;
5046 }
5047 if self.parallelism != 0 {
5048 len += 1;
5049 }
5050 if self.vnode_count != 0 {
5051 len += 1;
5052 }
5053 if self.node.is_some() {
5054 len += 1;
5055 }
5056 let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5057 if self.fragment_id != 0 {
5058 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5059 }
5060 if self.table_id != 0 {
5061 struct_ser.serialize_field("tableId", &self.table_id)?;
5062 }
5063 if self.distribution_type != 0 {
5064 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5065 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5066 struct_ser.serialize_field("distributionType", &v)?;
5067 }
5068 if !self.state_table_ids.is_empty() {
5069 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5070 }
5071 if !self.upstream_fragment_ids.is_empty() {
5072 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5073 }
5074 if self.fragment_type_mask != 0 {
5075 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5076 }
5077 if self.parallelism != 0 {
5078 struct_ser.serialize_field("parallelism", &self.parallelism)?;
5079 }
5080 if self.vnode_count != 0 {
5081 struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5082 }
5083 if let Some(v) = self.node.as_ref() {
5084 struct_ser.serialize_field("node", v)?;
5085 }
5086 struct_ser.end()
5087 }
5088}
5089impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5090 #[allow(deprecated)]
5091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5092 where
5093 D: serde::Deserializer<'de>,
5094 {
5095 const FIELDS: &[&str] = &[
5096 "fragment_id",
5097 "fragmentId",
5098 "table_id",
5099 "tableId",
5100 "distribution_type",
5101 "distributionType",
5102 "state_table_ids",
5103 "stateTableIds",
5104 "upstream_fragment_ids",
5105 "upstreamFragmentIds",
5106 "fragment_type_mask",
5107 "fragmentTypeMask",
5108 "parallelism",
5109 "vnode_count",
5110 "vnodeCount",
5111 "node",
5112 ];
5113
5114 #[allow(clippy::enum_variant_names)]
5115 enum GeneratedField {
5116 FragmentId,
5117 TableId,
5118 DistributionType,
5119 StateTableIds,
5120 UpstreamFragmentIds,
5121 FragmentTypeMask,
5122 Parallelism,
5123 VnodeCount,
5124 Node,
5125 }
5126 impl<'de> serde::Deserialize<'de> for GeneratedField {
5127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5128 where
5129 D: serde::Deserializer<'de>,
5130 {
5131 struct GeneratedVisitor;
5132
5133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5134 type Value = GeneratedField;
5135
5136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5137 write!(formatter, "expected one of: {:?}", &FIELDS)
5138 }
5139
5140 #[allow(unused_variables)]
5141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5142 where
5143 E: serde::de::Error,
5144 {
5145 match value {
5146 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5147 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5148 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5149 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5150 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5151 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5152 "parallelism" => Ok(GeneratedField::Parallelism),
5153 "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5154 "node" => Ok(GeneratedField::Node),
5155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5156 }
5157 }
5158 }
5159 deserializer.deserialize_identifier(GeneratedVisitor)
5160 }
5161 }
5162 struct GeneratedVisitor;
5163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5164 type Value = FragmentDistribution;
5165
5166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5167 formatter.write_str("struct meta.FragmentDistribution")
5168 }
5169
5170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5171 where
5172 V: serde::de::MapAccess<'de>,
5173 {
5174 let mut fragment_id__ = None;
5175 let mut table_id__ = None;
5176 let mut distribution_type__ = None;
5177 let mut state_table_ids__ = None;
5178 let mut upstream_fragment_ids__ = None;
5179 let mut fragment_type_mask__ = None;
5180 let mut parallelism__ = None;
5181 let mut vnode_count__ = None;
5182 let mut node__ = None;
5183 while let Some(k) = map_.next_key()? {
5184 match k {
5185 GeneratedField::FragmentId => {
5186 if fragment_id__.is_some() {
5187 return Err(serde::de::Error::duplicate_field("fragmentId"));
5188 }
5189 fragment_id__ =
5190 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5191 ;
5192 }
5193 GeneratedField::TableId => {
5194 if table_id__.is_some() {
5195 return Err(serde::de::Error::duplicate_field("tableId"));
5196 }
5197 table_id__ =
5198 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5199 ;
5200 }
5201 GeneratedField::DistributionType => {
5202 if distribution_type__.is_some() {
5203 return Err(serde::de::Error::duplicate_field("distributionType"));
5204 }
5205 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5206 }
5207 GeneratedField::StateTableIds => {
5208 if state_table_ids__.is_some() {
5209 return Err(serde::de::Error::duplicate_field("stateTableIds"));
5210 }
5211 state_table_ids__ =
5212 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5213 .into_iter().map(|x| x.0).collect())
5214 ;
5215 }
5216 GeneratedField::UpstreamFragmentIds => {
5217 if upstream_fragment_ids__.is_some() {
5218 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5219 }
5220 upstream_fragment_ids__ =
5221 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5222 .into_iter().map(|x| x.0).collect())
5223 ;
5224 }
5225 GeneratedField::FragmentTypeMask => {
5226 if fragment_type_mask__.is_some() {
5227 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5228 }
5229 fragment_type_mask__ =
5230 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5231 ;
5232 }
5233 GeneratedField::Parallelism => {
5234 if parallelism__.is_some() {
5235 return Err(serde::de::Error::duplicate_field("parallelism"));
5236 }
5237 parallelism__ =
5238 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5239 ;
5240 }
5241 GeneratedField::VnodeCount => {
5242 if vnode_count__.is_some() {
5243 return Err(serde::de::Error::duplicate_field("vnodeCount"));
5244 }
5245 vnode_count__ =
5246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5247 ;
5248 }
5249 GeneratedField::Node => {
5250 if node__.is_some() {
5251 return Err(serde::de::Error::duplicate_field("node"));
5252 }
5253 node__ = map_.next_value()?;
5254 }
5255 }
5256 }
5257 Ok(FragmentDistribution {
5258 fragment_id: fragment_id__.unwrap_or_default(),
5259 table_id: table_id__.unwrap_or_default(),
5260 distribution_type: distribution_type__.unwrap_or_default(),
5261 state_table_ids: state_table_ids__.unwrap_or_default(),
5262 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5263 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5264 parallelism: parallelism__.unwrap_or_default(),
5265 vnode_count: vnode_count__.unwrap_or_default(),
5266 node: node__,
5267 })
5268 }
5269 }
5270 deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5271 }
5272}
5273impl serde::Serialize for FragmentIdToActorIdMap {
5274 #[allow(deprecated)]
5275 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5276 where
5277 S: serde::Serializer,
5278 {
5279 use serde::ser::SerializeStruct;
5280 let mut len = 0;
5281 if !self.map.is_empty() {
5282 len += 1;
5283 }
5284 let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5285 if !self.map.is_empty() {
5286 struct_ser.serialize_field("map", &self.map)?;
5287 }
5288 struct_ser.end()
5289 }
5290}
5291impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5292 #[allow(deprecated)]
5293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5294 where
5295 D: serde::Deserializer<'de>,
5296 {
5297 const FIELDS: &[&str] = &[
5298 "map",
5299 ];
5300
5301 #[allow(clippy::enum_variant_names)]
5302 enum GeneratedField {
5303 Map,
5304 }
5305 impl<'de> serde::Deserialize<'de> for GeneratedField {
5306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5307 where
5308 D: serde::Deserializer<'de>,
5309 {
5310 struct GeneratedVisitor;
5311
5312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5313 type Value = GeneratedField;
5314
5315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5316 write!(formatter, "expected one of: {:?}", &FIELDS)
5317 }
5318
5319 #[allow(unused_variables)]
5320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5321 where
5322 E: serde::de::Error,
5323 {
5324 match value {
5325 "map" => Ok(GeneratedField::Map),
5326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5327 }
5328 }
5329 }
5330 deserializer.deserialize_identifier(GeneratedVisitor)
5331 }
5332 }
5333 struct GeneratedVisitor;
5334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5335 type Value = FragmentIdToActorIdMap;
5336
5337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5338 formatter.write_str("struct meta.FragmentIdToActorIdMap")
5339 }
5340
5341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5342 where
5343 V: serde::de::MapAccess<'de>,
5344 {
5345 let mut map__ = None;
5346 while let Some(k) = map_.next_key()? {
5347 match k {
5348 GeneratedField::Map => {
5349 if map__.is_some() {
5350 return Err(serde::de::Error::duplicate_field("map"));
5351 }
5352 map__ = Some(
5353 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5354 .into_iter().map(|(k,v)| (k.0, v)).collect()
5355 );
5356 }
5357 }
5358 }
5359 Ok(FragmentIdToActorIdMap {
5360 map: map__.unwrap_or_default(),
5361 })
5362 }
5363 }
5364 deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5365 }
5366}
5367impl serde::Serialize for FragmentToRelationMap {
5368 #[allow(deprecated)]
5369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5370 where
5371 S: serde::Serializer,
5372 {
5373 use serde::ser::SerializeStruct;
5374 let mut len = 0;
5375 if !self.fragment_to_relation_map.is_empty() {
5376 len += 1;
5377 }
5378 let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5379 if !self.fragment_to_relation_map.is_empty() {
5380 struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5381 }
5382 struct_ser.end()
5383 }
5384}
5385impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5386 #[allow(deprecated)]
5387 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5388 where
5389 D: serde::Deserializer<'de>,
5390 {
5391 const FIELDS: &[&str] = &[
5392 "fragment_to_relation_map",
5393 "fragmentToRelationMap",
5394 ];
5395
5396 #[allow(clippy::enum_variant_names)]
5397 enum GeneratedField {
5398 FragmentToRelationMap,
5399 }
5400 impl<'de> serde::Deserialize<'de> for GeneratedField {
5401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5402 where
5403 D: serde::Deserializer<'de>,
5404 {
5405 struct GeneratedVisitor;
5406
5407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5408 type Value = GeneratedField;
5409
5410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5411 write!(formatter, "expected one of: {:?}", &FIELDS)
5412 }
5413
5414 #[allow(unused_variables)]
5415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5416 where
5417 E: serde::de::Error,
5418 {
5419 match value {
5420 "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5421 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5422 }
5423 }
5424 }
5425 deserializer.deserialize_identifier(GeneratedVisitor)
5426 }
5427 }
5428 struct GeneratedVisitor;
5429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5430 type Value = FragmentToRelationMap;
5431
5432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5433 formatter.write_str("struct meta.FragmentToRelationMap")
5434 }
5435
5436 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5437 where
5438 V: serde::de::MapAccess<'de>,
5439 {
5440 let mut fragment_to_relation_map__ = None;
5441 while let Some(k) = map_.next_key()? {
5442 match k {
5443 GeneratedField::FragmentToRelationMap => {
5444 if fragment_to_relation_map__.is_some() {
5445 return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5446 }
5447 fragment_to_relation_map__ = Some(
5448 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5449 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5450 );
5451 }
5452 }
5453 }
5454 Ok(FragmentToRelationMap {
5455 fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5456 })
5457 }
5458 }
5459 deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5460 }
5461}
5462impl serde::Serialize for FragmentWorkerSlotMapping {
5463 #[allow(deprecated)]
5464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5465 where
5466 S: serde::Serializer,
5467 {
5468 use serde::ser::SerializeStruct;
5469 let mut len = 0;
5470 if self.fragment_id != 0 {
5471 len += 1;
5472 }
5473 if self.mapping.is_some() {
5474 len += 1;
5475 }
5476 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5477 if self.fragment_id != 0 {
5478 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5479 }
5480 if let Some(v) = self.mapping.as_ref() {
5481 struct_ser.serialize_field("mapping", v)?;
5482 }
5483 struct_ser.end()
5484 }
5485}
5486impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5487 #[allow(deprecated)]
5488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5489 where
5490 D: serde::Deserializer<'de>,
5491 {
5492 const FIELDS: &[&str] = &[
5493 "fragment_id",
5494 "fragmentId",
5495 "mapping",
5496 ];
5497
5498 #[allow(clippy::enum_variant_names)]
5499 enum GeneratedField {
5500 FragmentId,
5501 Mapping,
5502 }
5503 impl<'de> serde::Deserialize<'de> for GeneratedField {
5504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5505 where
5506 D: serde::Deserializer<'de>,
5507 {
5508 struct GeneratedVisitor;
5509
5510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5511 type Value = GeneratedField;
5512
5513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5514 write!(formatter, "expected one of: {:?}", &FIELDS)
5515 }
5516
5517 #[allow(unused_variables)]
5518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5519 where
5520 E: serde::de::Error,
5521 {
5522 match value {
5523 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5524 "mapping" => Ok(GeneratedField::Mapping),
5525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5526 }
5527 }
5528 }
5529 deserializer.deserialize_identifier(GeneratedVisitor)
5530 }
5531 }
5532 struct GeneratedVisitor;
5533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5534 type Value = FragmentWorkerSlotMapping;
5535
5536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5537 formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5538 }
5539
5540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5541 where
5542 V: serde::de::MapAccess<'de>,
5543 {
5544 let mut fragment_id__ = None;
5545 let mut mapping__ = None;
5546 while let Some(k) = map_.next_key()? {
5547 match k {
5548 GeneratedField::FragmentId => {
5549 if fragment_id__.is_some() {
5550 return Err(serde::de::Error::duplicate_field("fragmentId"));
5551 }
5552 fragment_id__ =
5553 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5554 ;
5555 }
5556 GeneratedField::Mapping => {
5557 if mapping__.is_some() {
5558 return Err(serde::de::Error::duplicate_field("mapping"));
5559 }
5560 mapping__ = map_.next_value()?;
5561 }
5562 }
5563 }
5564 Ok(FragmentWorkerSlotMapping {
5565 fragment_id: fragment_id__.unwrap_or_default(),
5566 mapping: mapping__,
5567 })
5568 }
5569 }
5570 deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5571 }
5572}
5573impl serde::Serialize for FragmentWorkerSlotMappings {
5574 #[allow(deprecated)]
5575 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5576 where
5577 S: serde::Serializer,
5578 {
5579 use serde::ser::SerializeStruct;
5580 let mut len = 0;
5581 if !self.mappings.is_empty() {
5582 len += 1;
5583 }
5584 let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5585 if !self.mappings.is_empty() {
5586 struct_ser.serialize_field("mappings", &self.mappings)?;
5587 }
5588 struct_ser.end()
5589 }
5590}
5591impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5592 #[allow(deprecated)]
5593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5594 where
5595 D: serde::Deserializer<'de>,
5596 {
5597 const FIELDS: &[&str] = &[
5598 "mappings",
5599 ];
5600
5601 #[allow(clippy::enum_variant_names)]
5602 enum GeneratedField {
5603 Mappings,
5604 }
5605 impl<'de> serde::Deserialize<'de> for GeneratedField {
5606 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5607 where
5608 D: serde::Deserializer<'de>,
5609 {
5610 struct GeneratedVisitor;
5611
5612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5613 type Value = GeneratedField;
5614
5615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5616 write!(formatter, "expected one of: {:?}", &FIELDS)
5617 }
5618
5619 #[allow(unused_variables)]
5620 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5621 where
5622 E: serde::de::Error,
5623 {
5624 match value {
5625 "mappings" => Ok(GeneratedField::Mappings),
5626 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5627 }
5628 }
5629 }
5630 deserializer.deserialize_identifier(GeneratedVisitor)
5631 }
5632 }
5633 struct GeneratedVisitor;
5634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5635 type Value = FragmentWorkerSlotMappings;
5636
5637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5638 formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5639 }
5640
5641 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5642 where
5643 V: serde::de::MapAccess<'de>,
5644 {
5645 let mut mappings__ = None;
5646 while let Some(k) = map_.next_key()? {
5647 match k {
5648 GeneratedField::Mappings => {
5649 if mappings__.is_some() {
5650 return Err(serde::de::Error::duplicate_field("mappings"));
5651 }
5652 mappings__ = Some(map_.next_value()?);
5653 }
5654 }
5655 }
5656 Ok(FragmentWorkerSlotMappings {
5657 mappings: mappings__.unwrap_or_default(),
5658 })
5659 }
5660 }
5661 deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5662 }
5663}
5664impl serde::Serialize for GetClusterInfoRequest {
5665 #[allow(deprecated)]
5666 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5667 where
5668 S: serde::Serializer,
5669 {
5670 use serde::ser::SerializeStruct;
5671 let len = 0;
5672 let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5673 struct_ser.end()
5674 }
5675}
5676impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5677 #[allow(deprecated)]
5678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5679 where
5680 D: serde::Deserializer<'de>,
5681 {
5682 const FIELDS: &[&str] = &[
5683 ];
5684
5685 #[allow(clippy::enum_variant_names)]
5686 enum GeneratedField {
5687 }
5688 impl<'de> serde::Deserialize<'de> for GeneratedField {
5689 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5690 where
5691 D: serde::Deserializer<'de>,
5692 {
5693 struct GeneratedVisitor;
5694
5695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5696 type Value = GeneratedField;
5697
5698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5699 write!(formatter, "expected one of: {:?}", &FIELDS)
5700 }
5701
5702 #[allow(unused_variables)]
5703 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5704 where
5705 E: serde::de::Error,
5706 {
5707 Err(serde::de::Error::unknown_field(value, FIELDS))
5708 }
5709 }
5710 deserializer.deserialize_identifier(GeneratedVisitor)
5711 }
5712 }
5713 struct GeneratedVisitor;
5714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5715 type Value = GetClusterInfoRequest;
5716
5717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5718 formatter.write_str("struct meta.GetClusterInfoRequest")
5719 }
5720
5721 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5722 where
5723 V: serde::de::MapAccess<'de>,
5724 {
5725 while map_.next_key::<GeneratedField>()?.is_some() {
5726 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5727 }
5728 Ok(GetClusterInfoRequest {
5729 })
5730 }
5731 }
5732 deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5733 }
5734}
5735impl serde::Serialize for GetClusterInfoResponse {
5736 #[allow(deprecated)]
5737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5738 where
5739 S: serde::Serializer,
5740 {
5741 use serde::ser::SerializeStruct;
5742 let mut len = 0;
5743 if !self.worker_nodes.is_empty() {
5744 len += 1;
5745 }
5746 if !self.table_fragments.is_empty() {
5747 len += 1;
5748 }
5749 if !self.actor_splits.is_empty() {
5750 len += 1;
5751 }
5752 if !self.source_infos.is_empty() {
5753 len += 1;
5754 }
5755 if self.revision != 0 {
5756 len += 1;
5757 }
5758 let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5759 if !self.worker_nodes.is_empty() {
5760 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5761 }
5762 if !self.table_fragments.is_empty() {
5763 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5764 }
5765 if !self.actor_splits.is_empty() {
5766 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5767 }
5768 if !self.source_infos.is_empty() {
5769 struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5770 }
5771 if self.revision != 0 {
5772 #[allow(clippy::needless_borrow)]
5773 #[allow(clippy::needless_borrows_for_generic_args)]
5774 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5775 }
5776 struct_ser.end()
5777 }
5778}
5779impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5780 #[allow(deprecated)]
5781 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5782 where
5783 D: serde::Deserializer<'de>,
5784 {
5785 const FIELDS: &[&str] = &[
5786 "worker_nodes",
5787 "workerNodes",
5788 "table_fragments",
5789 "tableFragments",
5790 "actor_splits",
5791 "actorSplits",
5792 "source_infos",
5793 "sourceInfos",
5794 "revision",
5795 ];
5796
5797 #[allow(clippy::enum_variant_names)]
5798 enum GeneratedField {
5799 WorkerNodes,
5800 TableFragments,
5801 ActorSplits,
5802 SourceInfos,
5803 Revision,
5804 }
5805 impl<'de> serde::Deserialize<'de> for GeneratedField {
5806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5807 where
5808 D: serde::Deserializer<'de>,
5809 {
5810 struct GeneratedVisitor;
5811
5812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5813 type Value = GeneratedField;
5814
5815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5816 write!(formatter, "expected one of: {:?}", &FIELDS)
5817 }
5818
5819 #[allow(unused_variables)]
5820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5821 where
5822 E: serde::de::Error,
5823 {
5824 match value {
5825 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5826 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5827 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5828 "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5829 "revision" => Ok(GeneratedField::Revision),
5830 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5831 }
5832 }
5833 }
5834 deserializer.deserialize_identifier(GeneratedVisitor)
5835 }
5836 }
5837 struct GeneratedVisitor;
5838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5839 type Value = GetClusterInfoResponse;
5840
5841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5842 formatter.write_str("struct meta.GetClusterInfoResponse")
5843 }
5844
5845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5846 where
5847 V: serde::de::MapAccess<'de>,
5848 {
5849 let mut worker_nodes__ = None;
5850 let mut table_fragments__ = None;
5851 let mut actor_splits__ = None;
5852 let mut source_infos__ = None;
5853 let mut revision__ = None;
5854 while let Some(k) = map_.next_key()? {
5855 match k {
5856 GeneratedField::WorkerNodes => {
5857 if worker_nodes__.is_some() {
5858 return Err(serde::de::Error::duplicate_field("workerNodes"));
5859 }
5860 worker_nodes__ = Some(map_.next_value()?);
5861 }
5862 GeneratedField::TableFragments => {
5863 if table_fragments__.is_some() {
5864 return Err(serde::de::Error::duplicate_field("tableFragments"));
5865 }
5866 table_fragments__ = Some(map_.next_value()?);
5867 }
5868 GeneratedField::ActorSplits => {
5869 if actor_splits__.is_some() {
5870 return Err(serde::de::Error::duplicate_field("actorSplits"));
5871 }
5872 actor_splits__ = Some(
5873 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5874 .into_iter().map(|(k,v)| (k.0, v)).collect()
5875 );
5876 }
5877 GeneratedField::SourceInfos => {
5878 if source_infos__.is_some() {
5879 return Err(serde::de::Error::duplicate_field("sourceInfos"));
5880 }
5881 source_infos__ = Some(
5882 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5883 .into_iter().map(|(k,v)| (k.0, v)).collect()
5884 );
5885 }
5886 GeneratedField::Revision => {
5887 if revision__.is_some() {
5888 return Err(serde::de::Error::duplicate_field("revision"));
5889 }
5890 revision__ =
5891 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5892 ;
5893 }
5894 }
5895 }
5896 Ok(GetClusterInfoResponse {
5897 worker_nodes: worker_nodes__.unwrap_or_default(),
5898 table_fragments: table_fragments__.unwrap_or_default(),
5899 actor_splits: actor_splits__.unwrap_or_default(),
5900 source_infos: source_infos__.unwrap_or_default(),
5901 revision: revision__.unwrap_or_default(),
5902 })
5903 }
5904 }
5905 deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
5906 }
5907}
5908impl serde::Serialize for GetClusterLimitsRequest {
5909 #[allow(deprecated)]
5910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5911 where
5912 S: serde::Serializer,
5913 {
5914 use serde::ser::SerializeStruct;
5915 let len = 0;
5916 let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
5917 struct_ser.end()
5918 }
5919}
5920impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
5921 #[allow(deprecated)]
5922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5923 where
5924 D: serde::Deserializer<'de>,
5925 {
5926 const FIELDS: &[&str] = &[
5927 ];
5928
5929 #[allow(clippy::enum_variant_names)]
5930 enum GeneratedField {
5931 }
5932 impl<'de> serde::Deserialize<'de> for GeneratedField {
5933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5934 where
5935 D: serde::Deserializer<'de>,
5936 {
5937 struct GeneratedVisitor;
5938
5939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5940 type Value = GeneratedField;
5941
5942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5943 write!(formatter, "expected one of: {:?}", &FIELDS)
5944 }
5945
5946 #[allow(unused_variables)]
5947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5948 where
5949 E: serde::de::Error,
5950 {
5951 Err(serde::de::Error::unknown_field(value, FIELDS))
5952 }
5953 }
5954 deserializer.deserialize_identifier(GeneratedVisitor)
5955 }
5956 }
5957 struct GeneratedVisitor;
5958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5959 type Value = GetClusterLimitsRequest;
5960
5961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5962 formatter.write_str("struct meta.GetClusterLimitsRequest")
5963 }
5964
5965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
5966 where
5967 V: serde::de::MapAccess<'de>,
5968 {
5969 while map_.next_key::<GeneratedField>()?.is_some() {
5970 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5971 }
5972 Ok(GetClusterLimitsRequest {
5973 })
5974 }
5975 }
5976 deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
5977 }
5978}
5979impl serde::Serialize for GetClusterLimitsResponse {
5980 #[allow(deprecated)]
5981 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5982 where
5983 S: serde::Serializer,
5984 {
5985 use serde::ser::SerializeStruct;
5986 let mut len = 0;
5987 if !self.active_limits.is_empty() {
5988 len += 1;
5989 }
5990 let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
5991 if !self.active_limits.is_empty() {
5992 struct_ser.serialize_field("activeLimits", &self.active_limits)?;
5993 }
5994 struct_ser.end()
5995 }
5996}
5997impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
5998 #[allow(deprecated)]
5999 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6000 where
6001 D: serde::Deserializer<'de>,
6002 {
6003 const FIELDS: &[&str] = &[
6004 "active_limits",
6005 "activeLimits",
6006 ];
6007
6008 #[allow(clippy::enum_variant_names)]
6009 enum GeneratedField {
6010 ActiveLimits,
6011 }
6012 impl<'de> serde::Deserialize<'de> for GeneratedField {
6013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6014 where
6015 D: serde::Deserializer<'de>,
6016 {
6017 struct GeneratedVisitor;
6018
6019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6020 type Value = GeneratedField;
6021
6022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6023 write!(formatter, "expected one of: {:?}", &FIELDS)
6024 }
6025
6026 #[allow(unused_variables)]
6027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6028 where
6029 E: serde::de::Error,
6030 {
6031 match value {
6032 "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6034 }
6035 }
6036 }
6037 deserializer.deserialize_identifier(GeneratedVisitor)
6038 }
6039 }
6040 struct GeneratedVisitor;
6041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6042 type Value = GetClusterLimitsResponse;
6043
6044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6045 formatter.write_str("struct meta.GetClusterLimitsResponse")
6046 }
6047
6048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6049 where
6050 V: serde::de::MapAccess<'de>,
6051 {
6052 let mut active_limits__ = None;
6053 while let Some(k) = map_.next_key()? {
6054 match k {
6055 GeneratedField::ActiveLimits => {
6056 if active_limits__.is_some() {
6057 return Err(serde::de::Error::duplicate_field("activeLimits"));
6058 }
6059 active_limits__ = Some(map_.next_value()?);
6060 }
6061 }
6062 }
6063 Ok(GetClusterLimitsResponse {
6064 active_limits: active_limits__.unwrap_or_default(),
6065 })
6066 }
6067 }
6068 deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6069 }
6070}
6071impl serde::Serialize for GetClusterRecoveryStatusRequest {
6072 #[allow(deprecated)]
6073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6074 where
6075 S: serde::Serializer,
6076 {
6077 use serde::ser::SerializeStruct;
6078 let len = 0;
6079 let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6080 struct_ser.end()
6081 }
6082}
6083impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6084 #[allow(deprecated)]
6085 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6086 where
6087 D: serde::Deserializer<'de>,
6088 {
6089 const FIELDS: &[&str] = &[
6090 ];
6091
6092 #[allow(clippy::enum_variant_names)]
6093 enum GeneratedField {
6094 }
6095 impl<'de> serde::Deserialize<'de> for GeneratedField {
6096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6097 where
6098 D: serde::Deserializer<'de>,
6099 {
6100 struct GeneratedVisitor;
6101
6102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6103 type Value = GeneratedField;
6104
6105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6106 write!(formatter, "expected one of: {:?}", &FIELDS)
6107 }
6108
6109 #[allow(unused_variables)]
6110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6111 where
6112 E: serde::de::Error,
6113 {
6114 Err(serde::de::Error::unknown_field(value, FIELDS))
6115 }
6116 }
6117 deserializer.deserialize_identifier(GeneratedVisitor)
6118 }
6119 }
6120 struct GeneratedVisitor;
6121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6122 type Value = GetClusterRecoveryStatusRequest;
6123
6124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6125 formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6126 }
6127
6128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6129 where
6130 V: serde::de::MapAccess<'de>,
6131 {
6132 while map_.next_key::<GeneratedField>()?.is_some() {
6133 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6134 }
6135 Ok(GetClusterRecoveryStatusRequest {
6136 })
6137 }
6138 }
6139 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6140 }
6141}
6142impl serde::Serialize for GetClusterRecoveryStatusResponse {
6143 #[allow(deprecated)]
6144 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6145 where
6146 S: serde::Serializer,
6147 {
6148 use serde::ser::SerializeStruct;
6149 let mut len = 0;
6150 if self.status != 0 {
6151 len += 1;
6152 }
6153 let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6154 if self.status != 0 {
6155 let v = RecoveryStatus::try_from(self.status)
6156 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6157 struct_ser.serialize_field("status", &v)?;
6158 }
6159 struct_ser.end()
6160 }
6161}
6162impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6163 #[allow(deprecated)]
6164 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6165 where
6166 D: serde::Deserializer<'de>,
6167 {
6168 const FIELDS: &[&str] = &[
6169 "status",
6170 ];
6171
6172 #[allow(clippy::enum_variant_names)]
6173 enum GeneratedField {
6174 Status,
6175 }
6176 impl<'de> serde::Deserialize<'de> for GeneratedField {
6177 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6178 where
6179 D: serde::Deserializer<'de>,
6180 {
6181 struct GeneratedVisitor;
6182
6183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6184 type Value = GeneratedField;
6185
6186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6187 write!(formatter, "expected one of: {:?}", &FIELDS)
6188 }
6189
6190 #[allow(unused_variables)]
6191 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6192 where
6193 E: serde::de::Error,
6194 {
6195 match value {
6196 "status" => Ok(GeneratedField::Status),
6197 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6198 }
6199 }
6200 }
6201 deserializer.deserialize_identifier(GeneratedVisitor)
6202 }
6203 }
6204 struct GeneratedVisitor;
6205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6206 type Value = GetClusterRecoveryStatusResponse;
6207
6208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6209 formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6210 }
6211
6212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6213 where
6214 V: serde::de::MapAccess<'de>,
6215 {
6216 let mut status__ = None;
6217 while let Some(k) = map_.next_key()? {
6218 match k {
6219 GeneratedField::Status => {
6220 if status__.is_some() {
6221 return Err(serde::de::Error::duplicate_field("status"));
6222 }
6223 status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6224 }
6225 }
6226 }
6227 Ok(GetClusterRecoveryStatusResponse {
6228 status: status__.unwrap_or_default(),
6229 })
6230 }
6231 }
6232 deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6233 }
6234}
6235impl serde::Serialize for GetFragmentByIdRequest {
6236 #[allow(deprecated)]
6237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6238 where
6239 S: serde::Serializer,
6240 {
6241 use serde::ser::SerializeStruct;
6242 let mut len = 0;
6243 if self.fragment_id != 0 {
6244 len += 1;
6245 }
6246 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6247 if self.fragment_id != 0 {
6248 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6249 }
6250 struct_ser.end()
6251 }
6252}
6253impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6254 #[allow(deprecated)]
6255 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6256 where
6257 D: serde::Deserializer<'de>,
6258 {
6259 const FIELDS: &[&str] = &[
6260 "fragment_id",
6261 "fragmentId",
6262 ];
6263
6264 #[allow(clippy::enum_variant_names)]
6265 enum GeneratedField {
6266 FragmentId,
6267 }
6268 impl<'de> serde::Deserialize<'de> for GeneratedField {
6269 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6270 where
6271 D: serde::Deserializer<'de>,
6272 {
6273 struct GeneratedVisitor;
6274
6275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6276 type Value = GeneratedField;
6277
6278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6279 write!(formatter, "expected one of: {:?}", &FIELDS)
6280 }
6281
6282 #[allow(unused_variables)]
6283 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6284 where
6285 E: serde::de::Error,
6286 {
6287 match value {
6288 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6290 }
6291 }
6292 }
6293 deserializer.deserialize_identifier(GeneratedVisitor)
6294 }
6295 }
6296 struct GeneratedVisitor;
6297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6298 type Value = GetFragmentByIdRequest;
6299
6300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6301 formatter.write_str("struct meta.GetFragmentByIdRequest")
6302 }
6303
6304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6305 where
6306 V: serde::de::MapAccess<'de>,
6307 {
6308 let mut fragment_id__ = None;
6309 while let Some(k) = map_.next_key()? {
6310 match k {
6311 GeneratedField::FragmentId => {
6312 if fragment_id__.is_some() {
6313 return Err(serde::de::Error::duplicate_field("fragmentId"));
6314 }
6315 fragment_id__ =
6316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6317 ;
6318 }
6319 }
6320 }
6321 Ok(GetFragmentByIdRequest {
6322 fragment_id: fragment_id__.unwrap_or_default(),
6323 })
6324 }
6325 }
6326 deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6327 }
6328}
6329impl serde::Serialize for GetFragmentByIdResponse {
6330 #[allow(deprecated)]
6331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6332 where
6333 S: serde::Serializer,
6334 {
6335 use serde::ser::SerializeStruct;
6336 let mut len = 0;
6337 if self.distribution.is_some() {
6338 len += 1;
6339 }
6340 let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6341 if let Some(v) = self.distribution.as_ref() {
6342 struct_ser.serialize_field("distribution", v)?;
6343 }
6344 struct_ser.end()
6345 }
6346}
6347impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6348 #[allow(deprecated)]
6349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6350 where
6351 D: serde::Deserializer<'de>,
6352 {
6353 const FIELDS: &[&str] = &[
6354 "distribution",
6355 ];
6356
6357 #[allow(clippy::enum_variant_names)]
6358 enum GeneratedField {
6359 Distribution,
6360 }
6361 impl<'de> serde::Deserialize<'de> for GeneratedField {
6362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6363 where
6364 D: serde::Deserializer<'de>,
6365 {
6366 struct GeneratedVisitor;
6367
6368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6369 type Value = GeneratedField;
6370
6371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6372 write!(formatter, "expected one of: {:?}", &FIELDS)
6373 }
6374
6375 #[allow(unused_variables)]
6376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6377 where
6378 E: serde::de::Error,
6379 {
6380 match value {
6381 "distribution" => Ok(GeneratedField::Distribution),
6382 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6383 }
6384 }
6385 }
6386 deserializer.deserialize_identifier(GeneratedVisitor)
6387 }
6388 }
6389 struct GeneratedVisitor;
6390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6391 type Value = GetFragmentByIdResponse;
6392
6393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6394 formatter.write_str("struct meta.GetFragmentByIdResponse")
6395 }
6396
6397 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6398 where
6399 V: serde::de::MapAccess<'de>,
6400 {
6401 let mut distribution__ = None;
6402 while let Some(k) = map_.next_key()? {
6403 match k {
6404 GeneratedField::Distribution => {
6405 if distribution__.is_some() {
6406 return Err(serde::de::Error::duplicate_field("distribution"));
6407 }
6408 distribution__ = map_.next_value()?;
6409 }
6410 }
6411 }
6412 Ok(GetFragmentByIdResponse {
6413 distribution: distribution__,
6414 })
6415 }
6416 }
6417 deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6418 }
6419}
6420impl serde::Serialize for GetMetaStoreInfoRequest {
6421 #[allow(deprecated)]
6422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6423 where
6424 S: serde::Serializer,
6425 {
6426 use serde::ser::SerializeStruct;
6427 let len = 0;
6428 let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6429 struct_ser.end()
6430 }
6431}
6432impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6433 #[allow(deprecated)]
6434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6435 where
6436 D: serde::Deserializer<'de>,
6437 {
6438 const FIELDS: &[&str] = &[
6439 ];
6440
6441 #[allow(clippy::enum_variant_names)]
6442 enum GeneratedField {
6443 }
6444 impl<'de> serde::Deserialize<'de> for GeneratedField {
6445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6446 where
6447 D: serde::Deserializer<'de>,
6448 {
6449 struct GeneratedVisitor;
6450
6451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6452 type Value = GeneratedField;
6453
6454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6455 write!(formatter, "expected one of: {:?}", &FIELDS)
6456 }
6457
6458 #[allow(unused_variables)]
6459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6460 where
6461 E: serde::de::Error,
6462 {
6463 Err(serde::de::Error::unknown_field(value, FIELDS))
6464 }
6465 }
6466 deserializer.deserialize_identifier(GeneratedVisitor)
6467 }
6468 }
6469 struct GeneratedVisitor;
6470 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6471 type Value = GetMetaStoreInfoRequest;
6472
6473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6474 formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6475 }
6476
6477 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6478 where
6479 V: serde::de::MapAccess<'de>,
6480 {
6481 while map_.next_key::<GeneratedField>()?.is_some() {
6482 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6483 }
6484 Ok(GetMetaStoreInfoRequest {
6485 })
6486 }
6487 }
6488 deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6489 }
6490}
6491impl serde::Serialize for GetMetaStoreInfoResponse {
6492 #[allow(deprecated)]
6493 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6494 where
6495 S: serde::Serializer,
6496 {
6497 use serde::ser::SerializeStruct;
6498 let mut len = 0;
6499 if !self.meta_store_endpoint.is_empty() {
6500 len += 1;
6501 }
6502 let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6503 if !self.meta_store_endpoint.is_empty() {
6504 struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6505 }
6506 struct_ser.end()
6507 }
6508}
6509impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6510 #[allow(deprecated)]
6511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6512 where
6513 D: serde::Deserializer<'de>,
6514 {
6515 const FIELDS: &[&str] = &[
6516 "meta_store_endpoint",
6517 "metaStoreEndpoint",
6518 ];
6519
6520 #[allow(clippy::enum_variant_names)]
6521 enum GeneratedField {
6522 MetaStoreEndpoint,
6523 }
6524 impl<'de> serde::Deserialize<'de> for GeneratedField {
6525 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6526 where
6527 D: serde::Deserializer<'de>,
6528 {
6529 struct GeneratedVisitor;
6530
6531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6532 type Value = GeneratedField;
6533
6534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6535 write!(formatter, "expected one of: {:?}", &FIELDS)
6536 }
6537
6538 #[allow(unused_variables)]
6539 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6540 where
6541 E: serde::de::Error,
6542 {
6543 match value {
6544 "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6545 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6546 }
6547 }
6548 }
6549 deserializer.deserialize_identifier(GeneratedVisitor)
6550 }
6551 }
6552 struct GeneratedVisitor;
6553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6554 type Value = GetMetaStoreInfoResponse;
6555
6556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6557 formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6558 }
6559
6560 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6561 where
6562 V: serde::de::MapAccess<'de>,
6563 {
6564 let mut meta_store_endpoint__ = None;
6565 while let Some(k) = map_.next_key()? {
6566 match k {
6567 GeneratedField::MetaStoreEndpoint => {
6568 if meta_store_endpoint__.is_some() {
6569 return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6570 }
6571 meta_store_endpoint__ = Some(map_.next_value()?);
6572 }
6573 }
6574 }
6575 Ok(GetMetaStoreInfoResponse {
6576 meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6577 })
6578 }
6579 }
6580 deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6581 }
6582}
6583impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6584 #[allow(deprecated)]
6585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6586 where
6587 S: serde::Serializer,
6588 {
6589 use serde::ser::SerializeStruct;
6590 let len = 0;
6591 let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6592 struct_ser.end()
6593 }
6594}
6595impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6596 #[allow(deprecated)]
6597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6598 where
6599 D: serde::Deserializer<'de>,
6600 {
6601 const FIELDS: &[&str] = &[
6602 ];
6603
6604 #[allow(clippy::enum_variant_names)]
6605 enum GeneratedField {
6606 }
6607 impl<'de> serde::Deserialize<'de> for GeneratedField {
6608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6609 where
6610 D: serde::Deserializer<'de>,
6611 {
6612 struct GeneratedVisitor;
6613
6614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6615 type Value = GeneratedField;
6616
6617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6618 write!(formatter, "expected one of: {:?}", &FIELDS)
6619 }
6620
6621 #[allow(unused_variables)]
6622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6623 where
6624 E: serde::de::Error,
6625 {
6626 Err(serde::de::Error::unknown_field(value, FIELDS))
6627 }
6628 }
6629 deserializer.deserialize_identifier(GeneratedVisitor)
6630 }
6631 }
6632 struct GeneratedVisitor;
6633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6634 type Value = GetServerlessStreamingJobsStatusRequest;
6635
6636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6637 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6638 }
6639
6640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6641 where
6642 V: serde::de::MapAccess<'de>,
6643 {
6644 while map_.next_key::<GeneratedField>()?.is_some() {
6645 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6646 }
6647 Ok(GetServerlessStreamingJobsStatusRequest {
6648 })
6649 }
6650 }
6651 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6652 }
6653}
6654impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6655 #[allow(deprecated)]
6656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6657 where
6658 S: serde::Serializer,
6659 {
6660 use serde::ser::SerializeStruct;
6661 let mut len = 0;
6662 if !self.streaming_job_statuses.is_empty() {
6663 len += 1;
6664 }
6665 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6666 if !self.streaming_job_statuses.is_empty() {
6667 struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6668 }
6669 struct_ser.end()
6670 }
6671}
6672impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6673 #[allow(deprecated)]
6674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6675 where
6676 D: serde::Deserializer<'de>,
6677 {
6678 const FIELDS: &[&str] = &[
6679 "streaming_job_statuses",
6680 "streamingJobStatuses",
6681 ];
6682
6683 #[allow(clippy::enum_variant_names)]
6684 enum GeneratedField {
6685 StreamingJobStatuses,
6686 }
6687 impl<'de> serde::Deserialize<'de> for GeneratedField {
6688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6689 where
6690 D: serde::Deserializer<'de>,
6691 {
6692 struct GeneratedVisitor;
6693
6694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6695 type Value = GeneratedField;
6696
6697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6698 write!(formatter, "expected one of: {:?}", &FIELDS)
6699 }
6700
6701 #[allow(unused_variables)]
6702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6703 where
6704 E: serde::de::Error,
6705 {
6706 match value {
6707 "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6709 }
6710 }
6711 }
6712 deserializer.deserialize_identifier(GeneratedVisitor)
6713 }
6714 }
6715 struct GeneratedVisitor;
6716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6717 type Value = GetServerlessStreamingJobsStatusResponse;
6718
6719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6720 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6721 }
6722
6723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6724 where
6725 V: serde::de::MapAccess<'de>,
6726 {
6727 let mut streaming_job_statuses__ = None;
6728 while let Some(k) = map_.next_key()? {
6729 match k {
6730 GeneratedField::StreamingJobStatuses => {
6731 if streaming_job_statuses__.is_some() {
6732 return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6733 }
6734 streaming_job_statuses__ = Some(map_.next_value()?);
6735 }
6736 }
6737 }
6738 Ok(GetServerlessStreamingJobsStatusResponse {
6739 streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6740 })
6741 }
6742 }
6743 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6744 }
6745}
6746impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6747 #[allow(deprecated)]
6748 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6749 where
6750 S: serde::Serializer,
6751 {
6752 use serde::ser::SerializeStruct;
6753 let mut len = 0;
6754 if self.table_id != 0 {
6755 len += 1;
6756 }
6757 if !self.node_label.is_empty() {
6758 len += 1;
6759 }
6760 if self.backfill_done {
6761 len += 1;
6762 }
6763 let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6764 if self.table_id != 0 {
6765 struct_ser.serialize_field("tableId", &self.table_id)?;
6766 }
6767 if !self.node_label.is_empty() {
6768 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6769 }
6770 if self.backfill_done {
6771 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6772 }
6773 struct_ser.end()
6774 }
6775}
6776impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6777 #[allow(deprecated)]
6778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6779 where
6780 D: serde::Deserializer<'de>,
6781 {
6782 const FIELDS: &[&str] = &[
6783 "table_id",
6784 "tableId",
6785 "node_label",
6786 "nodeLabel",
6787 "backfill_done",
6788 "backfillDone",
6789 ];
6790
6791 #[allow(clippy::enum_variant_names)]
6792 enum GeneratedField {
6793 TableId,
6794 NodeLabel,
6795 BackfillDone,
6796 }
6797 impl<'de> serde::Deserialize<'de> for GeneratedField {
6798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6799 where
6800 D: serde::Deserializer<'de>,
6801 {
6802 struct GeneratedVisitor;
6803
6804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6805 type Value = GeneratedField;
6806
6807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6808 write!(formatter, "expected one of: {:?}", &FIELDS)
6809 }
6810
6811 #[allow(unused_variables)]
6812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6813 where
6814 E: serde::de::Error,
6815 {
6816 match value {
6817 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6818 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6819 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6820 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6821 }
6822 }
6823 }
6824 deserializer.deserialize_identifier(GeneratedVisitor)
6825 }
6826 }
6827 struct GeneratedVisitor;
6828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6829 type Value = get_serverless_streaming_jobs_status_response::Status;
6830
6831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6832 formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6833 }
6834
6835 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6836 where
6837 V: serde::de::MapAccess<'de>,
6838 {
6839 let mut table_id__ = None;
6840 let mut node_label__ = None;
6841 let mut backfill_done__ = None;
6842 while let Some(k) = map_.next_key()? {
6843 match k {
6844 GeneratedField::TableId => {
6845 if table_id__.is_some() {
6846 return Err(serde::de::Error::duplicate_field("tableId"));
6847 }
6848 table_id__ =
6849 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6850 ;
6851 }
6852 GeneratedField::NodeLabel => {
6853 if node_label__.is_some() {
6854 return Err(serde::de::Error::duplicate_field("nodeLabel"));
6855 }
6856 node_label__ = Some(map_.next_value()?);
6857 }
6858 GeneratedField::BackfillDone => {
6859 if backfill_done__.is_some() {
6860 return Err(serde::de::Error::duplicate_field("backfillDone"));
6861 }
6862 backfill_done__ = Some(map_.next_value()?);
6863 }
6864 }
6865 }
6866 Ok(get_serverless_streaming_jobs_status_response::Status {
6867 table_id: table_id__.unwrap_or_default(),
6868 node_label: node_label__.unwrap_or_default(),
6869 backfill_done: backfill_done__.unwrap_or_default(),
6870 })
6871 }
6872 }
6873 deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
6874 }
6875}
6876impl serde::Serialize for GetServingVnodeMappingsRequest {
6877 #[allow(deprecated)]
6878 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6879 where
6880 S: serde::Serializer,
6881 {
6882 use serde::ser::SerializeStruct;
6883 let len = 0;
6884 let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
6885 struct_ser.end()
6886 }
6887}
6888impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
6889 #[allow(deprecated)]
6890 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6891 where
6892 D: serde::Deserializer<'de>,
6893 {
6894 const FIELDS: &[&str] = &[
6895 ];
6896
6897 #[allow(clippy::enum_variant_names)]
6898 enum GeneratedField {
6899 }
6900 impl<'de> serde::Deserialize<'de> for GeneratedField {
6901 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6902 where
6903 D: serde::Deserializer<'de>,
6904 {
6905 struct GeneratedVisitor;
6906
6907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6908 type Value = GeneratedField;
6909
6910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6911 write!(formatter, "expected one of: {:?}", &FIELDS)
6912 }
6913
6914 #[allow(unused_variables)]
6915 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6916 where
6917 E: serde::de::Error,
6918 {
6919 Err(serde::de::Error::unknown_field(value, FIELDS))
6920 }
6921 }
6922 deserializer.deserialize_identifier(GeneratedVisitor)
6923 }
6924 }
6925 struct GeneratedVisitor;
6926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6927 type Value = GetServingVnodeMappingsRequest;
6928
6929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6930 formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
6931 }
6932
6933 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
6934 where
6935 V: serde::de::MapAccess<'de>,
6936 {
6937 while map_.next_key::<GeneratedField>()?.is_some() {
6938 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6939 }
6940 Ok(GetServingVnodeMappingsRequest {
6941 })
6942 }
6943 }
6944 deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
6945 }
6946}
6947impl serde::Serialize for GetServingVnodeMappingsResponse {
6948 #[allow(deprecated)]
6949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6950 where
6951 S: serde::Serializer,
6952 {
6953 use serde::ser::SerializeStruct;
6954 let mut len = 0;
6955 if !self.fragment_to_table.is_empty() {
6956 len += 1;
6957 }
6958 if !self.worker_slot_mappings.is_empty() {
6959 len += 1;
6960 }
6961 let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
6962 if !self.fragment_to_table.is_empty() {
6963 struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
6964 }
6965 if !self.worker_slot_mappings.is_empty() {
6966 struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
6967 }
6968 struct_ser.end()
6969 }
6970}
6971impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
6972 #[allow(deprecated)]
6973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6974 where
6975 D: serde::Deserializer<'de>,
6976 {
6977 const FIELDS: &[&str] = &[
6978 "fragment_to_table",
6979 "fragmentToTable",
6980 "worker_slot_mappings",
6981 "workerSlotMappings",
6982 ];
6983
6984 #[allow(clippy::enum_variant_names)]
6985 enum GeneratedField {
6986 FragmentToTable,
6987 WorkerSlotMappings,
6988 }
6989 impl<'de> serde::Deserialize<'de> for GeneratedField {
6990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6991 where
6992 D: serde::Deserializer<'de>,
6993 {
6994 struct GeneratedVisitor;
6995
6996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6997 type Value = GeneratedField;
6998
6999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7000 write!(formatter, "expected one of: {:?}", &FIELDS)
7001 }
7002
7003 #[allow(unused_variables)]
7004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7005 where
7006 E: serde::de::Error,
7007 {
7008 match value {
7009 "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7010 "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7011 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7012 }
7013 }
7014 }
7015 deserializer.deserialize_identifier(GeneratedVisitor)
7016 }
7017 }
7018 struct GeneratedVisitor;
7019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7020 type Value = GetServingVnodeMappingsResponse;
7021
7022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7023 formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7024 }
7025
7026 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7027 where
7028 V: serde::de::MapAccess<'de>,
7029 {
7030 let mut fragment_to_table__ = None;
7031 let mut worker_slot_mappings__ = None;
7032 while let Some(k) = map_.next_key()? {
7033 match k {
7034 GeneratedField::FragmentToTable => {
7035 if fragment_to_table__.is_some() {
7036 return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7037 }
7038 fragment_to_table__ = Some(
7039 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7040 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7041 );
7042 }
7043 GeneratedField::WorkerSlotMappings => {
7044 if worker_slot_mappings__.is_some() {
7045 return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7046 }
7047 worker_slot_mappings__ = Some(map_.next_value()?);
7048 }
7049 }
7050 }
7051 Ok(GetServingVnodeMappingsResponse {
7052 fragment_to_table: fragment_to_table__.unwrap_or_default(),
7053 worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7054 })
7055 }
7056 }
7057 deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7058 }
7059}
7060impl serde::Serialize for GetSessionParamsRequest {
7061 #[allow(deprecated)]
7062 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7063 where
7064 S: serde::Serializer,
7065 {
7066 use serde::ser::SerializeStruct;
7067 let len = 0;
7068 let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7069 struct_ser.end()
7070 }
7071}
7072impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7073 #[allow(deprecated)]
7074 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7075 where
7076 D: serde::Deserializer<'de>,
7077 {
7078 const FIELDS: &[&str] = &[
7079 ];
7080
7081 #[allow(clippy::enum_variant_names)]
7082 enum GeneratedField {
7083 }
7084 impl<'de> serde::Deserialize<'de> for GeneratedField {
7085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7086 where
7087 D: serde::Deserializer<'de>,
7088 {
7089 struct GeneratedVisitor;
7090
7091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7092 type Value = GeneratedField;
7093
7094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7095 write!(formatter, "expected one of: {:?}", &FIELDS)
7096 }
7097
7098 #[allow(unused_variables)]
7099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7100 where
7101 E: serde::de::Error,
7102 {
7103 Err(serde::de::Error::unknown_field(value, FIELDS))
7104 }
7105 }
7106 deserializer.deserialize_identifier(GeneratedVisitor)
7107 }
7108 }
7109 struct GeneratedVisitor;
7110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7111 type Value = GetSessionParamsRequest;
7112
7113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7114 formatter.write_str("struct meta.GetSessionParamsRequest")
7115 }
7116
7117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7118 where
7119 V: serde::de::MapAccess<'de>,
7120 {
7121 while map_.next_key::<GeneratedField>()?.is_some() {
7122 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7123 }
7124 Ok(GetSessionParamsRequest {
7125 })
7126 }
7127 }
7128 deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7129 }
7130}
7131impl serde::Serialize for GetSessionParamsResponse {
7132 #[allow(deprecated)]
7133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7134 where
7135 S: serde::Serializer,
7136 {
7137 use serde::ser::SerializeStruct;
7138 let mut len = 0;
7139 if !self.params.is_empty() {
7140 len += 1;
7141 }
7142 let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7143 if !self.params.is_empty() {
7144 struct_ser.serialize_field("params", &self.params)?;
7145 }
7146 struct_ser.end()
7147 }
7148}
7149impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7150 #[allow(deprecated)]
7151 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7152 where
7153 D: serde::Deserializer<'de>,
7154 {
7155 const FIELDS: &[&str] = &[
7156 "params",
7157 ];
7158
7159 #[allow(clippy::enum_variant_names)]
7160 enum GeneratedField {
7161 Params,
7162 }
7163 impl<'de> serde::Deserialize<'de> for GeneratedField {
7164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7165 where
7166 D: serde::Deserializer<'de>,
7167 {
7168 struct GeneratedVisitor;
7169
7170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7171 type Value = GeneratedField;
7172
7173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7174 write!(formatter, "expected one of: {:?}", &FIELDS)
7175 }
7176
7177 #[allow(unused_variables)]
7178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7179 where
7180 E: serde::de::Error,
7181 {
7182 match value {
7183 "params" => Ok(GeneratedField::Params),
7184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7185 }
7186 }
7187 }
7188 deserializer.deserialize_identifier(GeneratedVisitor)
7189 }
7190 }
7191 struct GeneratedVisitor;
7192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7193 type Value = GetSessionParamsResponse;
7194
7195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7196 formatter.write_str("struct meta.GetSessionParamsResponse")
7197 }
7198
7199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7200 where
7201 V: serde::de::MapAccess<'de>,
7202 {
7203 let mut params__ = None;
7204 while let Some(k) = map_.next_key()? {
7205 match k {
7206 GeneratedField::Params => {
7207 if params__.is_some() {
7208 return Err(serde::de::Error::duplicate_field("params"));
7209 }
7210 params__ = Some(map_.next_value()?);
7211 }
7212 }
7213 }
7214 Ok(GetSessionParamsResponse {
7215 params: params__.unwrap_or_default(),
7216 })
7217 }
7218 }
7219 deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7220 }
7221}
7222impl serde::Serialize for GetSystemParamsRequest {
7223 #[allow(deprecated)]
7224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7225 where
7226 S: serde::Serializer,
7227 {
7228 use serde::ser::SerializeStruct;
7229 let len = 0;
7230 let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7231 struct_ser.end()
7232 }
7233}
7234impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7235 #[allow(deprecated)]
7236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7237 where
7238 D: serde::Deserializer<'de>,
7239 {
7240 const FIELDS: &[&str] = &[
7241 ];
7242
7243 #[allow(clippy::enum_variant_names)]
7244 enum GeneratedField {
7245 }
7246 impl<'de> serde::Deserialize<'de> for GeneratedField {
7247 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7248 where
7249 D: serde::Deserializer<'de>,
7250 {
7251 struct GeneratedVisitor;
7252
7253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7254 type Value = GeneratedField;
7255
7256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7257 write!(formatter, "expected one of: {:?}", &FIELDS)
7258 }
7259
7260 #[allow(unused_variables)]
7261 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7262 where
7263 E: serde::de::Error,
7264 {
7265 Err(serde::de::Error::unknown_field(value, FIELDS))
7266 }
7267 }
7268 deserializer.deserialize_identifier(GeneratedVisitor)
7269 }
7270 }
7271 struct GeneratedVisitor;
7272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7273 type Value = GetSystemParamsRequest;
7274
7275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7276 formatter.write_str("struct meta.GetSystemParamsRequest")
7277 }
7278
7279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7280 where
7281 V: serde::de::MapAccess<'de>,
7282 {
7283 while map_.next_key::<GeneratedField>()?.is_some() {
7284 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7285 }
7286 Ok(GetSystemParamsRequest {
7287 })
7288 }
7289 }
7290 deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7291 }
7292}
7293impl serde::Serialize for GetSystemParamsResponse {
7294 #[allow(deprecated)]
7295 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7296 where
7297 S: serde::Serializer,
7298 {
7299 use serde::ser::SerializeStruct;
7300 let mut len = 0;
7301 if self.params.is_some() {
7302 len += 1;
7303 }
7304 let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7305 if let Some(v) = self.params.as_ref() {
7306 struct_ser.serialize_field("params", v)?;
7307 }
7308 struct_ser.end()
7309 }
7310}
7311impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7312 #[allow(deprecated)]
7313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7314 where
7315 D: serde::Deserializer<'de>,
7316 {
7317 const FIELDS: &[&str] = &[
7318 "params",
7319 ];
7320
7321 #[allow(clippy::enum_variant_names)]
7322 enum GeneratedField {
7323 Params,
7324 }
7325 impl<'de> serde::Deserialize<'de> for GeneratedField {
7326 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7327 where
7328 D: serde::Deserializer<'de>,
7329 {
7330 struct GeneratedVisitor;
7331
7332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7333 type Value = GeneratedField;
7334
7335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7336 write!(formatter, "expected one of: {:?}", &FIELDS)
7337 }
7338
7339 #[allow(unused_variables)]
7340 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7341 where
7342 E: serde::de::Error,
7343 {
7344 match value {
7345 "params" => Ok(GeneratedField::Params),
7346 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7347 }
7348 }
7349 }
7350 deserializer.deserialize_identifier(GeneratedVisitor)
7351 }
7352 }
7353 struct GeneratedVisitor;
7354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7355 type Value = GetSystemParamsResponse;
7356
7357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7358 formatter.write_str("struct meta.GetSystemParamsResponse")
7359 }
7360
7361 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7362 where
7363 V: serde::de::MapAccess<'de>,
7364 {
7365 let mut params__ = None;
7366 while let Some(k) = map_.next_key()? {
7367 match k {
7368 GeneratedField::Params => {
7369 if params__.is_some() {
7370 return Err(serde::de::Error::duplicate_field("params"));
7371 }
7372 params__ = map_.next_value()?;
7373 }
7374 }
7375 }
7376 Ok(GetSystemParamsResponse {
7377 params: params__,
7378 })
7379 }
7380 }
7381 deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7382 }
7383}
7384impl serde::Serialize for GetTelemetryInfoRequest {
7385 #[allow(deprecated)]
7386 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7387 where
7388 S: serde::Serializer,
7389 {
7390 use serde::ser::SerializeStruct;
7391 let len = 0;
7392 let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7393 struct_ser.end()
7394 }
7395}
7396impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7397 #[allow(deprecated)]
7398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7399 where
7400 D: serde::Deserializer<'de>,
7401 {
7402 const FIELDS: &[&str] = &[
7403 ];
7404
7405 #[allow(clippy::enum_variant_names)]
7406 enum GeneratedField {
7407 }
7408 impl<'de> serde::Deserialize<'de> for GeneratedField {
7409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7410 where
7411 D: serde::Deserializer<'de>,
7412 {
7413 struct GeneratedVisitor;
7414
7415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7416 type Value = GeneratedField;
7417
7418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7419 write!(formatter, "expected one of: {:?}", &FIELDS)
7420 }
7421
7422 #[allow(unused_variables)]
7423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7424 where
7425 E: serde::de::Error,
7426 {
7427 Err(serde::de::Error::unknown_field(value, FIELDS))
7428 }
7429 }
7430 deserializer.deserialize_identifier(GeneratedVisitor)
7431 }
7432 }
7433 struct GeneratedVisitor;
7434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7435 type Value = GetTelemetryInfoRequest;
7436
7437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7438 formatter.write_str("struct meta.GetTelemetryInfoRequest")
7439 }
7440
7441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7442 where
7443 V: serde::de::MapAccess<'de>,
7444 {
7445 while map_.next_key::<GeneratedField>()?.is_some() {
7446 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7447 }
7448 Ok(GetTelemetryInfoRequest {
7449 })
7450 }
7451 }
7452 deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7453 }
7454}
7455impl serde::Serialize for HeartbeatRequest {
7456 #[allow(deprecated)]
7457 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7458 where
7459 S: serde::Serializer,
7460 {
7461 use serde::ser::SerializeStruct;
7462 let mut len = 0;
7463 if self.node_id != 0 {
7464 len += 1;
7465 }
7466 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7467 if self.node_id != 0 {
7468 struct_ser.serialize_field("nodeId", &self.node_id)?;
7469 }
7470 struct_ser.end()
7471 }
7472}
7473impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7474 #[allow(deprecated)]
7475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7476 where
7477 D: serde::Deserializer<'de>,
7478 {
7479 const FIELDS: &[&str] = &[
7480 "node_id",
7481 "nodeId",
7482 ];
7483
7484 #[allow(clippy::enum_variant_names)]
7485 enum GeneratedField {
7486 NodeId,
7487 }
7488 impl<'de> serde::Deserialize<'de> for GeneratedField {
7489 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7490 where
7491 D: serde::Deserializer<'de>,
7492 {
7493 struct GeneratedVisitor;
7494
7495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7496 type Value = GeneratedField;
7497
7498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7499 write!(formatter, "expected one of: {:?}", &FIELDS)
7500 }
7501
7502 #[allow(unused_variables)]
7503 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7504 where
7505 E: serde::de::Error,
7506 {
7507 match value {
7508 "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7509 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7510 }
7511 }
7512 }
7513 deserializer.deserialize_identifier(GeneratedVisitor)
7514 }
7515 }
7516 struct GeneratedVisitor;
7517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7518 type Value = HeartbeatRequest;
7519
7520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7521 formatter.write_str("struct meta.HeartbeatRequest")
7522 }
7523
7524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7525 where
7526 V: serde::de::MapAccess<'de>,
7527 {
7528 let mut node_id__ = None;
7529 while let Some(k) = map_.next_key()? {
7530 match k {
7531 GeneratedField::NodeId => {
7532 if node_id__.is_some() {
7533 return Err(serde::de::Error::duplicate_field("nodeId"));
7534 }
7535 node_id__ =
7536 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7537 ;
7538 }
7539 }
7540 }
7541 Ok(HeartbeatRequest {
7542 node_id: node_id__.unwrap_or_default(),
7543 })
7544 }
7545 }
7546 deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7547 }
7548}
7549impl serde::Serialize for HeartbeatResponse {
7550 #[allow(deprecated)]
7551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7552 where
7553 S: serde::Serializer,
7554 {
7555 use serde::ser::SerializeStruct;
7556 let mut len = 0;
7557 if self.status.is_some() {
7558 len += 1;
7559 }
7560 let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7561 if let Some(v) = self.status.as_ref() {
7562 struct_ser.serialize_field("status", v)?;
7563 }
7564 struct_ser.end()
7565 }
7566}
7567impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7568 #[allow(deprecated)]
7569 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7570 where
7571 D: serde::Deserializer<'de>,
7572 {
7573 const FIELDS: &[&str] = &[
7574 "status",
7575 ];
7576
7577 #[allow(clippy::enum_variant_names)]
7578 enum GeneratedField {
7579 Status,
7580 }
7581 impl<'de> serde::Deserialize<'de> for GeneratedField {
7582 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7583 where
7584 D: serde::Deserializer<'de>,
7585 {
7586 struct GeneratedVisitor;
7587
7588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7589 type Value = GeneratedField;
7590
7591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7592 write!(formatter, "expected one of: {:?}", &FIELDS)
7593 }
7594
7595 #[allow(unused_variables)]
7596 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7597 where
7598 E: serde::de::Error,
7599 {
7600 match value {
7601 "status" => Ok(GeneratedField::Status),
7602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7603 }
7604 }
7605 }
7606 deserializer.deserialize_identifier(GeneratedVisitor)
7607 }
7608 }
7609 struct GeneratedVisitor;
7610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7611 type Value = HeartbeatResponse;
7612
7613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7614 formatter.write_str("struct meta.HeartbeatResponse")
7615 }
7616
7617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7618 where
7619 V: serde::de::MapAccess<'de>,
7620 {
7621 let mut status__ = None;
7622 while let Some(k) = map_.next_key()? {
7623 match k {
7624 GeneratedField::Status => {
7625 if status__.is_some() {
7626 return Err(serde::de::Error::duplicate_field("status"));
7627 }
7628 status__ = map_.next_value()?;
7629 }
7630 }
7631 }
7632 Ok(HeartbeatResponse {
7633 status: status__,
7634 })
7635 }
7636 }
7637 deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7638 }
7639}
7640impl serde::Serialize for ListActorSplitsRequest {
7641 #[allow(deprecated)]
7642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7643 where
7644 S: serde::Serializer,
7645 {
7646 use serde::ser::SerializeStruct;
7647 let len = 0;
7648 let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7649 struct_ser.end()
7650 }
7651}
7652impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7653 #[allow(deprecated)]
7654 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7655 where
7656 D: serde::Deserializer<'de>,
7657 {
7658 const FIELDS: &[&str] = &[
7659 ];
7660
7661 #[allow(clippy::enum_variant_names)]
7662 enum GeneratedField {
7663 }
7664 impl<'de> serde::Deserialize<'de> for GeneratedField {
7665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7666 where
7667 D: serde::Deserializer<'de>,
7668 {
7669 struct GeneratedVisitor;
7670
7671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7672 type Value = GeneratedField;
7673
7674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7675 write!(formatter, "expected one of: {:?}", &FIELDS)
7676 }
7677
7678 #[allow(unused_variables)]
7679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7680 where
7681 E: serde::de::Error,
7682 {
7683 Err(serde::de::Error::unknown_field(value, FIELDS))
7684 }
7685 }
7686 deserializer.deserialize_identifier(GeneratedVisitor)
7687 }
7688 }
7689 struct GeneratedVisitor;
7690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7691 type Value = ListActorSplitsRequest;
7692
7693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7694 formatter.write_str("struct meta.ListActorSplitsRequest")
7695 }
7696
7697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7698 where
7699 V: serde::de::MapAccess<'de>,
7700 {
7701 while map_.next_key::<GeneratedField>()?.is_some() {
7702 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7703 }
7704 Ok(ListActorSplitsRequest {
7705 })
7706 }
7707 }
7708 deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7709 }
7710}
7711impl serde::Serialize for ListActorSplitsResponse {
7712 #[allow(deprecated)]
7713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7714 where
7715 S: serde::Serializer,
7716 {
7717 use serde::ser::SerializeStruct;
7718 let mut len = 0;
7719 if !self.actor_splits.is_empty() {
7720 len += 1;
7721 }
7722 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7723 if !self.actor_splits.is_empty() {
7724 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7725 }
7726 struct_ser.end()
7727 }
7728}
7729impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7730 #[allow(deprecated)]
7731 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7732 where
7733 D: serde::Deserializer<'de>,
7734 {
7735 const FIELDS: &[&str] = &[
7736 "actor_splits",
7737 "actorSplits",
7738 ];
7739
7740 #[allow(clippy::enum_variant_names)]
7741 enum GeneratedField {
7742 ActorSplits,
7743 }
7744 impl<'de> serde::Deserialize<'de> for GeneratedField {
7745 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7746 where
7747 D: serde::Deserializer<'de>,
7748 {
7749 struct GeneratedVisitor;
7750
7751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7752 type Value = GeneratedField;
7753
7754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7755 write!(formatter, "expected one of: {:?}", &FIELDS)
7756 }
7757
7758 #[allow(unused_variables)]
7759 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7760 where
7761 E: serde::de::Error,
7762 {
7763 match value {
7764 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7765 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7766 }
7767 }
7768 }
7769 deserializer.deserialize_identifier(GeneratedVisitor)
7770 }
7771 }
7772 struct GeneratedVisitor;
7773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7774 type Value = ListActorSplitsResponse;
7775
7776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7777 formatter.write_str("struct meta.ListActorSplitsResponse")
7778 }
7779
7780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7781 where
7782 V: serde::de::MapAccess<'de>,
7783 {
7784 let mut actor_splits__ = None;
7785 while let Some(k) = map_.next_key()? {
7786 match k {
7787 GeneratedField::ActorSplits => {
7788 if actor_splits__.is_some() {
7789 return Err(serde::de::Error::duplicate_field("actorSplits"));
7790 }
7791 actor_splits__ = Some(map_.next_value()?);
7792 }
7793 }
7794 }
7795 Ok(ListActorSplitsResponse {
7796 actor_splits: actor_splits__.unwrap_or_default(),
7797 })
7798 }
7799 }
7800 deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7801 }
7802}
7803impl serde::Serialize for list_actor_splits_response::ActorSplit {
7804 #[allow(deprecated)]
7805 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7806 where
7807 S: serde::Serializer,
7808 {
7809 use serde::ser::SerializeStruct;
7810 let mut len = 0;
7811 if self.actor_id != 0 {
7812 len += 1;
7813 }
7814 if self.fragment_id != 0 {
7815 len += 1;
7816 }
7817 if self.source_id != 0 {
7818 len += 1;
7819 }
7820 if !self.split_id.is_empty() {
7821 len += 1;
7822 }
7823 if self.fragment_type != 0 {
7824 len += 1;
7825 }
7826 let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7827 if self.actor_id != 0 {
7828 struct_ser.serialize_field("actorId", &self.actor_id)?;
7829 }
7830 if self.fragment_id != 0 {
7831 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7832 }
7833 if self.source_id != 0 {
7834 struct_ser.serialize_field("sourceId", &self.source_id)?;
7835 }
7836 if !self.split_id.is_empty() {
7837 struct_ser.serialize_field("splitId", &self.split_id)?;
7838 }
7839 if self.fragment_type != 0 {
7840 let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7841 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7842 struct_ser.serialize_field("fragmentType", &v)?;
7843 }
7844 struct_ser.end()
7845 }
7846}
7847impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7848 #[allow(deprecated)]
7849 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7850 where
7851 D: serde::Deserializer<'de>,
7852 {
7853 const FIELDS: &[&str] = &[
7854 "actor_id",
7855 "actorId",
7856 "fragment_id",
7857 "fragmentId",
7858 "source_id",
7859 "sourceId",
7860 "split_id",
7861 "splitId",
7862 "fragment_type",
7863 "fragmentType",
7864 ];
7865
7866 #[allow(clippy::enum_variant_names)]
7867 enum GeneratedField {
7868 ActorId,
7869 FragmentId,
7870 SourceId,
7871 SplitId,
7872 FragmentType,
7873 }
7874 impl<'de> serde::Deserialize<'de> for GeneratedField {
7875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7876 where
7877 D: serde::Deserializer<'de>,
7878 {
7879 struct GeneratedVisitor;
7880
7881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7882 type Value = GeneratedField;
7883
7884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7885 write!(formatter, "expected one of: {:?}", &FIELDS)
7886 }
7887
7888 #[allow(unused_variables)]
7889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7890 where
7891 E: serde::de::Error,
7892 {
7893 match value {
7894 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7895 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7896 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7897 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
7898 "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
7899 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7900 }
7901 }
7902 }
7903 deserializer.deserialize_identifier(GeneratedVisitor)
7904 }
7905 }
7906 struct GeneratedVisitor;
7907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7908 type Value = list_actor_splits_response::ActorSplit;
7909
7910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7911 formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
7912 }
7913
7914 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
7915 where
7916 V: serde::de::MapAccess<'de>,
7917 {
7918 let mut actor_id__ = None;
7919 let mut fragment_id__ = None;
7920 let mut source_id__ = None;
7921 let mut split_id__ = None;
7922 let mut fragment_type__ = None;
7923 while let Some(k) = map_.next_key()? {
7924 match k {
7925 GeneratedField::ActorId => {
7926 if actor_id__.is_some() {
7927 return Err(serde::de::Error::duplicate_field("actorId"));
7928 }
7929 actor_id__ =
7930 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7931 ;
7932 }
7933 GeneratedField::FragmentId => {
7934 if fragment_id__.is_some() {
7935 return Err(serde::de::Error::duplicate_field("fragmentId"));
7936 }
7937 fragment_id__ =
7938 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7939 ;
7940 }
7941 GeneratedField::SourceId => {
7942 if source_id__.is_some() {
7943 return Err(serde::de::Error::duplicate_field("sourceId"));
7944 }
7945 source_id__ =
7946 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7947 ;
7948 }
7949 GeneratedField::SplitId => {
7950 if split_id__.is_some() {
7951 return Err(serde::de::Error::duplicate_field("splitId"));
7952 }
7953 split_id__ = Some(map_.next_value()?);
7954 }
7955 GeneratedField::FragmentType => {
7956 if fragment_type__.is_some() {
7957 return Err(serde::de::Error::duplicate_field("fragmentType"));
7958 }
7959 fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
7960 }
7961 }
7962 }
7963 Ok(list_actor_splits_response::ActorSplit {
7964 actor_id: actor_id__.unwrap_or_default(),
7965 fragment_id: fragment_id__.unwrap_or_default(),
7966 source_id: source_id__.unwrap_or_default(),
7967 split_id: split_id__.unwrap_or_default(),
7968 fragment_type: fragment_type__.unwrap_or_default(),
7969 })
7970 }
7971 }
7972 deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
7973 }
7974}
7975impl serde::Serialize for list_actor_splits_response::FragmentType {
7976 #[allow(deprecated)]
7977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7978 where
7979 S: serde::Serializer,
7980 {
7981 let variant = match self {
7982 Self::Unspecified => "UNSPECIFIED",
7983 Self::NonSharedSource => "NON_SHARED_SOURCE",
7984 Self::SharedSource => "SHARED_SOURCE",
7985 Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
7986 };
7987 serializer.serialize_str(variant)
7988 }
7989}
7990impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
7991 #[allow(deprecated)]
7992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7993 where
7994 D: serde::Deserializer<'de>,
7995 {
7996 const FIELDS: &[&str] = &[
7997 "UNSPECIFIED",
7998 "NON_SHARED_SOURCE",
7999 "SHARED_SOURCE",
8000 "SHARED_SOURCE_BACKFILL",
8001 ];
8002
8003 struct GeneratedVisitor;
8004
8005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8006 type Value = list_actor_splits_response::FragmentType;
8007
8008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8009 write!(formatter, "expected one of: {:?}", &FIELDS)
8010 }
8011
8012 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8013 where
8014 E: serde::de::Error,
8015 {
8016 i32::try_from(v)
8017 .ok()
8018 .and_then(|x| x.try_into().ok())
8019 .ok_or_else(|| {
8020 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8021 })
8022 }
8023
8024 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8025 where
8026 E: serde::de::Error,
8027 {
8028 i32::try_from(v)
8029 .ok()
8030 .and_then(|x| x.try_into().ok())
8031 .ok_or_else(|| {
8032 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8033 })
8034 }
8035
8036 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8037 where
8038 E: serde::de::Error,
8039 {
8040 match value {
8041 "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8042 "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8043 "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8044 "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8045 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8046 }
8047 }
8048 }
8049 deserializer.deserialize_any(GeneratedVisitor)
8050 }
8051}
8052impl serde::Serialize for ListActorStatesRequest {
8053 #[allow(deprecated)]
8054 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8055 where
8056 S: serde::Serializer,
8057 {
8058 use serde::ser::SerializeStruct;
8059 let len = 0;
8060 let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8061 struct_ser.end()
8062 }
8063}
8064impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8065 #[allow(deprecated)]
8066 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8067 where
8068 D: serde::Deserializer<'de>,
8069 {
8070 const FIELDS: &[&str] = &[
8071 ];
8072
8073 #[allow(clippy::enum_variant_names)]
8074 enum GeneratedField {
8075 }
8076 impl<'de> serde::Deserialize<'de> for GeneratedField {
8077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8078 where
8079 D: serde::Deserializer<'de>,
8080 {
8081 struct GeneratedVisitor;
8082
8083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8084 type Value = GeneratedField;
8085
8086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087 write!(formatter, "expected one of: {:?}", &FIELDS)
8088 }
8089
8090 #[allow(unused_variables)]
8091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8092 where
8093 E: serde::de::Error,
8094 {
8095 Err(serde::de::Error::unknown_field(value, FIELDS))
8096 }
8097 }
8098 deserializer.deserialize_identifier(GeneratedVisitor)
8099 }
8100 }
8101 struct GeneratedVisitor;
8102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8103 type Value = ListActorStatesRequest;
8104
8105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8106 formatter.write_str("struct meta.ListActorStatesRequest")
8107 }
8108
8109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8110 where
8111 V: serde::de::MapAccess<'de>,
8112 {
8113 while map_.next_key::<GeneratedField>()?.is_some() {
8114 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8115 }
8116 Ok(ListActorStatesRequest {
8117 })
8118 }
8119 }
8120 deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8121 }
8122}
8123impl serde::Serialize for ListActorStatesResponse {
8124 #[allow(deprecated)]
8125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8126 where
8127 S: serde::Serializer,
8128 {
8129 use serde::ser::SerializeStruct;
8130 let mut len = 0;
8131 if !self.states.is_empty() {
8132 len += 1;
8133 }
8134 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8135 if !self.states.is_empty() {
8136 struct_ser.serialize_field("states", &self.states)?;
8137 }
8138 struct_ser.end()
8139 }
8140}
8141impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8142 #[allow(deprecated)]
8143 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8144 where
8145 D: serde::Deserializer<'de>,
8146 {
8147 const FIELDS: &[&str] = &[
8148 "states",
8149 ];
8150
8151 #[allow(clippy::enum_variant_names)]
8152 enum GeneratedField {
8153 States,
8154 }
8155 impl<'de> serde::Deserialize<'de> for GeneratedField {
8156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8157 where
8158 D: serde::Deserializer<'de>,
8159 {
8160 struct GeneratedVisitor;
8161
8162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8163 type Value = GeneratedField;
8164
8165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8166 write!(formatter, "expected one of: {:?}", &FIELDS)
8167 }
8168
8169 #[allow(unused_variables)]
8170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8171 where
8172 E: serde::de::Error,
8173 {
8174 match value {
8175 "states" => Ok(GeneratedField::States),
8176 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8177 }
8178 }
8179 }
8180 deserializer.deserialize_identifier(GeneratedVisitor)
8181 }
8182 }
8183 struct GeneratedVisitor;
8184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8185 type Value = ListActorStatesResponse;
8186
8187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8188 formatter.write_str("struct meta.ListActorStatesResponse")
8189 }
8190
8191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8192 where
8193 V: serde::de::MapAccess<'de>,
8194 {
8195 let mut states__ = None;
8196 while let Some(k) = map_.next_key()? {
8197 match k {
8198 GeneratedField::States => {
8199 if states__.is_some() {
8200 return Err(serde::de::Error::duplicate_field("states"));
8201 }
8202 states__ = Some(map_.next_value()?);
8203 }
8204 }
8205 }
8206 Ok(ListActorStatesResponse {
8207 states: states__.unwrap_or_default(),
8208 })
8209 }
8210 }
8211 deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8212 }
8213}
8214impl serde::Serialize for list_actor_states_response::ActorState {
8215 #[allow(deprecated)]
8216 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8217 where
8218 S: serde::Serializer,
8219 {
8220 use serde::ser::SerializeStruct;
8221 let mut len = 0;
8222 if self.actor_id != 0 {
8223 len += 1;
8224 }
8225 if self.fragment_id != 0 {
8226 len += 1;
8227 }
8228 if self.state != 0 {
8229 len += 1;
8230 }
8231 if self.worker_id != 0 {
8232 len += 1;
8233 }
8234 let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8235 if self.actor_id != 0 {
8236 struct_ser.serialize_field("actorId", &self.actor_id)?;
8237 }
8238 if self.fragment_id != 0 {
8239 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8240 }
8241 if self.state != 0 {
8242 let v = table_fragments::actor_status::ActorState::try_from(self.state)
8243 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
8244 struct_ser.serialize_field("state", &v)?;
8245 }
8246 if self.worker_id != 0 {
8247 struct_ser.serialize_field("workerId", &self.worker_id)?;
8248 }
8249 struct_ser.end()
8250 }
8251}
8252impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8253 #[allow(deprecated)]
8254 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8255 where
8256 D: serde::Deserializer<'de>,
8257 {
8258 const FIELDS: &[&str] = &[
8259 "actor_id",
8260 "actorId",
8261 "fragment_id",
8262 "fragmentId",
8263 "state",
8264 "worker_id",
8265 "workerId",
8266 ];
8267
8268 #[allow(clippy::enum_variant_names)]
8269 enum GeneratedField {
8270 ActorId,
8271 FragmentId,
8272 State,
8273 WorkerId,
8274 }
8275 impl<'de> serde::Deserialize<'de> for GeneratedField {
8276 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8277 where
8278 D: serde::Deserializer<'de>,
8279 {
8280 struct GeneratedVisitor;
8281
8282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8283 type Value = GeneratedField;
8284
8285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8286 write!(formatter, "expected one of: {:?}", &FIELDS)
8287 }
8288
8289 #[allow(unused_variables)]
8290 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8291 where
8292 E: serde::de::Error,
8293 {
8294 match value {
8295 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8296 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8297 "state" => Ok(GeneratedField::State),
8298 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8299 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8300 }
8301 }
8302 }
8303 deserializer.deserialize_identifier(GeneratedVisitor)
8304 }
8305 }
8306 struct GeneratedVisitor;
8307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8308 type Value = list_actor_states_response::ActorState;
8309
8310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8311 formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8312 }
8313
8314 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8315 where
8316 V: serde::de::MapAccess<'de>,
8317 {
8318 let mut actor_id__ = None;
8319 let mut fragment_id__ = None;
8320 let mut state__ = None;
8321 let mut worker_id__ = None;
8322 while let Some(k) = map_.next_key()? {
8323 match k {
8324 GeneratedField::ActorId => {
8325 if actor_id__.is_some() {
8326 return Err(serde::de::Error::duplicate_field("actorId"));
8327 }
8328 actor_id__ =
8329 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8330 ;
8331 }
8332 GeneratedField::FragmentId => {
8333 if fragment_id__.is_some() {
8334 return Err(serde::de::Error::duplicate_field("fragmentId"));
8335 }
8336 fragment_id__ =
8337 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8338 ;
8339 }
8340 GeneratedField::State => {
8341 if state__.is_some() {
8342 return Err(serde::de::Error::duplicate_field("state"));
8343 }
8344 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
8345 }
8346 GeneratedField::WorkerId => {
8347 if worker_id__.is_some() {
8348 return Err(serde::de::Error::duplicate_field("workerId"));
8349 }
8350 worker_id__ =
8351 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8352 ;
8353 }
8354 }
8355 }
8356 Ok(list_actor_states_response::ActorState {
8357 actor_id: actor_id__.unwrap_or_default(),
8358 fragment_id: fragment_id__.unwrap_or_default(),
8359 state: state__.unwrap_or_default(),
8360 worker_id: worker_id__.unwrap_or_default(),
8361 })
8362 }
8363 }
8364 deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8365 }
8366}
8367impl serde::Serialize for ListAllNodesRequest {
8368 #[allow(deprecated)]
8369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8370 where
8371 S: serde::Serializer,
8372 {
8373 use serde::ser::SerializeStruct;
8374 let mut len = 0;
8375 if self.worker_type.is_some() {
8376 len += 1;
8377 }
8378 if self.include_starting_nodes {
8379 len += 1;
8380 }
8381 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8382 if let Some(v) = self.worker_type.as_ref() {
8383 let v = super::common::WorkerType::try_from(*v)
8384 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8385 struct_ser.serialize_field("workerType", &v)?;
8386 }
8387 if self.include_starting_nodes {
8388 struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8389 }
8390 struct_ser.end()
8391 }
8392}
8393impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8394 #[allow(deprecated)]
8395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8396 where
8397 D: serde::Deserializer<'de>,
8398 {
8399 const FIELDS: &[&str] = &[
8400 "worker_type",
8401 "workerType",
8402 "include_starting_nodes",
8403 "includeStartingNodes",
8404 ];
8405
8406 #[allow(clippy::enum_variant_names)]
8407 enum GeneratedField {
8408 WorkerType,
8409 IncludeStartingNodes,
8410 }
8411 impl<'de> serde::Deserialize<'de> for GeneratedField {
8412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8413 where
8414 D: serde::Deserializer<'de>,
8415 {
8416 struct GeneratedVisitor;
8417
8418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8419 type Value = GeneratedField;
8420
8421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8422 write!(formatter, "expected one of: {:?}", &FIELDS)
8423 }
8424
8425 #[allow(unused_variables)]
8426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8427 where
8428 E: serde::de::Error,
8429 {
8430 match value {
8431 "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8432 "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8433 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8434 }
8435 }
8436 }
8437 deserializer.deserialize_identifier(GeneratedVisitor)
8438 }
8439 }
8440 struct GeneratedVisitor;
8441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8442 type Value = ListAllNodesRequest;
8443
8444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8445 formatter.write_str("struct meta.ListAllNodesRequest")
8446 }
8447
8448 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8449 where
8450 V: serde::de::MapAccess<'de>,
8451 {
8452 let mut worker_type__ = None;
8453 let mut include_starting_nodes__ = None;
8454 while let Some(k) = map_.next_key()? {
8455 match k {
8456 GeneratedField::WorkerType => {
8457 if worker_type__.is_some() {
8458 return Err(serde::de::Error::duplicate_field("workerType"));
8459 }
8460 worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8461 }
8462 GeneratedField::IncludeStartingNodes => {
8463 if include_starting_nodes__.is_some() {
8464 return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8465 }
8466 include_starting_nodes__ = Some(map_.next_value()?);
8467 }
8468 }
8469 }
8470 Ok(ListAllNodesRequest {
8471 worker_type: worker_type__,
8472 include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8473 })
8474 }
8475 }
8476 deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8477 }
8478}
8479impl serde::Serialize for ListAllNodesResponse {
8480 #[allow(deprecated)]
8481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8482 where
8483 S: serde::Serializer,
8484 {
8485 use serde::ser::SerializeStruct;
8486 let mut len = 0;
8487 if self.status.is_some() {
8488 len += 1;
8489 }
8490 if !self.nodes.is_empty() {
8491 len += 1;
8492 }
8493 let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8494 if let Some(v) = self.status.as_ref() {
8495 struct_ser.serialize_field("status", v)?;
8496 }
8497 if !self.nodes.is_empty() {
8498 struct_ser.serialize_field("nodes", &self.nodes)?;
8499 }
8500 struct_ser.end()
8501 }
8502}
8503impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8504 #[allow(deprecated)]
8505 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8506 where
8507 D: serde::Deserializer<'de>,
8508 {
8509 const FIELDS: &[&str] = &[
8510 "status",
8511 "nodes",
8512 ];
8513
8514 #[allow(clippy::enum_variant_names)]
8515 enum GeneratedField {
8516 Status,
8517 Nodes,
8518 }
8519 impl<'de> serde::Deserialize<'de> for GeneratedField {
8520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8521 where
8522 D: serde::Deserializer<'de>,
8523 {
8524 struct GeneratedVisitor;
8525
8526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8527 type Value = GeneratedField;
8528
8529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8530 write!(formatter, "expected one of: {:?}", &FIELDS)
8531 }
8532
8533 #[allow(unused_variables)]
8534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8535 where
8536 E: serde::de::Error,
8537 {
8538 match value {
8539 "status" => Ok(GeneratedField::Status),
8540 "nodes" => Ok(GeneratedField::Nodes),
8541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8542 }
8543 }
8544 }
8545 deserializer.deserialize_identifier(GeneratedVisitor)
8546 }
8547 }
8548 struct GeneratedVisitor;
8549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8550 type Value = ListAllNodesResponse;
8551
8552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8553 formatter.write_str("struct meta.ListAllNodesResponse")
8554 }
8555
8556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8557 where
8558 V: serde::de::MapAccess<'de>,
8559 {
8560 let mut status__ = None;
8561 let mut nodes__ = None;
8562 while let Some(k) = map_.next_key()? {
8563 match k {
8564 GeneratedField::Status => {
8565 if status__.is_some() {
8566 return Err(serde::de::Error::duplicate_field("status"));
8567 }
8568 status__ = map_.next_value()?;
8569 }
8570 GeneratedField::Nodes => {
8571 if nodes__.is_some() {
8572 return Err(serde::de::Error::duplicate_field("nodes"));
8573 }
8574 nodes__ = Some(map_.next_value()?);
8575 }
8576 }
8577 }
8578 Ok(ListAllNodesResponse {
8579 status: status__,
8580 nodes: nodes__.unwrap_or_default(),
8581 })
8582 }
8583 }
8584 deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8585 }
8586}
8587impl serde::Serialize for ListCdcProgressRequest {
8588 #[allow(deprecated)]
8589 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8590 where
8591 S: serde::Serializer,
8592 {
8593 use serde::ser::SerializeStruct;
8594 let len = 0;
8595 let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
8596 struct_ser.end()
8597 }
8598}
8599impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
8600 #[allow(deprecated)]
8601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8602 where
8603 D: serde::Deserializer<'de>,
8604 {
8605 const FIELDS: &[&str] = &[
8606 ];
8607
8608 #[allow(clippy::enum_variant_names)]
8609 enum GeneratedField {
8610 }
8611 impl<'de> serde::Deserialize<'de> for GeneratedField {
8612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8613 where
8614 D: serde::Deserializer<'de>,
8615 {
8616 struct GeneratedVisitor;
8617
8618 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8619 type Value = GeneratedField;
8620
8621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8622 write!(formatter, "expected one of: {:?}", &FIELDS)
8623 }
8624
8625 #[allow(unused_variables)]
8626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8627 where
8628 E: serde::de::Error,
8629 {
8630 Err(serde::de::Error::unknown_field(value, FIELDS))
8631 }
8632 }
8633 deserializer.deserialize_identifier(GeneratedVisitor)
8634 }
8635 }
8636 struct GeneratedVisitor;
8637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8638 type Value = ListCdcProgressRequest;
8639
8640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8641 formatter.write_str("struct meta.ListCdcProgressRequest")
8642 }
8643
8644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
8645 where
8646 V: serde::de::MapAccess<'de>,
8647 {
8648 while map_.next_key::<GeneratedField>()?.is_some() {
8649 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8650 }
8651 Ok(ListCdcProgressRequest {
8652 })
8653 }
8654 }
8655 deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
8656 }
8657}
8658impl serde::Serialize for ListCdcProgressResponse {
8659 #[allow(deprecated)]
8660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8661 where
8662 S: serde::Serializer,
8663 {
8664 use serde::ser::SerializeStruct;
8665 let mut len = 0;
8666 if !self.cdc_progress.is_empty() {
8667 len += 1;
8668 }
8669 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
8670 if !self.cdc_progress.is_empty() {
8671 struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
8672 }
8673 struct_ser.end()
8674 }
8675}
8676impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
8677 #[allow(deprecated)]
8678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8679 where
8680 D: serde::Deserializer<'de>,
8681 {
8682 const FIELDS: &[&str] = &[
8683 "cdc_progress",
8684 "cdcProgress",
8685 ];
8686
8687 #[allow(clippy::enum_variant_names)]
8688 enum GeneratedField {
8689 CdcProgress,
8690 }
8691 impl<'de> serde::Deserialize<'de> for GeneratedField {
8692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8693 where
8694 D: serde::Deserializer<'de>,
8695 {
8696 struct GeneratedVisitor;
8697
8698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8699 type Value = GeneratedField;
8700
8701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8702 write!(formatter, "expected one of: {:?}", &FIELDS)
8703 }
8704
8705 #[allow(unused_variables)]
8706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8707 where
8708 E: serde::de::Error,
8709 {
8710 match value {
8711 "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
8712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8713 }
8714 }
8715 }
8716 deserializer.deserialize_identifier(GeneratedVisitor)
8717 }
8718 }
8719 struct GeneratedVisitor;
8720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8721 type Value = ListCdcProgressResponse;
8722
8723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8724 formatter.write_str("struct meta.ListCdcProgressResponse")
8725 }
8726
8727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
8728 where
8729 V: serde::de::MapAccess<'de>,
8730 {
8731 let mut cdc_progress__ = None;
8732 while let Some(k) = map_.next_key()? {
8733 match k {
8734 GeneratedField::CdcProgress => {
8735 if cdc_progress__.is_some() {
8736 return Err(serde::de::Error::duplicate_field("cdcProgress"));
8737 }
8738 cdc_progress__ = Some(
8739 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8740 .into_iter().map(|(k,v)| (k.0, v)).collect()
8741 );
8742 }
8743 }
8744 }
8745 Ok(ListCdcProgressResponse {
8746 cdc_progress: cdc_progress__.unwrap_or_default(),
8747 })
8748 }
8749 }
8750 deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
8751 }
8752}
8753impl serde::Serialize for list_cdc_progress_response::CdcProgress {
8754 #[allow(deprecated)]
8755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8756 where
8757 S: serde::Serializer,
8758 {
8759 use serde::ser::SerializeStruct;
8760 let mut len = 0;
8761 if self.split_total_count != 0 {
8762 len += 1;
8763 }
8764 if self.split_backfilled_count != 0 {
8765 len += 1;
8766 }
8767 if self.split_completed_count != 0 {
8768 len += 1;
8769 }
8770 let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
8771 if self.split_total_count != 0 {
8772 #[allow(clippy::needless_borrow)]
8773 #[allow(clippy::needless_borrows_for_generic_args)]
8774 struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
8775 }
8776 if self.split_backfilled_count != 0 {
8777 #[allow(clippy::needless_borrow)]
8778 #[allow(clippy::needless_borrows_for_generic_args)]
8779 struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
8780 }
8781 if self.split_completed_count != 0 {
8782 #[allow(clippy::needless_borrow)]
8783 #[allow(clippy::needless_borrows_for_generic_args)]
8784 struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
8785 }
8786 struct_ser.end()
8787 }
8788}
8789impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
8790 #[allow(deprecated)]
8791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8792 where
8793 D: serde::Deserializer<'de>,
8794 {
8795 const FIELDS: &[&str] = &[
8796 "split_total_count",
8797 "splitTotalCount",
8798 "split_backfilled_count",
8799 "splitBackfilledCount",
8800 "split_completed_count",
8801 "splitCompletedCount",
8802 ];
8803
8804 #[allow(clippy::enum_variant_names)]
8805 enum GeneratedField {
8806 SplitTotalCount,
8807 SplitBackfilledCount,
8808 SplitCompletedCount,
8809 }
8810 impl<'de> serde::Deserialize<'de> for GeneratedField {
8811 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8812 where
8813 D: serde::Deserializer<'de>,
8814 {
8815 struct GeneratedVisitor;
8816
8817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8818 type Value = GeneratedField;
8819
8820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8821 write!(formatter, "expected one of: {:?}", &FIELDS)
8822 }
8823
8824 #[allow(unused_variables)]
8825 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8826 where
8827 E: serde::de::Error,
8828 {
8829 match value {
8830 "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
8831 "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
8832 "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
8833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8834 }
8835 }
8836 }
8837 deserializer.deserialize_identifier(GeneratedVisitor)
8838 }
8839 }
8840 struct GeneratedVisitor;
8841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8842 type Value = list_cdc_progress_response::CdcProgress;
8843
8844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8845 formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
8846 }
8847
8848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
8849 where
8850 V: serde::de::MapAccess<'de>,
8851 {
8852 let mut split_total_count__ = None;
8853 let mut split_backfilled_count__ = None;
8854 let mut split_completed_count__ = None;
8855 while let Some(k) = map_.next_key()? {
8856 match k {
8857 GeneratedField::SplitTotalCount => {
8858 if split_total_count__.is_some() {
8859 return Err(serde::de::Error::duplicate_field("splitTotalCount"));
8860 }
8861 split_total_count__ =
8862 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8863 ;
8864 }
8865 GeneratedField::SplitBackfilledCount => {
8866 if split_backfilled_count__.is_some() {
8867 return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
8868 }
8869 split_backfilled_count__ =
8870 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8871 ;
8872 }
8873 GeneratedField::SplitCompletedCount => {
8874 if split_completed_count__.is_some() {
8875 return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
8876 }
8877 split_completed_count__ =
8878 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8879 ;
8880 }
8881 }
8882 }
8883 Ok(list_cdc_progress_response::CdcProgress {
8884 split_total_count: split_total_count__.unwrap_or_default(),
8885 split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
8886 split_completed_count: split_completed_count__.unwrap_or_default(),
8887 })
8888 }
8889 }
8890 deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
8891 }
8892}
8893impl serde::Serialize for ListCreatingFragmentDistributionRequest {
8894 #[allow(deprecated)]
8895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8896 where
8897 S: serde::Serializer,
8898 {
8899 use serde::ser::SerializeStruct;
8900 let len = 0;
8901 let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
8902 struct_ser.end()
8903 }
8904}
8905impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
8906 #[allow(deprecated)]
8907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8908 where
8909 D: serde::Deserializer<'de>,
8910 {
8911 const FIELDS: &[&str] = &[
8912 ];
8913
8914 #[allow(clippy::enum_variant_names)]
8915 enum GeneratedField {
8916 }
8917 impl<'de> serde::Deserialize<'de> for GeneratedField {
8918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8919 where
8920 D: serde::Deserializer<'de>,
8921 {
8922 struct GeneratedVisitor;
8923
8924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8925 type Value = GeneratedField;
8926
8927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8928 write!(formatter, "expected one of: {:?}", &FIELDS)
8929 }
8930
8931 #[allow(unused_variables)]
8932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8933 where
8934 E: serde::de::Error,
8935 {
8936 Err(serde::de::Error::unknown_field(value, FIELDS))
8937 }
8938 }
8939 deserializer.deserialize_identifier(GeneratedVisitor)
8940 }
8941 }
8942 struct GeneratedVisitor;
8943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8944 type Value = ListCreatingFragmentDistributionRequest;
8945
8946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8947 formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
8948 }
8949
8950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
8951 where
8952 V: serde::de::MapAccess<'de>,
8953 {
8954 while map_.next_key::<GeneratedField>()?.is_some() {
8955 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8956 }
8957 Ok(ListCreatingFragmentDistributionRequest {
8958 })
8959 }
8960 }
8961 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8962 }
8963}
8964impl serde::Serialize for ListCreatingFragmentDistributionResponse {
8965 #[allow(deprecated)]
8966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8967 where
8968 S: serde::Serializer,
8969 {
8970 use serde::ser::SerializeStruct;
8971 let mut len = 0;
8972 if !self.distributions.is_empty() {
8973 len += 1;
8974 }
8975 let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
8976 if !self.distributions.is_empty() {
8977 struct_ser.serialize_field("distributions", &self.distributions)?;
8978 }
8979 struct_ser.end()
8980 }
8981}
8982impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
8983 #[allow(deprecated)]
8984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8985 where
8986 D: serde::Deserializer<'de>,
8987 {
8988 const FIELDS: &[&str] = &[
8989 "distributions",
8990 ];
8991
8992 #[allow(clippy::enum_variant_names)]
8993 enum GeneratedField {
8994 Distributions,
8995 }
8996 impl<'de> serde::Deserialize<'de> for GeneratedField {
8997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8998 where
8999 D: serde::Deserializer<'de>,
9000 {
9001 struct GeneratedVisitor;
9002
9003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9004 type Value = GeneratedField;
9005
9006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9007 write!(formatter, "expected one of: {:?}", &FIELDS)
9008 }
9009
9010 #[allow(unused_variables)]
9011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9012 where
9013 E: serde::de::Error,
9014 {
9015 match value {
9016 "distributions" => Ok(GeneratedField::Distributions),
9017 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9018 }
9019 }
9020 }
9021 deserializer.deserialize_identifier(GeneratedVisitor)
9022 }
9023 }
9024 struct GeneratedVisitor;
9025 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9026 type Value = ListCreatingFragmentDistributionResponse;
9027
9028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9029 formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
9030 }
9031
9032 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
9033 where
9034 V: serde::de::MapAccess<'de>,
9035 {
9036 let mut distributions__ = None;
9037 while let Some(k) = map_.next_key()? {
9038 match k {
9039 GeneratedField::Distributions => {
9040 if distributions__.is_some() {
9041 return Err(serde::de::Error::duplicate_field("distributions"));
9042 }
9043 distributions__ = Some(map_.next_value()?);
9044 }
9045 }
9046 }
9047 Ok(ListCreatingFragmentDistributionResponse {
9048 distributions: distributions__.unwrap_or_default(),
9049 })
9050 }
9051 }
9052 deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9053 }
9054}
9055impl serde::Serialize for ListEventLogRequest {
9056 #[allow(deprecated)]
9057 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9058 where
9059 S: serde::Serializer,
9060 {
9061 use serde::ser::SerializeStruct;
9062 let len = 0;
9063 let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
9064 struct_ser.end()
9065 }
9066}
9067impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
9068 #[allow(deprecated)]
9069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9070 where
9071 D: serde::Deserializer<'de>,
9072 {
9073 const FIELDS: &[&str] = &[
9074 ];
9075
9076 #[allow(clippy::enum_variant_names)]
9077 enum GeneratedField {
9078 }
9079 impl<'de> serde::Deserialize<'de> for GeneratedField {
9080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9081 where
9082 D: serde::Deserializer<'de>,
9083 {
9084 struct GeneratedVisitor;
9085
9086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9087 type Value = GeneratedField;
9088
9089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9090 write!(formatter, "expected one of: {:?}", &FIELDS)
9091 }
9092
9093 #[allow(unused_variables)]
9094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9095 where
9096 E: serde::de::Error,
9097 {
9098 Err(serde::de::Error::unknown_field(value, FIELDS))
9099 }
9100 }
9101 deserializer.deserialize_identifier(GeneratedVisitor)
9102 }
9103 }
9104 struct GeneratedVisitor;
9105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9106 type Value = ListEventLogRequest;
9107
9108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9109 formatter.write_str("struct meta.ListEventLogRequest")
9110 }
9111
9112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
9113 where
9114 V: serde::de::MapAccess<'de>,
9115 {
9116 while map_.next_key::<GeneratedField>()?.is_some() {
9117 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9118 }
9119 Ok(ListEventLogRequest {
9120 })
9121 }
9122 }
9123 deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
9124 }
9125}
9126impl serde::Serialize for ListEventLogResponse {
9127 #[allow(deprecated)]
9128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9129 where
9130 S: serde::Serializer,
9131 {
9132 use serde::ser::SerializeStruct;
9133 let mut len = 0;
9134 if !self.event_logs.is_empty() {
9135 len += 1;
9136 }
9137 let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
9138 if !self.event_logs.is_empty() {
9139 struct_ser.serialize_field("eventLogs", &self.event_logs)?;
9140 }
9141 struct_ser.end()
9142 }
9143}
9144impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
9145 #[allow(deprecated)]
9146 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9147 where
9148 D: serde::Deserializer<'de>,
9149 {
9150 const FIELDS: &[&str] = &[
9151 "event_logs",
9152 "eventLogs",
9153 ];
9154
9155 #[allow(clippy::enum_variant_names)]
9156 enum GeneratedField {
9157 EventLogs,
9158 }
9159 impl<'de> serde::Deserialize<'de> for GeneratedField {
9160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9161 where
9162 D: serde::Deserializer<'de>,
9163 {
9164 struct GeneratedVisitor;
9165
9166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9167 type Value = GeneratedField;
9168
9169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9170 write!(formatter, "expected one of: {:?}", &FIELDS)
9171 }
9172
9173 #[allow(unused_variables)]
9174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9175 where
9176 E: serde::de::Error,
9177 {
9178 match value {
9179 "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
9180 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9181 }
9182 }
9183 }
9184 deserializer.deserialize_identifier(GeneratedVisitor)
9185 }
9186 }
9187 struct GeneratedVisitor;
9188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9189 type Value = ListEventLogResponse;
9190
9191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9192 formatter.write_str("struct meta.ListEventLogResponse")
9193 }
9194
9195 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
9196 where
9197 V: serde::de::MapAccess<'de>,
9198 {
9199 let mut event_logs__ = None;
9200 while let Some(k) = map_.next_key()? {
9201 match k {
9202 GeneratedField::EventLogs => {
9203 if event_logs__.is_some() {
9204 return Err(serde::de::Error::duplicate_field("eventLogs"));
9205 }
9206 event_logs__ = Some(map_.next_value()?);
9207 }
9208 }
9209 }
9210 Ok(ListEventLogResponse {
9211 event_logs: event_logs__.unwrap_or_default(),
9212 })
9213 }
9214 }
9215 deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
9216 }
9217}
9218impl serde::Serialize for ListFragmentDistributionRequest {
9219 #[allow(deprecated)]
9220 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9221 where
9222 S: serde::Serializer,
9223 {
9224 use serde::ser::SerializeStruct;
9225 let len = 0;
9226 let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
9227 struct_ser.end()
9228 }
9229}
9230impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
9231 #[allow(deprecated)]
9232 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9233 where
9234 D: serde::Deserializer<'de>,
9235 {
9236 const FIELDS: &[&str] = &[
9237 ];
9238
9239 #[allow(clippy::enum_variant_names)]
9240 enum GeneratedField {
9241 }
9242 impl<'de> serde::Deserialize<'de> for GeneratedField {
9243 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9244 where
9245 D: serde::Deserializer<'de>,
9246 {
9247 struct GeneratedVisitor;
9248
9249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9250 type Value = GeneratedField;
9251
9252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9253 write!(formatter, "expected one of: {:?}", &FIELDS)
9254 }
9255
9256 #[allow(unused_variables)]
9257 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9258 where
9259 E: serde::de::Error,
9260 {
9261 Err(serde::de::Error::unknown_field(value, FIELDS))
9262 }
9263 }
9264 deserializer.deserialize_identifier(GeneratedVisitor)
9265 }
9266 }
9267 struct GeneratedVisitor;
9268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9269 type Value = ListFragmentDistributionRequest;
9270
9271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9272 formatter.write_str("struct meta.ListFragmentDistributionRequest")
9273 }
9274
9275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
9276 where
9277 V: serde::de::MapAccess<'de>,
9278 {
9279 while map_.next_key::<GeneratedField>()?.is_some() {
9280 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9281 }
9282 Ok(ListFragmentDistributionRequest {
9283 })
9284 }
9285 }
9286 deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9287 }
9288}
9289impl serde::Serialize for ListFragmentDistributionResponse {
9290 #[allow(deprecated)]
9291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9292 where
9293 S: serde::Serializer,
9294 {
9295 use serde::ser::SerializeStruct;
9296 let mut len = 0;
9297 if !self.distributions.is_empty() {
9298 len += 1;
9299 }
9300 let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
9301 if !self.distributions.is_empty() {
9302 struct_ser.serialize_field("distributions", &self.distributions)?;
9303 }
9304 struct_ser.end()
9305 }
9306}
9307impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
9308 #[allow(deprecated)]
9309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9310 where
9311 D: serde::Deserializer<'de>,
9312 {
9313 const FIELDS: &[&str] = &[
9314 "distributions",
9315 ];
9316
9317 #[allow(clippy::enum_variant_names)]
9318 enum GeneratedField {
9319 Distributions,
9320 }
9321 impl<'de> serde::Deserialize<'de> for GeneratedField {
9322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9323 where
9324 D: serde::Deserializer<'de>,
9325 {
9326 struct GeneratedVisitor;
9327
9328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9329 type Value = GeneratedField;
9330
9331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9332 write!(formatter, "expected one of: {:?}", &FIELDS)
9333 }
9334
9335 #[allow(unused_variables)]
9336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9337 where
9338 E: serde::de::Error,
9339 {
9340 match value {
9341 "distributions" => Ok(GeneratedField::Distributions),
9342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9343 }
9344 }
9345 }
9346 deserializer.deserialize_identifier(GeneratedVisitor)
9347 }
9348 }
9349 struct GeneratedVisitor;
9350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9351 type Value = ListFragmentDistributionResponse;
9352
9353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9354 formatter.write_str("struct meta.ListFragmentDistributionResponse")
9355 }
9356
9357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9358 where
9359 V: serde::de::MapAccess<'de>,
9360 {
9361 let mut distributions__ = None;
9362 while let Some(k) = map_.next_key()? {
9363 match k {
9364 GeneratedField::Distributions => {
9365 if distributions__.is_some() {
9366 return Err(serde::de::Error::duplicate_field("distributions"));
9367 }
9368 distributions__ = Some(map_.next_value()?);
9369 }
9370 }
9371 }
9372 Ok(ListFragmentDistributionResponse {
9373 distributions: distributions__.unwrap_or_default(),
9374 })
9375 }
9376 }
9377 deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9378 }
9379}
9380impl serde::Serialize for ListIcebergTablesRequest {
9381 #[allow(deprecated)]
9382 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9383 where
9384 S: serde::Serializer,
9385 {
9386 use serde::ser::SerializeStruct;
9387 let len = 0;
9388 let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
9389 struct_ser.end()
9390 }
9391}
9392impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
9393 #[allow(deprecated)]
9394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9395 where
9396 D: serde::Deserializer<'de>,
9397 {
9398 const FIELDS: &[&str] = &[
9399 ];
9400
9401 #[allow(clippy::enum_variant_names)]
9402 enum GeneratedField {
9403 }
9404 impl<'de> serde::Deserialize<'de> for GeneratedField {
9405 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9406 where
9407 D: serde::Deserializer<'de>,
9408 {
9409 struct GeneratedVisitor;
9410
9411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9412 type Value = GeneratedField;
9413
9414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9415 write!(formatter, "expected one of: {:?}", &FIELDS)
9416 }
9417
9418 #[allow(unused_variables)]
9419 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9420 where
9421 E: serde::de::Error,
9422 {
9423 Err(serde::de::Error::unknown_field(value, FIELDS))
9424 }
9425 }
9426 deserializer.deserialize_identifier(GeneratedVisitor)
9427 }
9428 }
9429 struct GeneratedVisitor;
9430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9431 type Value = ListIcebergTablesRequest;
9432
9433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9434 formatter.write_str("struct meta.ListIcebergTablesRequest")
9435 }
9436
9437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
9438 where
9439 V: serde::de::MapAccess<'de>,
9440 {
9441 while map_.next_key::<GeneratedField>()?.is_some() {
9442 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9443 }
9444 Ok(ListIcebergTablesRequest {
9445 })
9446 }
9447 }
9448 deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
9449 }
9450}
9451impl serde::Serialize for ListIcebergTablesResponse {
9452 #[allow(deprecated)]
9453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9454 where
9455 S: serde::Serializer,
9456 {
9457 use serde::ser::SerializeStruct;
9458 let mut len = 0;
9459 if !self.iceberg_tables.is_empty() {
9460 len += 1;
9461 }
9462 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
9463 if !self.iceberg_tables.is_empty() {
9464 struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
9465 }
9466 struct_ser.end()
9467 }
9468}
9469impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
9470 #[allow(deprecated)]
9471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9472 where
9473 D: serde::Deserializer<'de>,
9474 {
9475 const FIELDS: &[&str] = &[
9476 "iceberg_tables",
9477 "icebergTables",
9478 ];
9479
9480 #[allow(clippy::enum_variant_names)]
9481 enum GeneratedField {
9482 IcebergTables,
9483 }
9484 impl<'de> serde::Deserialize<'de> for GeneratedField {
9485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9486 where
9487 D: serde::Deserializer<'de>,
9488 {
9489 struct GeneratedVisitor;
9490
9491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9492 type Value = GeneratedField;
9493
9494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9495 write!(formatter, "expected one of: {:?}", &FIELDS)
9496 }
9497
9498 #[allow(unused_variables)]
9499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9500 where
9501 E: serde::de::Error,
9502 {
9503 match value {
9504 "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9505 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9506 }
9507 }
9508 }
9509 deserializer.deserialize_identifier(GeneratedVisitor)
9510 }
9511 }
9512 struct GeneratedVisitor;
9513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9514 type Value = ListIcebergTablesResponse;
9515
9516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9517 formatter.write_str("struct meta.ListIcebergTablesResponse")
9518 }
9519
9520 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9521 where
9522 V: serde::de::MapAccess<'de>,
9523 {
9524 let mut iceberg_tables__ = None;
9525 while let Some(k) = map_.next_key()? {
9526 match k {
9527 GeneratedField::IcebergTables => {
9528 if iceberg_tables__.is_some() {
9529 return Err(serde::de::Error::duplicate_field("icebergTables"));
9530 }
9531 iceberg_tables__ = Some(map_.next_value()?);
9532 }
9533 }
9534 }
9535 Ok(ListIcebergTablesResponse {
9536 iceberg_tables: iceberg_tables__.unwrap_or_default(),
9537 })
9538 }
9539 }
9540 deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9541 }
9542}
9543impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9544 #[allow(deprecated)]
9545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9546 where
9547 S: serde::Serializer,
9548 {
9549 use serde::ser::SerializeStruct;
9550 let mut len = 0;
9551 if !self.catalog_name.is_empty() {
9552 len += 1;
9553 }
9554 if !self.table_namespace.is_empty() {
9555 len += 1;
9556 }
9557 if !self.table_name.is_empty() {
9558 len += 1;
9559 }
9560 if self.metadata_location.is_some() {
9561 len += 1;
9562 }
9563 if self.previous_metadata_location.is_some() {
9564 len += 1;
9565 }
9566 if self.iceberg_type.is_some() {
9567 len += 1;
9568 }
9569 let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9570 if !self.catalog_name.is_empty() {
9571 struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9572 }
9573 if !self.table_namespace.is_empty() {
9574 struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9575 }
9576 if !self.table_name.is_empty() {
9577 struct_ser.serialize_field("tableName", &self.table_name)?;
9578 }
9579 if let Some(v) = self.metadata_location.as_ref() {
9580 struct_ser.serialize_field("metadataLocation", v)?;
9581 }
9582 if let Some(v) = self.previous_metadata_location.as_ref() {
9583 struct_ser.serialize_field("previousMetadataLocation", v)?;
9584 }
9585 if let Some(v) = self.iceberg_type.as_ref() {
9586 struct_ser.serialize_field("icebergType", v)?;
9587 }
9588 struct_ser.end()
9589 }
9590}
9591impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9592 #[allow(deprecated)]
9593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9594 where
9595 D: serde::Deserializer<'de>,
9596 {
9597 const FIELDS: &[&str] = &[
9598 "catalog_name",
9599 "catalogName",
9600 "table_namespace",
9601 "tableNamespace",
9602 "table_name",
9603 "tableName",
9604 "metadata_location",
9605 "metadataLocation",
9606 "previous_metadata_location",
9607 "previousMetadataLocation",
9608 "iceberg_type",
9609 "icebergType",
9610 ];
9611
9612 #[allow(clippy::enum_variant_names)]
9613 enum GeneratedField {
9614 CatalogName,
9615 TableNamespace,
9616 TableName,
9617 MetadataLocation,
9618 PreviousMetadataLocation,
9619 IcebergType,
9620 }
9621 impl<'de> serde::Deserialize<'de> for GeneratedField {
9622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9623 where
9624 D: serde::Deserializer<'de>,
9625 {
9626 struct GeneratedVisitor;
9627
9628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9629 type Value = GeneratedField;
9630
9631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9632 write!(formatter, "expected one of: {:?}", &FIELDS)
9633 }
9634
9635 #[allow(unused_variables)]
9636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9637 where
9638 E: serde::de::Error,
9639 {
9640 match value {
9641 "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9642 "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9643 "tableName" | "table_name" => Ok(GeneratedField::TableName),
9644 "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9645 "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9646 "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9648 }
9649 }
9650 }
9651 deserializer.deserialize_identifier(GeneratedVisitor)
9652 }
9653 }
9654 struct GeneratedVisitor;
9655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9656 type Value = list_iceberg_tables_response::IcebergTable;
9657
9658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9659 formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9660 }
9661
9662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9663 where
9664 V: serde::de::MapAccess<'de>,
9665 {
9666 let mut catalog_name__ = None;
9667 let mut table_namespace__ = None;
9668 let mut table_name__ = None;
9669 let mut metadata_location__ = None;
9670 let mut previous_metadata_location__ = None;
9671 let mut iceberg_type__ = None;
9672 while let Some(k) = map_.next_key()? {
9673 match k {
9674 GeneratedField::CatalogName => {
9675 if catalog_name__.is_some() {
9676 return Err(serde::de::Error::duplicate_field("catalogName"));
9677 }
9678 catalog_name__ = Some(map_.next_value()?);
9679 }
9680 GeneratedField::TableNamespace => {
9681 if table_namespace__.is_some() {
9682 return Err(serde::de::Error::duplicate_field("tableNamespace"));
9683 }
9684 table_namespace__ = Some(map_.next_value()?);
9685 }
9686 GeneratedField::TableName => {
9687 if table_name__.is_some() {
9688 return Err(serde::de::Error::duplicate_field("tableName"));
9689 }
9690 table_name__ = Some(map_.next_value()?);
9691 }
9692 GeneratedField::MetadataLocation => {
9693 if metadata_location__.is_some() {
9694 return Err(serde::de::Error::duplicate_field("metadataLocation"));
9695 }
9696 metadata_location__ = map_.next_value()?;
9697 }
9698 GeneratedField::PreviousMetadataLocation => {
9699 if previous_metadata_location__.is_some() {
9700 return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9701 }
9702 previous_metadata_location__ = map_.next_value()?;
9703 }
9704 GeneratedField::IcebergType => {
9705 if iceberg_type__.is_some() {
9706 return Err(serde::de::Error::duplicate_field("icebergType"));
9707 }
9708 iceberg_type__ = map_.next_value()?;
9709 }
9710 }
9711 }
9712 Ok(list_iceberg_tables_response::IcebergTable {
9713 catalog_name: catalog_name__.unwrap_or_default(),
9714 table_namespace: table_namespace__.unwrap_or_default(),
9715 table_name: table_name__.unwrap_or_default(),
9716 metadata_location: metadata_location__,
9717 previous_metadata_location: previous_metadata_location__,
9718 iceberg_type: iceberg_type__,
9719 })
9720 }
9721 }
9722 deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9723 }
9724}
9725impl serde::Serialize for ListObjectDependenciesRequest {
9726 #[allow(deprecated)]
9727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9728 where
9729 S: serde::Serializer,
9730 {
9731 use serde::ser::SerializeStruct;
9732 let len = 0;
9733 let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9734 struct_ser.end()
9735 }
9736}
9737impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9738 #[allow(deprecated)]
9739 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9740 where
9741 D: serde::Deserializer<'de>,
9742 {
9743 const FIELDS: &[&str] = &[
9744 ];
9745
9746 #[allow(clippy::enum_variant_names)]
9747 enum GeneratedField {
9748 }
9749 impl<'de> serde::Deserialize<'de> for GeneratedField {
9750 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9751 where
9752 D: serde::Deserializer<'de>,
9753 {
9754 struct GeneratedVisitor;
9755
9756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9757 type Value = GeneratedField;
9758
9759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9760 write!(formatter, "expected one of: {:?}", &FIELDS)
9761 }
9762
9763 #[allow(unused_variables)]
9764 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9765 where
9766 E: serde::de::Error,
9767 {
9768 Err(serde::de::Error::unknown_field(value, FIELDS))
9769 }
9770 }
9771 deserializer.deserialize_identifier(GeneratedVisitor)
9772 }
9773 }
9774 struct GeneratedVisitor;
9775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9776 type Value = ListObjectDependenciesRequest;
9777
9778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9779 formatter.write_str("struct meta.ListObjectDependenciesRequest")
9780 }
9781
9782 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9783 where
9784 V: serde::de::MapAccess<'de>,
9785 {
9786 while map_.next_key::<GeneratedField>()?.is_some() {
9787 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9788 }
9789 Ok(ListObjectDependenciesRequest {
9790 })
9791 }
9792 }
9793 deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9794 }
9795}
9796impl serde::Serialize for ListObjectDependenciesResponse {
9797 #[allow(deprecated)]
9798 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9799 where
9800 S: serde::Serializer,
9801 {
9802 use serde::ser::SerializeStruct;
9803 let mut len = 0;
9804 if !self.dependencies.is_empty() {
9805 len += 1;
9806 }
9807 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9808 if !self.dependencies.is_empty() {
9809 struct_ser.serialize_field("dependencies", &self.dependencies)?;
9810 }
9811 struct_ser.end()
9812 }
9813}
9814impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9815 #[allow(deprecated)]
9816 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9817 where
9818 D: serde::Deserializer<'de>,
9819 {
9820 const FIELDS: &[&str] = &[
9821 "dependencies",
9822 ];
9823
9824 #[allow(clippy::enum_variant_names)]
9825 enum GeneratedField {
9826 Dependencies,
9827 }
9828 impl<'de> serde::Deserialize<'de> for GeneratedField {
9829 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9830 where
9831 D: serde::Deserializer<'de>,
9832 {
9833 struct GeneratedVisitor;
9834
9835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9836 type Value = GeneratedField;
9837
9838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9839 write!(formatter, "expected one of: {:?}", &FIELDS)
9840 }
9841
9842 #[allow(unused_variables)]
9843 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9844 where
9845 E: serde::de::Error,
9846 {
9847 match value {
9848 "dependencies" => Ok(GeneratedField::Dependencies),
9849 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9850 }
9851 }
9852 }
9853 deserializer.deserialize_identifier(GeneratedVisitor)
9854 }
9855 }
9856 struct GeneratedVisitor;
9857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9858 type Value = ListObjectDependenciesResponse;
9859
9860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9861 formatter.write_str("struct meta.ListObjectDependenciesResponse")
9862 }
9863
9864 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
9865 where
9866 V: serde::de::MapAccess<'de>,
9867 {
9868 let mut dependencies__ = None;
9869 while let Some(k) = map_.next_key()? {
9870 match k {
9871 GeneratedField::Dependencies => {
9872 if dependencies__.is_some() {
9873 return Err(serde::de::Error::duplicate_field("dependencies"));
9874 }
9875 dependencies__ = Some(map_.next_value()?);
9876 }
9877 }
9878 }
9879 Ok(ListObjectDependenciesResponse {
9880 dependencies: dependencies__.unwrap_or_default(),
9881 })
9882 }
9883 }
9884 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
9885 }
9886}
9887impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
9888 #[allow(deprecated)]
9889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9890 where
9891 S: serde::Serializer,
9892 {
9893 use serde::ser::SerializeStruct;
9894 let mut len = 0;
9895 if self.object_id != 0 {
9896 len += 1;
9897 }
9898 if self.referenced_object_id != 0 {
9899 len += 1;
9900 }
9901 let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
9902 if self.object_id != 0 {
9903 struct_ser.serialize_field("objectId", &self.object_id)?;
9904 }
9905 if self.referenced_object_id != 0 {
9906 struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
9907 }
9908 struct_ser.end()
9909 }
9910}
9911impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
9912 #[allow(deprecated)]
9913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9914 where
9915 D: serde::Deserializer<'de>,
9916 {
9917 const FIELDS: &[&str] = &[
9918 "object_id",
9919 "objectId",
9920 "referenced_object_id",
9921 "referencedObjectId",
9922 ];
9923
9924 #[allow(clippy::enum_variant_names)]
9925 enum GeneratedField {
9926 ObjectId,
9927 ReferencedObjectId,
9928 }
9929 impl<'de> serde::Deserialize<'de> for GeneratedField {
9930 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9931 where
9932 D: serde::Deserializer<'de>,
9933 {
9934 struct GeneratedVisitor;
9935
9936 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9937 type Value = GeneratedField;
9938
9939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9940 write!(formatter, "expected one of: {:?}", &FIELDS)
9941 }
9942
9943 #[allow(unused_variables)]
9944 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9945 where
9946 E: serde::de::Error,
9947 {
9948 match value {
9949 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
9950 "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
9951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9952 }
9953 }
9954 }
9955 deserializer.deserialize_identifier(GeneratedVisitor)
9956 }
9957 }
9958 struct GeneratedVisitor;
9959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9960 type Value = list_object_dependencies_response::ObjectDependencies;
9961
9962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9963 formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
9964 }
9965
9966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
9967 where
9968 V: serde::de::MapAccess<'de>,
9969 {
9970 let mut object_id__ = None;
9971 let mut referenced_object_id__ = None;
9972 while let Some(k) = map_.next_key()? {
9973 match k {
9974 GeneratedField::ObjectId => {
9975 if object_id__.is_some() {
9976 return Err(serde::de::Error::duplicate_field("objectId"));
9977 }
9978 object_id__ =
9979 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9980 ;
9981 }
9982 GeneratedField::ReferencedObjectId => {
9983 if referenced_object_id__.is_some() {
9984 return Err(serde::de::Error::duplicate_field("referencedObjectId"));
9985 }
9986 referenced_object_id__ =
9987 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9988 ;
9989 }
9990 }
9991 }
9992 Ok(list_object_dependencies_response::ObjectDependencies {
9993 object_id: object_id__.unwrap_or_default(),
9994 referenced_object_id: referenced_object_id__.unwrap_or_default(),
9995 })
9996 }
9997 }
9998 deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
9999 }
10000}
10001impl serde::Serialize for ListRateLimitsRequest {
10002 #[allow(deprecated)]
10003 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10004 where
10005 S: serde::Serializer,
10006 {
10007 use serde::ser::SerializeStruct;
10008 let len = 0;
10009 let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10010 struct_ser.end()
10011 }
10012}
10013impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10014 #[allow(deprecated)]
10015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10016 where
10017 D: serde::Deserializer<'de>,
10018 {
10019 const FIELDS: &[&str] = &[
10020 ];
10021
10022 #[allow(clippy::enum_variant_names)]
10023 enum GeneratedField {
10024 }
10025 impl<'de> serde::Deserialize<'de> for GeneratedField {
10026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10027 where
10028 D: serde::Deserializer<'de>,
10029 {
10030 struct GeneratedVisitor;
10031
10032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10033 type Value = GeneratedField;
10034
10035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10036 write!(formatter, "expected one of: {:?}", &FIELDS)
10037 }
10038
10039 #[allow(unused_variables)]
10040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10041 where
10042 E: serde::de::Error,
10043 {
10044 Err(serde::de::Error::unknown_field(value, FIELDS))
10045 }
10046 }
10047 deserializer.deserialize_identifier(GeneratedVisitor)
10048 }
10049 }
10050 struct GeneratedVisitor;
10051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10052 type Value = ListRateLimitsRequest;
10053
10054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10055 formatter.write_str("struct meta.ListRateLimitsRequest")
10056 }
10057
10058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10059 where
10060 V: serde::de::MapAccess<'de>,
10061 {
10062 while map_.next_key::<GeneratedField>()?.is_some() {
10063 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10064 }
10065 Ok(ListRateLimitsRequest {
10066 })
10067 }
10068 }
10069 deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10070 }
10071}
10072impl serde::Serialize for ListRateLimitsResponse {
10073 #[allow(deprecated)]
10074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10075 where
10076 S: serde::Serializer,
10077 {
10078 use serde::ser::SerializeStruct;
10079 let mut len = 0;
10080 if !self.rate_limits.is_empty() {
10081 len += 1;
10082 }
10083 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10084 if !self.rate_limits.is_empty() {
10085 struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10086 }
10087 struct_ser.end()
10088 }
10089}
10090impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10091 #[allow(deprecated)]
10092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10093 where
10094 D: serde::Deserializer<'de>,
10095 {
10096 const FIELDS: &[&str] = &[
10097 "rate_limits",
10098 "rateLimits",
10099 ];
10100
10101 #[allow(clippy::enum_variant_names)]
10102 enum GeneratedField {
10103 RateLimits,
10104 }
10105 impl<'de> serde::Deserialize<'de> for GeneratedField {
10106 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10107 where
10108 D: serde::Deserializer<'de>,
10109 {
10110 struct GeneratedVisitor;
10111
10112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10113 type Value = GeneratedField;
10114
10115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10116 write!(formatter, "expected one of: {:?}", &FIELDS)
10117 }
10118
10119 #[allow(unused_variables)]
10120 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10121 where
10122 E: serde::de::Error,
10123 {
10124 match value {
10125 "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10127 }
10128 }
10129 }
10130 deserializer.deserialize_identifier(GeneratedVisitor)
10131 }
10132 }
10133 struct GeneratedVisitor;
10134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10135 type Value = ListRateLimitsResponse;
10136
10137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10138 formatter.write_str("struct meta.ListRateLimitsResponse")
10139 }
10140
10141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
10142 where
10143 V: serde::de::MapAccess<'de>,
10144 {
10145 let mut rate_limits__ = None;
10146 while let Some(k) = map_.next_key()? {
10147 match k {
10148 GeneratedField::RateLimits => {
10149 if rate_limits__.is_some() {
10150 return Err(serde::de::Error::duplicate_field("rateLimits"));
10151 }
10152 rate_limits__ = Some(map_.next_value()?);
10153 }
10154 }
10155 }
10156 Ok(ListRateLimitsResponse {
10157 rate_limits: rate_limits__.unwrap_or_default(),
10158 })
10159 }
10160 }
10161 deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
10162 }
10163}
10164impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
10165 #[allow(deprecated)]
10166 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10167 where
10168 S: serde::Serializer,
10169 {
10170 use serde::ser::SerializeStruct;
10171 let mut len = 0;
10172 if self.fragment_id != 0 {
10173 len += 1;
10174 }
10175 if self.job_id != 0 {
10176 len += 1;
10177 }
10178 if self.fragment_type_mask != 0 {
10179 len += 1;
10180 }
10181 if self.rate_limit != 0 {
10182 len += 1;
10183 }
10184 if !self.node_name.is_empty() {
10185 len += 1;
10186 }
10187 let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
10188 if self.fragment_id != 0 {
10189 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10190 }
10191 if self.job_id != 0 {
10192 struct_ser.serialize_field("jobId", &self.job_id)?;
10193 }
10194 if self.fragment_type_mask != 0 {
10195 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10196 }
10197 if self.rate_limit != 0 {
10198 struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
10199 }
10200 if !self.node_name.is_empty() {
10201 struct_ser.serialize_field("nodeName", &self.node_name)?;
10202 }
10203 struct_ser.end()
10204 }
10205}
10206impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
10207 #[allow(deprecated)]
10208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10209 where
10210 D: serde::Deserializer<'de>,
10211 {
10212 const FIELDS: &[&str] = &[
10213 "fragment_id",
10214 "fragmentId",
10215 "job_id",
10216 "jobId",
10217 "fragment_type_mask",
10218 "fragmentTypeMask",
10219 "rate_limit",
10220 "rateLimit",
10221 "node_name",
10222 "nodeName",
10223 ];
10224
10225 #[allow(clippy::enum_variant_names)]
10226 enum GeneratedField {
10227 FragmentId,
10228 JobId,
10229 FragmentTypeMask,
10230 RateLimit,
10231 NodeName,
10232 }
10233 impl<'de> serde::Deserialize<'de> for GeneratedField {
10234 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10235 where
10236 D: serde::Deserializer<'de>,
10237 {
10238 struct GeneratedVisitor;
10239
10240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10241 type Value = GeneratedField;
10242
10243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10244 write!(formatter, "expected one of: {:?}", &FIELDS)
10245 }
10246
10247 #[allow(unused_variables)]
10248 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10249 where
10250 E: serde::de::Error,
10251 {
10252 match value {
10253 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10254 "jobId" | "job_id" => Ok(GeneratedField::JobId),
10255 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10256 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10257 "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
10258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10259 }
10260 }
10261 }
10262 deserializer.deserialize_identifier(GeneratedVisitor)
10263 }
10264 }
10265 struct GeneratedVisitor;
10266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10267 type Value = list_rate_limits_response::RateLimitInfo;
10268
10269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10270 formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
10271 }
10272
10273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
10274 where
10275 V: serde::de::MapAccess<'de>,
10276 {
10277 let mut fragment_id__ = None;
10278 let mut job_id__ = None;
10279 let mut fragment_type_mask__ = None;
10280 let mut rate_limit__ = None;
10281 let mut node_name__ = None;
10282 while let Some(k) = map_.next_key()? {
10283 match k {
10284 GeneratedField::FragmentId => {
10285 if fragment_id__.is_some() {
10286 return Err(serde::de::Error::duplicate_field("fragmentId"));
10287 }
10288 fragment_id__ =
10289 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10290 ;
10291 }
10292 GeneratedField::JobId => {
10293 if job_id__.is_some() {
10294 return Err(serde::de::Error::duplicate_field("jobId"));
10295 }
10296 job_id__ =
10297 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10298 ;
10299 }
10300 GeneratedField::FragmentTypeMask => {
10301 if fragment_type_mask__.is_some() {
10302 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10303 }
10304 fragment_type_mask__ =
10305 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10306 ;
10307 }
10308 GeneratedField::RateLimit => {
10309 if rate_limit__.is_some() {
10310 return Err(serde::de::Error::duplicate_field("rateLimit"));
10311 }
10312 rate_limit__ =
10313 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10314 ;
10315 }
10316 GeneratedField::NodeName => {
10317 if node_name__.is_some() {
10318 return Err(serde::de::Error::duplicate_field("nodeName"));
10319 }
10320 node_name__ = Some(map_.next_value()?);
10321 }
10322 }
10323 }
10324 Ok(list_rate_limits_response::RateLimitInfo {
10325 fragment_id: fragment_id__.unwrap_or_default(),
10326 job_id: job_id__.unwrap_or_default(),
10327 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10328 rate_limit: rate_limit__.unwrap_or_default(),
10329 node_name: node_name__.unwrap_or_default(),
10330 })
10331 }
10332 }
10333 deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10334 }
10335}
10336impl serde::Serialize for ListStreamingJobStatesRequest {
10337 #[allow(deprecated)]
10338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10339 where
10340 S: serde::Serializer,
10341 {
10342 use serde::ser::SerializeStruct;
10343 let len = 0;
10344 let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
10345 struct_ser.end()
10346 }
10347}
10348impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
10349 #[allow(deprecated)]
10350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10351 where
10352 D: serde::Deserializer<'de>,
10353 {
10354 const FIELDS: &[&str] = &[
10355 ];
10356
10357 #[allow(clippy::enum_variant_names)]
10358 enum GeneratedField {
10359 }
10360 impl<'de> serde::Deserialize<'de> for GeneratedField {
10361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10362 where
10363 D: serde::Deserializer<'de>,
10364 {
10365 struct GeneratedVisitor;
10366
10367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10368 type Value = GeneratedField;
10369
10370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10371 write!(formatter, "expected one of: {:?}", &FIELDS)
10372 }
10373
10374 #[allow(unused_variables)]
10375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10376 where
10377 E: serde::de::Error,
10378 {
10379 Err(serde::de::Error::unknown_field(value, FIELDS))
10380 }
10381 }
10382 deserializer.deserialize_identifier(GeneratedVisitor)
10383 }
10384 }
10385 struct GeneratedVisitor;
10386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10387 type Value = ListStreamingJobStatesRequest;
10388
10389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10390 formatter.write_str("struct meta.ListStreamingJobStatesRequest")
10391 }
10392
10393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
10394 where
10395 V: serde::de::MapAccess<'de>,
10396 {
10397 while map_.next_key::<GeneratedField>()?.is_some() {
10398 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10399 }
10400 Ok(ListStreamingJobStatesRequest {
10401 })
10402 }
10403 }
10404 deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
10405 }
10406}
10407impl serde::Serialize for ListStreamingJobStatesResponse {
10408 #[allow(deprecated)]
10409 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10410 where
10411 S: serde::Serializer,
10412 {
10413 use serde::ser::SerializeStruct;
10414 let mut len = 0;
10415 if !self.states.is_empty() {
10416 len += 1;
10417 }
10418 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
10419 if !self.states.is_empty() {
10420 struct_ser.serialize_field("states", &self.states)?;
10421 }
10422 struct_ser.end()
10423 }
10424}
10425impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
10426 #[allow(deprecated)]
10427 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10428 where
10429 D: serde::Deserializer<'de>,
10430 {
10431 const FIELDS: &[&str] = &[
10432 "states",
10433 ];
10434
10435 #[allow(clippy::enum_variant_names)]
10436 enum GeneratedField {
10437 States,
10438 }
10439 impl<'de> serde::Deserialize<'de> for GeneratedField {
10440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10441 where
10442 D: serde::Deserializer<'de>,
10443 {
10444 struct GeneratedVisitor;
10445
10446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10447 type Value = GeneratedField;
10448
10449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10450 write!(formatter, "expected one of: {:?}", &FIELDS)
10451 }
10452
10453 #[allow(unused_variables)]
10454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10455 where
10456 E: serde::de::Error,
10457 {
10458 match value {
10459 "states" => Ok(GeneratedField::States),
10460 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10461 }
10462 }
10463 }
10464 deserializer.deserialize_identifier(GeneratedVisitor)
10465 }
10466 }
10467 struct GeneratedVisitor;
10468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10469 type Value = ListStreamingJobStatesResponse;
10470
10471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10472 formatter.write_str("struct meta.ListStreamingJobStatesResponse")
10473 }
10474
10475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
10476 where
10477 V: serde::de::MapAccess<'de>,
10478 {
10479 let mut states__ = None;
10480 while let Some(k) = map_.next_key()? {
10481 match k {
10482 GeneratedField::States => {
10483 if states__.is_some() {
10484 return Err(serde::de::Error::duplicate_field("states"));
10485 }
10486 states__ = Some(map_.next_value()?);
10487 }
10488 }
10489 }
10490 Ok(ListStreamingJobStatesResponse {
10491 states: states__.unwrap_or_default(),
10492 })
10493 }
10494 }
10495 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10496 }
10497}
10498impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10499 #[allow(deprecated)]
10500 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10501 where
10502 S: serde::Serializer,
10503 {
10504 use serde::ser::SerializeStruct;
10505 let mut len = 0;
10506 if self.table_id != 0 {
10507 len += 1;
10508 }
10509 if self.state != 0 {
10510 len += 1;
10511 }
10512 if self.parallelism.is_some() {
10513 len += 1;
10514 }
10515 if self.max_parallelism != 0 {
10516 len += 1;
10517 }
10518 if !self.name.is_empty() {
10519 len += 1;
10520 }
10521 if !self.resource_group.is_empty() {
10522 len += 1;
10523 }
10524 if self.database_id != 0 {
10525 len += 1;
10526 }
10527 if self.schema_id != 0 {
10528 len += 1;
10529 }
10530 let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10531 if self.table_id != 0 {
10532 struct_ser.serialize_field("tableId", &self.table_id)?;
10533 }
10534 if self.state != 0 {
10535 let v = table_fragments::State::try_from(self.state)
10536 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10537 struct_ser.serialize_field("state", &v)?;
10538 }
10539 if let Some(v) = self.parallelism.as_ref() {
10540 struct_ser.serialize_field("parallelism", v)?;
10541 }
10542 if self.max_parallelism != 0 {
10543 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10544 }
10545 if !self.name.is_empty() {
10546 struct_ser.serialize_field("name", &self.name)?;
10547 }
10548 if !self.resource_group.is_empty() {
10549 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10550 }
10551 if self.database_id != 0 {
10552 struct_ser.serialize_field("databaseId", &self.database_id)?;
10553 }
10554 if self.schema_id != 0 {
10555 struct_ser.serialize_field("schemaId", &self.schema_id)?;
10556 }
10557 struct_ser.end()
10558 }
10559}
10560impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10561 #[allow(deprecated)]
10562 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10563 where
10564 D: serde::Deserializer<'de>,
10565 {
10566 const FIELDS: &[&str] = &[
10567 "table_id",
10568 "tableId",
10569 "state",
10570 "parallelism",
10571 "max_parallelism",
10572 "maxParallelism",
10573 "name",
10574 "resource_group",
10575 "resourceGroup",
10576 "database_id",
10577 "databaseId",
10578 "schema_id",
10579 "schemaId",
10580 ];
10581
10582 #[allow(clippy::enum_variant_names)]
10583 enum GeneratedField {
10584 TableId,
10585 State,
10586 Parallelism,
10587 MaxParallelism,
10588 Name,
10589 ResourceGroup,
10590 DatabaseId,
10591 SchemaId,
10592 }
10593 impl<'de> serde::Deserialize<'de> for GeneratedField {
10594 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10595 where
10596 D: serde::Deserializer<'de>,
10597 {
10598 struct GeneratedVisitor;
10599
10600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10601 type Value = GeneratedField;
10602
10603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10604 write!(formatter, "expected one of: {:?}", &FIELDS)
10605 }
10606
10607 #[allow(unused_variables)]
10608 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10609 where
10610 E: serde::de::Error,
10611 {
10612 match value {
10613 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10614 "state" => Ok(GeneratedField::State),
10615 "parallelism" => Ok(GeneratedField::Parallelism),
10616 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10617 "name" => Ok(GeneratedField::Name),
10618 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10619 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
10620 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
10621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10622 }
10623 }
10624 }
10625 deserializer.deserialize_identifier(GeneratedVisitor)
10626 }
10627 }
10628 struct GeneratedVisitor;
10629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10630 type Value = list_streaming_job_states_response::StreamingJobState;
10631
10632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10633 formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10634 }
10635
10636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10637 where
10638 V: serde::de::MapAccess<'de>,
10639 {
10640 let mut table_id__ = None;
10641 let mut state__ = None;
10642 let mut parallelism__ = None;
10643 let mut max_parallelism__ = None;
10644 let mut name__ = None;
10645 let mut resource_group__ = None;
10646 let mut database_id__ = None;
10647 let mut schema_id__ = None;
10648 while let Some(k) = map_.next_key()? {
10649 match k {
10650 GeneratedField::TableId => {
10651 if table_id__.is_some() {
10652 return Err(serde::de::Error::duplicate_field("tableId"));
10653 }
10654 table_id__ =
10655 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10656 ;
10657 }
10658 GeneratedField::State => {
10659 if state__.is_some() {
10660 return Err(serde::de::Error::duplicate_field("state"));
10661 }
10662 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10663 }
10664 GeneratedField::Parallelism => {
10665 if parallelism__.is_some() {
10666 return Err(serde::de::Error::duplicate_field("parallelism"));
10667 }
10668 parallelism__ = map_.next_value()?;
10669 }
10670 GeneratedField::MaxParallelism => {
10671 if max_parallelism__.is_some() {
10672 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10673 }
10674 max_parallelism__ =
10675 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10676 ;
10677 }
10678 GeneratedField::Name => {
10679 if name__.is_some() {
10680 return Err(serde::de::Error::duplicate_field("name"));
10681 }
10682 name__ = Some(map_.next_value()?);
10683 }
10684 GeneratedField::ResourceGroup => {
10685 if resource_group__.is_some() {
10686 return Err(serde::de::Error::duplicate_field("resourceGroup"));
10687 }
10688 resource_group__ = Some(map_.next_value()?);
10689 }
10690 GeneratedField::DatabaseId => {
10691 if database_id__.is_some() {
10692 return Err(serde::de::Error::duplicate_field("databaseId"));
10693 }
10694 database_id__ =
10695 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10696 ;
10697 }
10698 GeneratedField::SchemaId => {
10699 if schema_id__.is_some() {
10700 return Err(serde::de::Error::duplicate_field("schemaId"));
10701 }
10702 schema_id__ =
10703 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10704 ;
10705 }
10706 }
10707 }
10708 Ok(list_streaming_job_states_response::StreamingJobState {
10709 table_id: table_id__.unwrap_or_default(),
10710 state: state__.unwrap_or_default(),
10711 parallelism: parallelism__,
10712 max_parallelism: max_parallelism__.unwrap_or_default(),
10713 name: name__.unwrap_or_default(),
10714 resource_group: resource_group__.unwrap_or_default(),
10715 database_id: database_id__.unwrap_or_default(),
10716 schema_id: schema_id__.unwrap_or_default(),
10717 })
10718 }
10719 }
10720 deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10721 }
10722}
10723impl serde::Serialize for ListTableFragmentsRequest {
10724 #[allow(deprecated)]
10725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10726 where
10727 S: serde::Serializer,
10728 {
10729 use serde::ser::SerializeStruct;
10730 let mut len = 0;
10731 if !self.table_ids.is_empty() {
10732 len += 1;
10733 }
10734 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10735 if !self.table_ids.is_empty() {
10736 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10737 }
10738 struct_ser.end()
10739 }
10740}
10741impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10742 #[allow(deprecated)]
10743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10744 where
10745 D: serde::Deserializer<'de>,
10746 {
10747 const FIELDS: &[&str] = &[
10748 "table_ids",
10749 "tableIds",
10750 ];
10751
10752 #[allow(clippy::enum_variant_names)]
10753 enum GeneratedField {
10754 TableIds,
10755 }
10756 impl<'de> serde::Deserialize<'de> for GeneratedField {
10757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10758 where
10759 D: serde::Deserializer<'de>,
10760 {
10761 struct GeneratedVisitor;
10762
10763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10764 type Value = GeneratedField;
10765
10766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10767 write!(formatter, "expected one of: {:?}", &FIELDS)
10768 }
10769
10770 #[allow(unused_variables)]
10771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10772 where
10773 E: serde::de::Error,
10774 {
10775 match value {
10776 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10778 }
10779 }
10780 }
10781 deserializer.deserialize_identifier(GeneratedVisitor)
10782 }
10783 }
10784 struct GeneratedVisitor;
10785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10786 type Value = ListTableFragmentsRequest;
10787
10788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10789 formatter.write_str("struct meta.ListTableFragmentsRequest")
10790 }
10791
10792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10793 where
10794 V: serde::de::MapAccess<'de>,
10795 {
10796 let mut table_ids__ = None;
10797 while let Some(k) = map_.next_key()? {
10798 match k {
10799 GeneratedField::TableIds => {
10800 if table_ids__.is_some() {
10801 return Err(serde::de::Error::duplicate_field("tableIds"));
10802 }
10803 table_ids__ =
10804 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10805 .into_iter().map(|x| x.0).collect())
10806 ;
10807 }
10808 }
10809 }
10810 Ok(ListTableFragmentsRequest {
10811 table_ids: table_ids__.unwrap_or_default(),
10812 })
10813 }
10814 }
10815 deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10816 }
10817}
10818impl serde::Serialize for ListTableFragmentsResponse {
10819 #[allow(deprecated)]
10820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10821 where
10822 S: serde::Serializer,
10823 {
10824 use serde::ser::SerializeStruct;
10825 let mut len = 0;
10826 if !self.table_fragments.is_empty() {
10827 len += 1;
10828 }
10829 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10830 if !self.table_fragments.is_empty() {
10831 struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10832 }
10833 struct_ser.end()
10834 }
10835}
10836impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10837 #[allow(deprecated)]
10838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10839 where
10840 D: serde::Deserializer<'de>,
10841 {
10842 const FIELDS: &[&str] = &[
10843 "table_fragments",
10844 "tableFragments",
10845 ];
10846
10847 #[allow(clippy::enum_variant_names)]
10848 enum GeneratedField {
10849 TableFragments,
10850 }
10851 impl<'de> serde::Deserialize<'de> for GeneratedField {
10852 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10853 where
10854 D: serde::Deserializer<'de>,
10855 {
10856 struct GeneratedVisitor;
10857
10858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10859 type Value = GeneratedField;
10860
10861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10862 write!(formatter, "expected one of: {:?}", &FIELDS)
10863 }
10864
10865 #[allow(unused_variables)]
10866 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10867 where
10868 E: serde::de::Error,
10869 {
10870 match value {
10871 "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
10872 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10873 }
10874 }
10875 }
10876 deserializer.deserialize_identifier(GeneratedVisitor)
10877 }
10878 }
10879 struct GeneratedVisitor;
10880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10881 type Value = ListTableFragmentsResponse;
10882
10883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10884 formatter.write_str("struct meta.ListTableFragmentsResponse")
10885 }
10886
10887 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
10888 where
10889 V: serde::de::MapAccess<'de>,
10890 {
10891 let mut table_fragments__ = None;
10892 while let Some(k) = map_.next_key()? {
10893 match k {
10894 GeneratedField::TableFragments => {
10895 if table_fragments__.is_some() {
10896 return Err(serde::de::Error::duplicate_field("tableFragments"));
10897 }
10898 table_fragments__ = Some(
10899 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10900 .into_iter().map(|(k,v)| (k.0, v)).collect()
10901 );
10902 }
10903 }
10904 }
10905 Ok(ListTableFragmentsResponse {
10906 table_fragments: table_fragments__.unwrap_or_default(),
10907 })
10908 }
10909 }
10910 deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
10911 }
10912}
10913impl serde::Serialize for list_table_fragments_response::ActorInfo {
10914 #[allow(deprecated)]
10915 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10916 where
10917 S: serde::Serializer,
10918 {
10919 use serde::ser::SerializeStruct;
10920 let mut len = 0;
10921 if self.id != 0 {
10922 len += 1;
10923 }
10924 if self.node.is_some() {
10925 len += 1;
10926 }
10927 if !self.dispatcher.is_empty() {
10928 len += 1;
10929 }
10930 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
10931 if self.id != 0 {
10932 struct_ser.serialize_field("id", &self.id)?;
10933 }
10934 if let Some(v) = self.node.as_ref() {
10935 struct_ser.serialize_field("node", v)?;
10936 }
10937 if !self.dispatcher.is_empty() {
10938 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10939 }
10940 struct_ser.end()
10941 }
10942}
10943impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
10944 #[allow(deprecated)]
10945 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10946 where
10947 D: serde::Deserializer<'de>,
10948 {
10949 const FIELDS: &[&str] = &[
10950 "id",
10951 "node",
10952 "dispatcher",
10953 ];
10954
10955 #[allow(clippy::enum_variant_names)]
10956 enum GeneratedField {
10957 Id,
10958 Node,
10959 Dispatcher,
10960 }
10961 impl<'de> serde::Deserialize<'de> for GeneratedField {
10962 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10963 where
10964 D: serde::Deserializer<'de>,
10965 {
10966 struct GeneratedVisitor;
10967
10968 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10969 type Value = GeneratedField;
10970
10971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10972 write!(formatter, "expected one of: {:?}", &FIELDS)
10973 }
10974
10975 #[allow(unused_variables)]
10976 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10977 where
10978 E: serde::de::Error,
10979 {
10980 match value {
10981 "id" => Ok(GeneratedField::Id),
10982 "node" => Ok(GeneratedField::Node),
10983 "dispatcher" => Ok(GeneratedField::Dispatcher),
10984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10985 }
10986 }
10987 }
10988 deserializer.deserialize_identifier(GeneratedVisitor)
10989 }
10990 }
10991 struct GeneratedVisitor;
10992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10993 type Value = list_table_fragments_response::ActorInfo;
10994
10995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10996 formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
10997 }
10998
10999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
11000 where
11001 V: serde::de::MapAccess<'de>,
11002 {
11003 let mut id__ = None;
11004 let mut node__ = None;
11005 let mut dispatcher__ = None;
11006 while let Some(k) = map_.next_key()? {
11007 match k {
11008 GeneratedField::Id => {
11009 if id__.is_some() {
11010 return Err(serde::de::Error::duplicate_field("id"));
11011 }
11012 id__ =
11013 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11014 ;
11015 }
11016 GeneratedField::Node => {
11017 if node__.is_some() {
11018 return Err(serde::de::Error::duplicate_field("node"));
11019 }
11020 node__ = map_.next_value()?;
11021 }
11022 GeneratedField::Dispatcher => {
11023 if dispatcher__.is_some() {
11024 return Err(serde::de::Error::duplicate_field("dispatcher"));
11025 }
11026 dispatcher__ = Some(map_.next_value()?);
11027 }
11028 }
11029 }
11030 Ok(list_table_fragments_response::ActorInfo {
11031 id: id__.unwrap_or_default(),
11032 node: node__,
11033 dispatcher: dispatcher__.unwrap_or_default(),
11034 })
11035 }
11036 }
11037 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
11038 }
11039}
11040impl serde::Serialize for list_table_fragments_response::FragmentInfo {
11041 #[allow(deprecated)]
11042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11043 where
11044 S: serde::Serializer,
11045 {
11046 use serde::ser::SerializeStruct;
11047 let mut len = 0;
11048 if self.id != 0 {
11049 len += 1;
11050 }
11051 if !self.actors.is_empty() {
11052 len += 1;
11053 }
11054 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
11055 if self.id != 0 {
11056 struct_ser.serialize_field("id", &self.id)?;
11057 }
11058 if !self.actors.is_empty() {
11059 struct_ser.serialize_field("actors", &self.actors)?;
11060 }
11061 struct_ser.end()
11062 }
11063}
11064impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
11065 #[allow(deprecated)]
11066 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11067 where
11068 D: serde::Deserializer<'de>,
11069 {
11070 const FIELDS: &[&str] = &[
11071 "id",
11072 "actors",
11073 ];
11074
11075 #[allow(clippy::enum_variant_names)]
11076 enum GeneratedField {
11077 Id,
11078 Actors,
11079 }
11080 impl<'de> serde::Deserialize<'de> for GeneratedField {
11081 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11082 where
11083 D: serde::Deserializer<'de>,
11084 {
11085 struct GeneratedVisitor;
11086
11087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11088 type Value = GeneratedField;
11089
11090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11091 write!(formatter, "expected one of: {:?}", &FIELDS)
11092 }
11093
11094 #[allow(unused_variables)]
11095 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11096 where
11097 E: serde::de::Error,
11098 {
11099 match value {
11100 "id" => Ok(GeneratedField::Id),
11101 "actors" => Ok(GeneratedField::Actors),
11102 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11103 }
11104 }
11105 }
11106 deserializer.deserialize_identifier(GeneratedVisitor)
11107 }
11108 }
11109 struct GeneratedVisitor;
11110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11111 type Value = list_table_fragments_response::FragmentInfo;
11112
11113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11114 formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
11115 }
11116
11117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
11118 where
11119 V: serde::de::MapAccess<'de>,
11120 {
11121 let mut id__ = None;
11122 let mut actors__ = None;
11123 while let Some(k) = map_.next_key()? {
11124 match k {
11125 GeneratedField::Id => {
11126 if id__.is_some() {
11127 return Err(serde::de::Error::duplicate_field("id"));
11128 }
11129 id__ =
11130 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11131 ;
11132 }
11133 GeneratedField::Actors => {
11134 if actors__.is_some() {
11135 return Err(serde::de::Error::duplicate_field("actors"));
11136 }
11137 actors__ = Some(map_.next_value()?);
11138 }
11139 }
11140 }
11141 Ok(list_table_fragments_response::FragmentInfo {
11142 id: id__.unwrap_or_default(),
11143 actors: actors__.unwrap_or_default(),
11144 })
11145 }
11146 }
11147 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
11148 }
11149}
11150impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
11151 #[allow(deprecated)]
11152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11153 where
11154 S: serde::Serializer,
11155 {
11156 use serde::ser::SerializeStruct;
11157 let mut len = 0;
11158 if !self.fragments.is_empty() {
11159 len += 1;
11160 }
11161 if self.ctx.is_some() {
11162 len += 1;
11163 }
11164 let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
11165 if !self.fragments.is_empty() {
11166 struct_ser.serialize_field("fragments", &self.fragments)?;
11167 }
11168 if let Some(v) = self.ctx.as_ref() {
11169 struct_ser.serialize_field("ctx", v)?;
11170 }
11171 struct_ser.end()
11172 }
11173}
11174impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
11175 #[allow(deprecated)]
11176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11177 where
11178 D: serde::Deserializer<'de>,
11179 {
11180 const FIELDS: &[&str] = &[
11181 "fragments",
11182 "ctx",
11183 ];
11184
11185 #[allow(clippy::enum_variant_names)]
11186 enum GeneratedField {
11187 Fragments,
11188 Ctx,
11189 }
11190 impl<'de> serde::Deserialize<'de> for GeneratedField {
11191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11192 where
11193 D: serde::Deserializer<'de>,
11194 {
11195 struct GeneratedVisitor;
11196
11197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11198 type Value = GeneratedField;
11199
11200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11201 write!(formatter, "expected one of: {:?}", &FIELDS)
11202 }
11203
11204 #[allow(unused_variables)]
11205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11206 where
11207 E: serde::de::Error,
11208 {
11209 match value {
11210 "fragments" => Ok(GeneratedField::Fragments),
11211 "ctx" => Ok(GeneratedField::Ctx),
11212 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11213 }
11214 }
11215 }
11216 deserializer.deserialize_identifier(GeneratedVisitor)
11217 }
11218 }
11219 struct GeneratedVisitor;
11220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11221 type Value = list_table_fragments_response::TableFragmentInfo;
11222
11223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11224 formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
11225 }
11226
11227 fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
11228 where
11229 V: serde::de::MapAccess<'de>,
11230 {
11231 let mut fragments__ = None;
11232 let mut ctx__ = None;
11233 while let Some(k) = map_.next_key()? {
11234 match k {
11235 GeneratedField::Fragments => {
11236 if fragments__.is_some() {
11237 return Err(serde::de::Error::duplicate_field("fragments"));
11238 }
11239 fragments__ = Some(map_.next_value()?);
11240 }
11241 GeneratedField::Ctx => {
11242 if ctx__.is_some() {
11243 return Err(serde::de::Error::duplicate_field("ctx"));
11244 }
11245 ctx__ = map_.next_value()?;
11246 }
11247 }
11248 }
11249 Ok(list_table_fragments_response::TableFragmentInfo {
11250 fragments: fragments__.unwrap_or_default(),
11251 ctx: ctx__,
11252 })
11253 }
11254 }
11255 deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
11256 }
11257}
11258impl serde::Serialize for MembersRequest {
11259 #[allow(deprecated)]
11260 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11261 where
11262 S: serde::Serializer,
11263 {
11264 use serde::ser::SerializeStruct;
11265 let len = 0;
11266 let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
11267 struct_ser.end()
11268 }
11269}
11270impl<'de> serde::Deserialize<'de> for MembersRequest {
11271 #[allow(deprecated)]
11272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11273 where
11274 D: serde::Deserializer<'de>,
11275 {
11276 const FIELDS: &[&str] = &[
11277 ];
11278
11279 #[allow(clippy::enum_variant_names)]
11280 enum GeneratedField {
11281 }
11282 impl<'de> serde::Deserialize<'de> for GeneratedField {
11283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11284 where
11285 D: serde::Deserializer<'de>,
11286 {
11287 struct GeneratedVisitor;
11288
11289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11290 type Value = GeneratedField;
11291
11292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11293 write!(formatter, "expected one of: {:?}", &FIELDS)
11294 }
11295
11296 #[allow(unused_variables)]
11297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11298 where
11299 E: serde::de::Error,
11300 {
11301 Err(serde::de::Error::unknown_field(value, FIELDS))
11302 }
11303 }
11304 deserializer.deserialize_identifier(GeneratedVisitor)
11305 }
11306 }
11307 struct GeneratedVisitor;
11308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11309 type Value = MembersRequest;
11310
11311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11312 formatter.write_str("struct meta.MembersRequest")
11313 }
11314
11315 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
11316 where
11317 V: serde::de::MapAccess<'de>,
11318 {
11319 while map_.next_key::<GeneratedField>()?.is_some() {
11320 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11321 }
11322 Ok(MembersRequest {
11323 })
11324 }
11325 }
11326 deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
11327 }
11328}
11329impl serde::Serialize for MembersResponse {
11330 #[allow(deprecated)]
11331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11332 where
11333 S: serde::Serializer,
11334 {
11335 use serde::ser::SerializeStruct;
11336 let mut len = 0;
11337 if !self.members.is_empty() {
11338 len += 1;
11339 }
11340 let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
11341 if !self.members.is_empty() {
11342 struct_ser.serialize_field("members", &self.members)?;
11343 }
11344 struct_ser.end()
11345 }
11346}
11347impl<'de> serde::Deserialize<'de> for MembersResponse {
11348 #[allow(deprecated)]
11349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11350 where
11351 D: serde::Deserializer<'de>,
11352 {
11353 const FIELDS: &[&str] = &[
11354 "members",
11355 ];
11356
11357 #[allow(clippy::enum_variant_names)]
11358 enum GeneratedField {
11359 Members,
11360 }
11361 impl<'de> serde::Deserialize<'de> for GeneratedField {
11362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11363 where
11364 D: serde::Deserializer<'de>,
11365 {
11366 struct GeneratedVisitor;
11367
11368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11369 type Value = GeneratedField;
11370
11371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11372 write!(formatter, "expected one of: {:?}", &FIELDS)
11373 }
11374
11375 #[allow(unused_variables)]
11376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11377 where
11378 E: serde::de::Error,
11379 {
11380 match value {
11381 "members" => Ok(GeneratedField::Members),
11382 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11383 }
11384 }
11385 }
11386 deserializer.deserialize_identifier(GeneratedVisitor)
11387 }
11388 }
11389 struct GeneratedVisitor;
11390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11391 type Value = MembersResponse;
11392
11393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11394 formatter.write_str("struct meta.MembersResponse")
11395 }
11396
11397 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11398 where
11399 V: serde::de::MapAccess<'de>,
11400 {
11401 let mut members__ = None;
11402 while let Some(k) = map_.next_key()? {
11403 match k {
11404 GeneratedField::Members => {
11405 if members__.is_some() {
11406 return Err(serde::de::Error::duplicate_field("members"));
11407 }
11408 members__ = Some(map_.next_value()?);
11409 }
11410 }
11411 }
11412 Ok(MembersResponse {
11413 members: members__.unwrap_or_default(),
11414 })
11415 }
11416 }
11417 deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11418 }
11419}
11420impl serde::Serialize for MetaMember {
11421 #[allow(deprecated)]
11422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11423 where
11424 S: serde::Serializer,
11425 {
11426 use serde::ser::SerializeStruct;
11427 let mut len = 0;
11428 if self.address.is_some() {
11429 len += 1;
11430 }
11431 if self.is_leader {
11432 len += 1;
11433 }
11434 let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11435 if let Some(v) = self.address.as_ref() {
11436 struct_ser.serialize_field("address", v)?;
11437 }
11438 if self.is_leader {
11439 struct_ser.serialize_field("isLeader", &self.is_leader)?;
11440 }
11441 struct_ser.end()
11442 }
11443}
11444impl<'de> serde::Deserialize<'de> for MetaMember {
11445 #[allow(deprecated)]
11446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11447 where
11448 D: serde::Deserializer<'de>,
11449 {
11450 const FIELDS: &[&str] = &[
11451 "address",
11452 "is_leader",
11453 "isLeader",
11454 ];
11455
11456 #[allow(clippy::enum_variant_names)]
11457 enum GeneratedField {
11458 Address,
11459 IsLeader,
11460 }
11461 impl<'de> serde::Deserialize<'de> for GeneratedField {
11462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11463 where
11464 D: serde::Deserializer<'de>,
11465 {
11466 struct GeneratedVisitor;
11467
11468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11469 type Value = GeneratedField;
11470
11471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11472 write!(formatter, "expected one of: {:?}", &FIELDS)
11473 }
11474
11475 #[allow(unused_variables)]
11476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11477 where
11478 E: serde::de::Error,
11479 {
11480 match value {
11481 "address" => Ok(GeneratedField::Address),
11482 "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11484 }
11485 }
11486 }
11487 deserializer.deserialize_identifier(GeneratedVisitor)
11488 }
11489 }
11490 struct GeneratedVisitor;
11491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11492 type Value = MetaMember;
11493
11494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11495 formatter.write_str("struct meta.MetaMember")
11496 }
11497
11498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11499 where
11500 V: serde::de::MapAccess<'de>,
11501 {
11502 let mut address__ = None;
11503 let mut is_leader__ = None;
11504 while let Some(k) = map_.next_key()? {
11505 match k {
11506 GeneratedField::Address => {
11507 if address__.is_some() {
11508 return Err(serde::de::Error::duplicate_field("address"));
11509 }
11510 address__ = map_.next_value()?;
11511 }
11512 GeneratedField::IsLeader => {
11513 if is_leader__.is_some() {
11514 return Err(serde::de::Error::duplicate_field("isLeader"));
11515 }
11516 is_leader__ = Some(map_.next_value()?);
11517 }
11518 }
11519 }
11520 Ok(MetaMember {
11521 address: address__,
11522 is_leader: is_leader__.unwrap_or_default(),
11523 })
11524 }
11525 }
11526 deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11527 }
11528}
11529impl serde::Serialize for MetaSnapshot {
11530 #[allow(deprecated)]
11531 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11532 where
11533 S: serde::Serializer,
11534 {
11535 use serde::ser::SerializeStruct;
11536 let mut len = 0;
11537 if !self.databases.is_empty() {
11538 len += 1;
11539 }
11540 if !self.schemas.is_empty() {
11541 len += 1;
11542 }
11543 if !self.sources.is_empty() {
11544 len += 1;
11545 }
11546 if !self.sinks.is_empty() {
11547 len += 1;
11548 }
11549 if !self.tables.is_empty() {
11550 len += 1;
11551 }
11552 if !self.indexes.is_empty() {
11553 len += 1;
11554 }
11555 if !self.views.is_empty() {
11556 len += 1;
11557 }
11558 if !self.functions.is_empty() {
11559 len += 1;
11560 }
11561 if !self.connections.is_empty() {
11562 len += 1;
11563 }
11564 if !self.subscriptions.is_empty() {
11565 len += 1;
11566 }
11567 if !self.users.is_empty() {
11568 len += 1;
11569 }
11570 if self.session_params.is_some() {
11571 len += 1;
11572 }
11573 if !self.secrets.is_empty() {
11574 len += 1;
11575 }
11576 if self.compute_node_total_cpu_count != 0 {
11577 len += 1;
11578 }
11579 if !self.nodes.is_empty() {
11580 len += 1;
11581 }
11582 if self.hummock_version.is_some() {
11583 len += 1;
11584 }
11585 if self.meta_backup_manifest_id.is_some() {
11586 len += 1;
11587 }
11588 if self.hummock_write_limits.is_some() {
11589 len += 1;
11590 }
11591 if !self.streaming_worker_slot_mappings.is_empty() {
11592 len += 1;
11593 }
11594 if !self.serving_worker_slot_mappings.is_empty() {
11595 len += 1;
11596 }
11597 if self.version.is_some() {
11598 len += 1;
11599 }
11600 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11601 if !self.databases.is_empty() {
11602 struct_ser.serialize_field("databases", &self.databases)?;
11603 }
11604 if !self.schemas.is_empty() {
11605 struct_ser.serialize_field("schemas", &self.schemas)?;
11606 }
11607 if !self.sources.is_empty() {
11608 struct_ser.serialize_field("sources", &self.sources)?;
11609 }
11610 if !self.sinks.is_empty() {
11611 struct_ser.serialize_field("sinks", &self.sinks)?;
11612 }
11613 if !self.tables.is_empty() {
11614 struct_ser.serialize_field("tables", &self.tables)?;
11615 }
11616 if !self.indexes.is_empty() {
11617 struct_ser.serialize_field("indexes", &self.indexes)?;
11618 }
11619 if !self.views.is_empty() {
11620 struct_ser.serialize_field("views", &self.views)?;
11621 }
11622 if !self.functions.is_empty() {
11623 struct_ser.serialize_field("functions", &self.functions)?;
11624 }
11625 if !self.connections.is_empty() {
11626 struct_ser.serialize_field("connections", &self.connections)?;
11627 }
11628 if !self.subscriptions.is_empty() {
11629 struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11630 }
11631 if !self.users.is_empty() {
11632 struct_ser.serialize_field("users", &self.users)?;
11633 }
11634 if let Some(v) = self.session_params.as_ref() {
11635 struct_ser.serialize_field("sessionParams", v)?;
11636 }
11637 if !self.secrets.is_empty() {
11638 struct_ser.serialize_field("secrets", &self.secrets)?;
11639 }
11640 if self.compute_node_total_cpu_count != 0 {
11641 #[allow(clippy::needless_borrow)]
11642 #[allow(clippy::needless_borrows_for_generic_args)]
11643 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11644 }
11645 if !self.nodes.is_empty() {
11646 struct_ser.serialize_field("nodes", &self.nodes)?;
11647 }
11648 if let Some(v) = self.hummock_version.as_ref() {
11649 struct_ser.serialize_field("hummockVersion", v)?;
11650 }
11651 if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11652 struct_ser.serialize_field("metaBackupManifestId", v)?;
11653 }
11654 if let Some(v) = self.hummock_write_limits.as_ref() {
11655 struct_ser.serialize_field("hummockWriteLimits", v)?;
11656 }
11657 if !self.streaming_worker_slot_mappings.is_empty() {
11658 struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11659 }
11660 if !self.serving_worker_slot_mappings.is_empty() {
11661 struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11662 }
11663 if let Some(v) = self.version.as_ref() {
11664 struct_ser.serialize_field("version", v)?;
11665 }
11666 struct_ser.end()
11667 }
11668}
11669impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11670 #[allow(deprecated)]
11671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11672 where
11673 D: serde::Deserializer<'de>,
11674 {
11675 const FIELDS: &[&str] = &[
11676 "databases",
11677 "schemas",
11678 "sources",
11679 "sinks",
11680 "tables",
11681 "indexes",
11682 "views",
11683 "functions",
11684 "connections",
11685 "subscriptions",
11686 "users",
11687 "session_params",
11688 "sessionParams",
11689 "secrets",
11690 "compute_node_total_cpu_count",
11691 "computeNodeTotalCpuCount",
11692 "nodes",
11693 "hummock_version",
11694 "hummockVersion",
11695 "meta_backup_manifest_id",
11696 "metaBackupManifestId",
11697 "hummock_write_limits",
11698 "hummockWriteLimits",
11699 "streaming_worker_slot_mappings",
11700 "streamingWorkerSlotMappings",
11701 "serving_worker_slot_mappings",
11702 "servingWorkerSlotMappings",
11703 "version",
11704 ];
11705
11706 #[allow(clippy::enum_variant_names)]
11707 enum GeneratedField {
11708 Databases,
11709 Schemas,
11710 Sources,
11711 Sinks,
11712 Tables,
11713 Indexes,
11714 Views,
11715 Functions,
11716 Connections,
11717 Subscriptions,
11718 Users,
11719 SessionParams,
11720 Secrets,
11721 ComputeNodeTotalCpuCount,
11722 Nodes,
11723 HummockVersion,
11724 MetaBackupManifestId,
11725 HummockWriteLimits,
11726 StreamingWorkerSlotMappings,
11727 ServingWorkerSlotMappings,
11728 Version,
11729 }
11730 impl<'de> serde::Deserialize<'de> for GeneratedField {
11731 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11732 where
11733 D: serde::Deserializer<'de>,
11734 {
11735 struct GeneratedVisitor;
11736
11737 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11738 type Value = GeneratedField;
11739
11740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11741 write!(formatter, "expected one of: {:?}", &FIELDS)
11742 }
11743
11744 #[allow(unused_variables)]
11745 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11746 where
11747 E: serde::de::Error,
11748 {
11749 match value {
11750 "databases" => Ok(GeneratedField::Databases),
11751 "schemas" => Ok(GeneratedField::Schemas),
11752 "sources" => Ok(GeneratedField::Sources),
11753 "sinks" => Ok(GeneratedField::Sinks),
11754 "tables" => Ok(GeneratedField::Tables),
11755 "indexes" => Ok(GeneratedField::Indexes),
11756 "views" => Ok(GeneratedField::Views),
11757 "functions" => Ok(GeneratedField::Functions),
11758 "connections" => Ok(GeneratedField::Connections),
11759 "subscriptions" => Ok(GeneratedField::Subscriptions),
11760 "users" => Ok(GeneratedField::Users),
11761 "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11762 "secrets" => Ok(GeneratedField::Secrets),
11763 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11764 "nodes" => Ok(GeneratedField::Nodes),
11765 "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11766 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11767 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11768 "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11769 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11770 "version" => Ok(GeneratedField::Version),
11771 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11772 }
11773 }
11774 }
11775 deserializer.deserialize_identifier(GeneratedVisitor)
11776 }
11777 }
11778 struct GeneratedVisitor;
11779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11780 type Value = MetaSnapshot;
11781
11782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11783 formatter.write_str("struct meta.MetaSnapshot")
11784 }
11785
11786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11787 where
11788 V: serde::de::MapAccess<'de>,
11789 {
11790 let mut databases__ = None;
11791 let mut schemas__ = None;
11792 let mut sources__ = None;
11793 let mut sinks__ = None;
11794 let mut tables__ = None;
11795 let mut indexes__ = None;
11796 let mut views__ = None;
11797 let mut functions__ = None;
11798 let mut connections__ = None;
11799 let mut subscriptions__ = None;
11800 let mut users__ = None;
11801 let mut session_params__ = None;
11802 let mut secrets__ = None;
11803 let mut compute_node_total_cpu_count__ = None;
11804 let mut nodes__ = None;
11805 let mut hummock_version__ = None;
11806 let mut meta_backup_manifest_id__ = None;
11807 let mut hummock_write_limits__ = None;
11808 let mut streaming_worker_slot_mappings__ = None;
11809 let mut serving_worker_slot_mappings__ = None;
11810 let mut version__ = None;
11811 while let Some(k) = map_.next_key()? {
11812 match k {
11813 GeneratedField::Databases => {
11814 if databases__.is_some() {
11815 return Err(serde::de::Error::duplicate_field("databases"));
11816 }
11817 databases__ = Some(map_.next_value()?);
11818 }
11819 GeneratedField::Schemas => {
11820 if schemas__.is_some() {
11821 return Err(serde::de::Error::duplicate_field("schemas"));
11822 }
11823 schemas__ = Some(map_.next_value()?);
11824 }
11825 GeneratedField::Sources => {
11826 if sources__.is_some() {
11827 return Err(serde::de::Error::duplicate_field("sources"));
11828 }
11829 sources__ = Some(map_.next_value()?);
11830 }
11831 GeneratedField::Sinks => {
11832 if sinks__.is_some() {
11833 return Err(serde::de::Error::duplicate_field("sinks"));
11834 }
11835 sinks__ = Some(map_.next_value()?);
11836 }
11837 GeneratedField::Tables => {
11838 if tables__.is_some() {
11839 return Err(serde::de::Error::duplicate_field("tables"));
11840 }
11841 tables__ = Some(map_.next_value()?);
11842 }
11843 GeneratedField::Indexes => {
11844 if indexes__.is_some() {
11845 return Err(serde::de::Error::duplicate_field("indexes"));
11846 }
11847 indexes__ = Some(map_.next_value()?);
11848 }
11849 GeneratedField::Views => {
11850 if views__.is_some() {
11851 return Err(serde::de::Error::duplicate_field("views"));
11852 }
11853 views__ = Some(map_.next_value()?);
11854 }
11855 GeneratedField::Functions => {
11856 if functions__.is_some() {
11857 return Err(serde::de::Error::duplicate_field("functions"));
11858 }
11859 functions__ = Some(map_.next_value()?);
11860 }
11861 GeneratedField::Connections => {
11862 if connections__.is_some() {
11863 return Err(serde::de::Error::duplicate_field("connections"));
11864 }
11865 connections__ = Some(map_.next_value()?);
11866 }
11867 GeneratedField::Subscriptions => {
11868 if subscriptions__.is_some() {
11869 return Err(serde::de::Error::duplicate_field("subscriptions"));
11870 }
11871 subscriptions__ = Some(map_.next_value()?);
11872 }
11873 GeneratedField::Users => {
11874 if users__.is_some() {
11875 return Err(serde::de::Error::duplicate_field("users"));
11876 }
11877 users__ = Some(map_.next_value()?);
11878 }
11879 GeneratedField::SessionParams => {
11880 if session_params__.is_some() {
11881 return Err(serde::de::Error::duplicate_field("sessionParams"));
11882 }
11883 session_params__ = map_.next_value()?;
11884 }
11885 GeneratedField::Secrets => {
11886 if secrets__.is_some() {
11887 return Err(serde::de::Error::duplicate_field("secrets"));
11888 }
11889 secrets__ = Some(map_.next_value()?);
11890 }
11891 GeneratedField::ComputeNodeTotalCpuCount => {
11892 if compute_node_total_cpu_count__.is_some() {
11893 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
11894 }
11895 compute_node_total_cpu_count__ =
11896 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11897 ;
11898 }
11899 GeneratedField::Nodes => {
11900 if nodes__.is_some() {
11901 return Err(serde::de::Error::duplicate_field("nodes"));
11902 }
11903 nodes__ = Some(map_.next_value()?);
11904 }
11905 GeneratedField::HummockVersion => {
11906 if hummock_version__.is_some() {
11907 return Err(serde::de::Error::duplicate_field("hummockVersion"));
11908 }
11909 hummock_version__ = map_.next_value()?;
11910 }
11911 GeneratedField::MetaBackupManifestId => {
11912 if meta_backup_manifest_id__.is_some() {
11913 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
11914 }
11915 meta_backup_manifest_id__ = map_.next_value()?;
11916 }
11917 GeneratedField::HummockWriteLimits => {
11918 if hummock_write_limits__.is_some() {
11919 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
11920 }
11921 hummock_write_limits__ = map_.next_value()?;
11922 }
11923 GeneratedField::StreamingWorkerSlotMappings => {
11924 if streaming_worker_slot_mappings__.is_some() {
11925 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
11926 }
11927 streaming_worker_slot_mappings__ = Some(map_.next_value()?);
11928 }
11929 GeneratedField::ServingWorkerSlotMappings => {
11930 if serving_worker_slot_mappings__.is_some() {
11931 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
11932 }
11933 serving_worker_slot_mappings__ = Some(map_.next_value()?);
11934 }
11935 GeneratedField::Version => {
11936 if version__.is_some() {
11937 return Err(serde::de::Error::duplicate_field("version"));
11938 }
11939 version__ = map_.next_value()?;
11940 }
11941 }
11942 }
11943 Ok(MetaSnapshot {
11944 databases: databases__.unwrap_or_default(),
11945 schemas: schemas__.unwrap_or_default(),
11946 sources: sources__.unwrap_or_default(),
11947 sinks: sinks__.unwrap_or_default(),
11948 tables: tables__.unwrap_or_default(),
11949 indexes: indexes__.unwrap_or_default(),
11950 views: views__.unwrap_or_default(),
11951 functions: functions__.unwrap_or_default(),
11952 connections: connections__.unwrap_or_default(),
11953 subscriptions: subscriptions__.unwrap_or_default(),
11954 users: users__.unwrap_or_default(),
11955 session_params: session_params__,
11956 secrets: secrets__.unwrap_or_default(),
11957 compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
11958 nodes: nodes__.unwrap_or_default(),
11959 hummock_version: hummock_version__,
11960 meta_backup_manifest_id: meta_backup_manifest_id__,
11961 hummock_write_limits: hummock_write_limits__,
11962 streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
11963 serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
11964 version: version__,
11965 })
11966 }
11967 }
11968 deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
11969 }
11970}
11971impl serde::Serialize for meta_snapshot::SnapshotVersion {
11972 #[allow(deprecated)]
11973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11974 where
11975 S: serde::Serializer,
11976 {
11977 use serde::ser::SerializeStruct;
11978 let mut len = 0;
11979 if self.catalog_version != 0 {
11980 len += 1;
11981 }
11982 if self.worker_node_version != 0 {
11983 len += 1;
11984 }
11985 if self.streaming_worker_slot_mapping_version != 0 {
11986 len += 1;
11987 }
11988 let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
11989 if self.catalog_version != 0 {
11990 #[allow(clippy::needless_borrow)]
11991 #[allow(clippy::needless_borrows_for_generic_args)]
11992 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11993 }
11994 if self.worker_node_version != 0 {
11995 #[allow(clippy::needless_borrow)]
11996 #[allow(clippy::needless_borrows_for_generic_args)]
11997 struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
11998 }
11999 if self.streaming_worker_slot_mapping_version != 0 {
12000 #[allow(clippy::needless_borrow)]
12001 #[allow(clippy::needless_borrows_for_generic_args)]
12002 struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
12003 }
12004 struct_ser.end()
12005 }
12006}
12007impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
12008 #[allow(deprecated)]
12009 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12010 where
12011 D: serde::Deserializer<'de>,
12012 {
12013 const FIELDS: &[&str] = &[
12014 "catalog_version",
12015 "catalogVersion",
12016 "worker_node_version",
12017 "workerNodeVersion",
12018 "streaming_worker_slot_mapping_version",
12019 "streamingWorkerSlotMappingVersion",
12020 ];
12021
12022 #[allow(clippy::enum_variant_names)]
12023 enum GeneratedField {
12024 CatalogVersion,
12025 WorkerNodeVersion,
12026 StreamingWorkerSlotMappingVersion,
12027 }
12028 impl<'de> serde::Deserialize<'de> for GeneratedField {
12029 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12030 where
12031 D: serde::Deserializer<'de>,
12032 {
12033 struct GeneratedVisitor;
12034
12035 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12036 type Value = GeneratedField;
12037
12038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12039 write!(formatter, "expected one of: {:?}", &FIELDS)
12040 }
12041
12042 #[allow(unused_variables)]
12043 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12044 where
12045 E: serde::de::Error,
12046 {
12047 match value {
12048 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12049 "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
12050 "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
12051 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12052 }
12053 }
12054 }
12055 deserializer.deserialize_identifier(GeneratedVisitor)
12056 }
12057 }
12058 struct GeneratedVisitor;
12059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12060 type Value = meta_snapshot::SnapshotVersion;
12061
12062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12063 formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
12064 }
12065
12066 fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
12067 where
12068 V: serde::de::MapAccess<'de>,
12069 {
12070 let mut catalog_version__ = None;
12071 let mut worker_node_version__ = None;
12072 let mut streaming_worker_slot_mapping_version__ = None;
12073 while let Some(k) = map_.next_key()? {
12074 match k {
12075 GeneratedField::CatalogVersion => {
12076 if catalog_version__.is_some() {
12077 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12078 }
12079 catalog_version__ =
12080 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12081 ;
12082 }
12083 GeneratedField::WorkerNodeVersion => {
12084 if worker_node_version__.is_some() {
12085 return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
12086 }
12087 worker_node_version__ =
12088 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12089 ;
12090 }
12091 GeneratedField::StreamingWorkerSlotMappingVersion => {
12092 if streaming_worker_slot_mapping_version__.is_some() {
12093 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
12094 }
12095 streaming_worker_slot_mapping_version__ =
12096 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12097 ;
12098 }
12099 }
12100 }
12101 Ok(meta_snapshot::SnapshotVersion {
12102 catalog_version: catalog_version__.unwrap_or_default(),
12103 worker_node_version: worker_node_version__.unwrap_or_default(),
12104 streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
12105 })
12106 }
12107 }
12108 deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
12109 }
12110}
12111impl serde::Serialize for MigrationPlan {
12112 #[allow(deprecated)]
12113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12114 where
12115 S: serde::Serializer,
12116 {
12117 use serde::ser::SerializeStruct;
12118 let mut len = 0;
12119 if !self.worker_slot_migration_plan.is_empty() {
12120 len += 1;
12121 }
12122 let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
12123 if !self.worker_slot_migration_plan.is_empty() {
12124 let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
12125 .map(|(k, v)| (k, v.to_string())).collect();
12126 struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
12127 }
12128 struct_ser.end()
12129 }
12130}
12131impl<'de> serde::Deserialize<'de> for MigrationPlan {
12132 #[allow(deprecated)]
12133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12134 where
12135 D: serde::Deserializer<'de>,
12136 {
12137 const FIELDS: &[&str] = &[
12138 "worker_slot_migration_plan",
12139 "workerSlotMigrationPlan",
12140 ];
12141
12142 #[allow(clippy::enum_variant_names)]
12143 enum GeneratedField {
12144 WorkerSlotMigrationPlan,
12145 }
12146 impl<'de> serde::Deserialize<'de> for GeneratedField {
12147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12148 where
12149 D: serde::Deserializer<'de>,
12150 {
12151 struct GeneratedVisitor;
12152
12153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12154 type Value = GeneratedField;
12155
12156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12157 write!(formatter, "expected one of: {:?}", &FIELDS)
12158 }
12159
12160 #[allow(unused_variables)]
12161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12162 where
12163 E: serde::de::Error,
12164 {
12165 match value {
12166 "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
12167 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12168 }
12169 }
12170 }
12171 deserializer.deserialize_identifier(GeneratedVisitor)
12172 }
12173 }
12174 struct GeneratedVisitor;
12175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12176 type Value = MigrationPlan;
12177
12178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12179 formatter.write_str("struct meta.MigrationPlan")
12180 }
12181
12182 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
12183 where
12184 V: serde::de::MapAccess<'de>,
12185 {
12186 let mut worker_slot_migration_plan__ = None;
12187 while let Some(k) = map_.next_key()? {
12188 match k {
12189 GeneratedField::WorkerSlotMigrationPlan => {
12190 if worker_slot_migration_plan__.is_some() {
12191 return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
12192 }
12193 worker_slot_migration_plan__ = Some(
12194 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12195 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
12196 );
12197 }
12198 }
12199 }
12200 Ok(MigrationPlan {
12201 worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
12202 })
12203 }
12204 }
12205 deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
12206 }
12207}
12208impl serde::Serialize for Object {
12209 #[allow(deprecated)]
12210 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12211 where
12212 S: serde::Serializer,
12213 {
12214 use serde::ser::SerializeStruct;
12215 let mut len = 0;
12216 if self.object_info.is_some() {
12217 len += 1;
12218 }
12219 let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
12220 if let Some(v) = self.object_info.as_ref() {
12221 match v {
12222 object::ObjectInfo::Database(v) => {
12223 struct_ser.serialize_field("database", v)?;
12224 }
12225 object::ObjectInfo::Schema(v) => {
12226 struct_ser.serialize_field("schema", v)?;
12227 }
12228 object::ObjectInfo::Table(v) => {
12229 struct_ser.serialize_field("table", v)?;
12230 }
12231 object::ObjectInfo::Index(v) => {
12232 struct_ser.serialize_field("index", v)?;
12233 }
12234 object::ObjectInfo::Source(v) => {
12235 struct_ser.serialize_field("source", v)?;
12236 }
12237 object::ObjectInfo::Sink(v) => {
12238 struct_ser.serialize_field("sink", v)?;
12239 }
12240 object::ObjectInfo::View(v) => {
12241 struct_ser.serialize_field("view", v)?;
12242 }
12243 object::ObjectInfo::Function(v) => {
12244 struct_ser.serialize_field("function", v)?;
12245 }
12246 object::ObjectInfo::Connection(v) => {
12247 struct_ser.serialize_field("connection", v)?;
12248 }
12249 object::ObjectInfo::Subscription(v) => {
12250 struct_ser.serialize_field("subscription", v)?;
12251 }
12252 object::ObjectInfo::Secret(v) => {
12253 struct_ser.serialize_field("secret", v)?;
12254 }
12255 }
12256 }
12257 struct_ser.end()
12258 }
12259}
12260impl<'de> serde::Deserialize<'de> for Object {
12261 #[allow(deprecated)]
12262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12263 where
12264 D: serde::Deserializer<'de>,
12265 {
12266 const FIELDS: &[&str] = &[
12267 "database",
12268 "schema",
12269 "table",
12270 "index",
12271 "source",
12272 "sink",
12273 "view",
12274 "function",
12275 "connection",
12276 "subscription",
12277 "secret",
12278 ];
12279
12280 #[allow(clippy::enum_variant_names)]
12281 enum GeneratedField {
12282 Database,
12283 Schema,
12284 Table,
12285 Index,
12286 Source,
12287 Sink,
12288 View,
12289 Function,
12290 Connection,
12291 Subscription,
12292 Secret,
12293 }
12294 impl<'de> serde::Deserialize<'de> for GeneratedField {
12295 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12296 where
12297 D: serde::Deserializer<'de>,
12298 {
12299 struct GeneratedVisitor;
12300
12301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12302 type Value = GeneratedField;
12303
12304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12305 write!(formatter, "expected one of: {:?}", &FIELDS)
12306 }
12307
12308 #[allow(unused_variables)]
12309 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12310 where
12311 E: serde::de::Error,
12312 {
12313 match value {
12314 "database" => Ok(GeneratedField::Database),
12315 "schema" => Ok(GeneratedField::Schema),
12316 "table" => Ok(GeneratedField::Table),
12317 "index" => Ok(GeneratedField::Index),
12318 "source" => Ok(GeneratedField::Source),
12319 "sink" => Ok(GeneratedField::Sink),
12320 "view" => Ok(GeneratedField::View),
12321 "function" => Ok(GeneratedField::Function),
12322 "connection" => Ok(GeneratedField::Connection),
12323 "subscription" => Ok(GeneratedField::Subscription),
12324 "secret" => Ok(GeneratedField::Secret),
12325 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12326 }
12327 }
12328 }
12329 deserializer.deserialize_identifier(GeneratedVisitor)
12330 }
12331 }
12332 struct GeneratedVisitor;
12333 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12334 type Value = Object;
12335
12336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12337 formatter.write_str("struct meta.Object")
12338 }
12339
12340 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12341 where
12342 V: serde::de::MapAccess<'de>,
12343 {
12344 let mut object_info__ = None;
12345 while let Some(k) = map_.next_key()? {
12346 match k {
12347 GeneratedField::Database => {
12348 if object_info__.is_some() {
12349 return Err(serde::de::Error::duplicate_field("database"));
12350 }
12351 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12352;
12353 }
12354 GeneratedField::Schema => {
12355 if object_info__.is_some() {
12356 return Err(serde::de::Error::duplicate_field("schema"));
12357 }
12358 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12359;
12360 }
12361 GeneratedField::Table => {
12362 if object_info__.is_some() {
12363 return Err(serde::de::Error::duplicate_field("table"));
12364 }
12365 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12366;
12367 }
12368 GeneratedField::Index => {
12369 if object_info__.is_some() {
12370 return Err(serde::de::Error::duplicate_field("index"));
12371 }
12372 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12373;
12374 }
12375 GeneratedField::Source => {
12376 if object_info__.is_some() {
12377 return Err(serde::de::Error::duplicate_field("source"));
12378 }
12379 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12380;
12381 }
12382 GeneratedField::Sink => {
12383 if object_info__.is_some() {
12384 return Err(serde::de::Error::duplicate_field("sink"));
12385 }
12386 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12387;
12388 }
12389 GeneratedField::View => {
12390 if object_info__.is_some() {
12391 return Err(serde::de::Error::duplicate_field("view"));
12392 }
12393 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12394;
12395 }
12396 GeneratedField::Function => {
12397 if object_info__.is_some() {
12398 return Err(serde::de::Error::duplicate_field("function"));
12399 }
12400 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12401;
12402 }
12403 GeneratedField::Connection => {
12404 if object_info__.is_some() {
12405 return Err(serde::de::Error::duplicate_field("connection"));
12406 }
12407 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12408;
12409 }
12410 GeneratedField::Subscription => {
12411 if object_info__.is_some() {
12412 return Err(serde::de::Error::duplicate_field("subscription"));
12413 }
12414 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12415;
12416 }
12417 GeneratedField::Secret => {
12418 if object_info__.is_some() {
12419 return Err(serde::de::Error::duplicate_field("secret"));
12420 }
12421 object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12422;
12423 }
12424 }
12425 }
12426 Ok(Object {
12427 object_info: object_info__,
12428 })
12429 }
12430 }
12431 deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12432 }
12433}
12434impl serde::Serialize for ObjectGroup {
12435 #[allow(deprecated)]
12436 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12437 where
12438 S: serde::Serializer,
12439 {
12440 use serde::ser::SerializeStruct;
12441 let mut len = 0;
12442 if !self.objects.is_empty() {
12443 len += 1;
12444 }
12445 let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12446 if !self.objects.is_empty() {
12447 struct_ser.serialize_field("objects", &self.objects)?;
12448 }
12449 struct_ser.end()
12450 }
12451}
12452impl<'de> serde::Deserialize<'de> for ObjectGroup {
12453 #[allow(deprecated)]
12454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12455 where
12456 D: serde::Deserializer<'de>,
12457 {
12458 const FIELDS: &[&str] = &[
12459 "objects",
12460 ];
12461
12462 #[allow(clippy::enum_variant_names)]
12463 enum GeneratedField {
12464 Objects,
12465 }
12466 impl<'de> serde::Deserialize<'de> for GeneratedField {
12467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12468 where
12469 D: serde::Deserializer<'de>,
12470 {
12471 struct GeneratedVisitor;
12472
12473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12474 type Value = GeneratedField;
12475
12476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12477 write!(formatter, "expected one of: {:?}", &FIELDS)
12478 }
12479
12480 #[allow(unused_variables)]
12481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12482 where
12483 E: serde::de::Error,
12484 {
12485 match value {
12486 "objects" => Ok(GeneratedField::Objects),
12487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12488 }
12489 }
12490 }
12491 deserializer.deserialize_identifier(GeneratedVisitor)
12492 }
12493 }
12494 struct GeneratedVisitor;
12495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12496 type Value = ObjectGroup;
12497
12498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12499 formatter.write_str("struct meta.ObjectGroup")
12500 }
12501
12502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12503 where
12504 V: serde::de::MapAccess<'de>,
12505 {
12506 let mut objects__ = None;
12507 while let Some(k) = map_.next_key()? {
12508 match k {
12509 GeneratedField::Objects => {
12510 if objects__.is_some() {
12511 return Err(serde::de::Error::duplicate_field("objects"));
12512 }
12513 objects__ = Some(map_.next_value()?);
12514 }
12515 }
12516 }
12517 Ok(ObjectGroup {
12518 objects: objects__.unwrap_or_default(),
12519 })
12520 }
12521 }
12522 deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12523 }
12524}
12525impl serde::Serialize for PauseRequest {
12526 #[allow(deprecated)]
12527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12528 where
12529 S: serde::Serializer,
12530 {
12531 use serde::ser::SerializeStruct;
12532 let len = 0;
12533 let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12534 struct_ser.end()
12535 }
12536}
12537impl<'de> serde::Deserialize<'de> for PauseRequest {
12538 #[allow(deprecated)]
12539 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12540 where
12541 D: serde::Deserializer<'de>,
12542 {
12543 const FIELDS: &[&str] = &[
12544 ];
12545
12546 #[allow(clippy::enum_variant_names)]
12547 enum GeneratedField {
12548 }
12549 impl<'de> serde::Deserialize<'de> for GeneratedField {
12550 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12551 where
12552 D: serde::Deserializer<'de>,
12553 {
12554 struct GeneratedVisitor;
12555
12556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12557 type Value = GeneratedField;
12558
12559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12560 write!(formatter, "expected one of: {:?}", &FIELDS)
12561 }
12562
12563 #[allow(unused_variables)]
12564 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12565 where
12566 E: serde::de::Error,
12567 {
12568 Err(serde::de::Error::unknown_field(value, FIELDS))
12569 }
12570 }
12571 deserializer.deserialize_identifier(GeneratedVisitor)
12572 }
12573 }
12574 struct GeneratedVisitor;
12575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12576 type Value = PauseRequest;
12577
12578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12579 formatter.write_str("struct meta.PauseRequest")
12580 }
12581
12582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12583 where
12584 V: serde::de::MapAccess<'de>,
12585 {
12586 while map_.next_key::<GeneratedField>()?.is_some() {
12587 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12588 }
12589 Ok(PauseRequest {
12590 })
12591 }
12592 }
12593 deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12594 }
12595}
12596impl serde::Serialize for PauseResponse {
12597 #[allow(deprecated)]
12598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12599 where
12600 S: serde::Serializer,
12601 {
12602 use serde::ser::SerializeStruct;
12603 let len = 0;
12604 let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12605 struct_ser.end()
12606 }
12607}
12608impl<'de> serde::Deserialize<'de> for PauseResponse {
12609 #[allow(deprecated)]
12610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12611 where
12612 D: serde::Deserializer<'de>,
12613 {
12614 const FIELDS: &[&str] = &[
12615 ];
12616
12617 #[allow(clippy::enum_variant_names)]
12618 enum GeneratedField {
12619 }
12620 impl<'de> serde::Deserialize<'de> for GeneratedField {
12621 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12622 where
12623 D: serde::Deserializer<'de>,
12624 {
12625 struct GeneratedVisitor;
12626
12627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12628 type Value = GeneratedField;
12629
12630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12631 write!(formatter, "expected one of: {:?}", &FIELDS)
12632 }
12633
12634 #[allow(unused_variables)]
12635 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12636 where
12637 E: serde::de::Error,
12638 {
12639 Err(serde::de::Error::unknown_field(value, FIELDS))
12640 }
12641 }
12642 deserializer.deserialize_identifier(GeneratedVisitor)
12643 }
12644 }
12645 struct GeneratedVisitor;
12646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12647 type Value = PauseResponse;
12648
12649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12650 formatter.write_str("struct meta.PauseResponse")
12651 }
12652
12653 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12654 where
12655 V: serde::de::MapAccess<'de>,
12656 {
12657 while map_.next_key::<GeneratedField>()?.is_some() {
12658 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12659 }
12660 Ok(PauseResponse {
12661 })
12662 }
12663 }
12664 deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12665 }
12666}
12667impl serde::Serialize for RecoverRequest {
12668 #[allow(deprecated)]
12669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12670 where
12671 S: serde::Serializer,
12672 {
12673 use serde::ser::SerializeStruct;
12674 let len = 0;
12675 let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12676 struct_ser.end()
12677 }
12678}
12679impl<'de> serde::Deserialize<'de> for RecoverRequest {
12680 #[allow(deprecated)]
12681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12682 where
12683 D: serde::Deserializer<'de>,
12684 {
12685 const FIELDS: &[&str] = &[
12686 ];
12687
12688 #[allow(clippy::enum_variant_names)]
12689 enum GeneratedField {
12690 }
12691 impl<'de> serde::Deserialize<'de> for GeneratedField {
12692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12693 where
12694 D: serde::Deserializer<'de>,
12695 {
12696 struct GeneratedVisitor;
12697
12698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12699 type Value = GeneratedField;
12700
12701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12702 write!(formatter, "expected one of: {:?}", &FIELDS)
12703 }
12704
12705 #[allow(unused_variables)]
12706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12707 where
12708 E: serde::de::Error,
12709 {
12710 Err(serde::de::Error::unknown_field(value, FIELDS))
12711 }
12712 }
12713 deserializer.deserialize_identifier(GeneratedVisitor)
12714 }
12715 }
12716 struct GeneratedVisitor;
12717 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12718 type Value = RecoverRequest;
12719
12720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12721 formatter.write_str("struct meta.RecoverRequest")
12722 }
12723
12724 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12725 where
12726 V: serde::de::MapAccess<'de>,
12727 {
12728 while map_.next_key::<GeneratedField>()?.is_some() {
12729 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12730 }
12731 Ok(RecoverRequest {
12732 })
12733 }
12734 }
12735 deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12736 }
12737}
12738impl serde::Serialize for RecoverResponse {
12739 #[allow(deprecated)]
12740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12741 where
12742 S: serde::Serializer,
12743 {
12744 use serde::ser::SerializeStruct;
12745 let len = 0;
12746 let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12747 struct_ser.end()
12748 }
12749}
12750impl<'de> serde::Deserialize<'de> for RecoverResponse {
12751 #[allow(deprecated)]
12752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12753 where
12754 D: serde::Deserializer<'de>,
12755 {
12756 const FIELDS: &[&str] = &[
12757 ];
12758
12759 #[allow(clippy::enum_variant_names)]
12760 enum GeneratedField {
12761 }
12762 impl<'de> serde::Deserialize<'de> for GeneratedField {
12763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12764 where
12765 D: serde::Deserializer<'de>,
12766 {
12767 struct GeneratedVisitor;
12768
12769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12770 type Value = GeneratedField;
12771
12772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12773 write!(formatter, "expected one of: {:?}", &FIELDS)
12774 }
12775
12776 #[allow(unused_variables)]
12777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12778 where
12779 E: serde::de::Error,
12780 {
12781 Err(serde::de::Error::unknown_field(value, FIELDS))
12782 }
12783 }
12784 deserializer.deserialize_identifier(GeneratedVisitor)
12785 }
12786 }
12787 struct GeneratedVisitor;
12788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12789 type Value = RecoverResponse;
12790
12791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12792 formatter.write_str("struct meta.RecoverResponse")
12793 }
12794
12795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12796 where
12797 V: serde::de::MapAccess<'de>,
12798 {
12799 while map_.next_key::<GeneratedField>()?.is_some() {
12800 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12801 }
12802 Ok(RecoverResponse {
12803 })
12804 }
12805 }
12806 deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12807 }
12808}
12809impl serde::Serialize for Recovery {
12810 #[allow(deprecated)]
12811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12812 where
12813 S: serde::Serializer,
12814 {
12815 use serde::ser::SerializeStruct;
12816 let len = 0;
12817 let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12818 struct_ser.end()
12819 }
12820}
12821impl<'de> serde::Deserialize<'de> for Recovery {
12822 #[allow(deprecated)]
12823 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12824 where
12825 D: serde::Deserializer<'de>,
12826 {
12827 const FIELDS: &[&str] = &[
12828 ];
12829
12830 #[allow(clippy::enum_variant_names)]
12831 enum GeneratedField {
12832 }
12833 impl<'de> serde::Deserialize<'de> for GeneratedField {
12834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12835 where
12836 D: serde::Deserializer<'de>,
12837 {
12838 struct GeneratedVisitor;
12839
12840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12841 type Value = GeneratedField;
12842
12843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12844 write!(formatter, "expected one of: {:?}", &FIELDS)
12845 }
12846
12847 #[allow(unused_variables)]
12848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12849 where
12850 E: serde::de::Error,
12851 {
12852 Err(serde::de::Error::unknown_field(value, FIELDS))
12853 }
12854 }
12855 deserializer.deserialize_identifier(GeneratedVisitor)
12856 }
12857 }
12858 struct GeneratedVisitor;
12859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12860 type Value = Recovery;
12861
12862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12863 formatter.write_str("struct meta.Recovery")
12864 }
12865
12866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
12867 where
12868 V: serde::de::MapAccess<'de>,
12869 {
12870 while map_.next_key::<GeneratedField>()?.is_some() {
12871 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12872 }
12873 Ok(Recovery {
12874 })
12875 }
12876 }
12877 deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
12878 }
12879}
12880impl serde::Serialize for RecoveryStatus {
12881 #[allow(deprecated)]
12882 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12883 where
12884 S: serde::Serializer,
12885 {
12886 let variant = match self {
12887 Self::StatusUnspecified => "STATUS_UNSPECIFIED",
12888 Self::StatusStarting => "STATUS_STARTING",
12889 Self::StatusRecovering => "STATUS_RECOVERING",
12890 Self::StatusRunning => "STATUS_RUNNING",
12891 };
12892 serializer.serialize_str(variant)
12893 }
12894}
12895impl<'de> serde::Deserialize<'de> for RecoveryStatus {
12896 #[allow(deprecated)]
12897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12898 where
12899 D: serde::Deserializer<'de>,
12900 {
12901 const FIELDS: &[&str] = &[
12902 "STATUS_UNSPECIFIED",
12903 "STATUS_STARTING",
12904 "STATUS_RECOVERING",
12905 "STATUS_RUNNING",
12906 ];
12907
12908 struct GeneratedVisitor;
12909
12910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12911 type Value = RecoveryStatus;
12912
12913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12914 write!(formatter, "expected one of: {:?}", &FIELDS)
12915 }
12916
12917 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12918 where
12919 E: serde::de::Error,
12920 {
12921 i32::try_from(v)
12922 .ok()
12923 .and_then(|x| x.try_into().ok())
12924 .ok_or_else(|| {
12925 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12926 })
12927 }
12928
12929 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12930 where
12931 E: serde::de::Error,
12932 {
12933 i32::try_from(v)
12934 .ok()
12935 .and_then(|x| x.try_into().ok())
12936 .ok_or_else(|| {
12937 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12938 })
12939 }
12940
12941 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12942 where
12943 E: serde::de::Error,
12944 {
12945 match value {
12946 "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
12947 "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
12948 "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
12949 "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
12950 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12951 }
12952 }
12953 }
12954 deserializer.deserialize_any(GeneratedVisitor)
12955 }
12956}
12957impl serde::Serialize for RefreshRequest {
12958 #[allow(deprecated)]
12959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12960 where
12961 S: serde::Serializer,
12962 {
12963 use serde::ser::SerializeStruct;
12964 let mut len = 0;
12965 if self.table_id != 0 {
12966 len += 1;
12967 }
12968 if self.associated_source_id != 0 {
12969 len += 1;
12970 }
12971 let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
12972 if self.table_id != 0 {
12973 struct_ser.serialize_field("tableId", &self.table_id)?;
12974 }
12975 if self.associated_source_id != 0 {
12976 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
12977 }
12978 struct_ser.end()
12979 }
12980}
12981impl<'de> serde::Deserialize<'de> for RefreshRequest {
12982 #[allow(deprecated)]
12983 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12984 where
12985 D: serde::Deserializer<'de>,
12986 {
12987 const FIELDS: &[&str] = &[
12988 "table_id",
12989 "tableId",
12990 "associated_source_id",
12991 "associatedSourceId",
12992 ];
12993
12994 #[allow(clippy::enum_variant_names)]
12995 enum GeneratedField {
12996 TableId,
12997 AssociatedSourceId,
12998 }
12999 impl<'de> serde::Deserialize<'de> for GeneratedField {
13000 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13001 where
13002 D: serde::Deserializer<'de>,
13003 {
13004 struct GeneratedVisitor;
13005
13006 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13007 type Value = GeneratedField;
13008
13009 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13010 write!(formatter, "expected one of: {:?}", &FIELDS)
13011 }
13012
13013 #[allow(unused_variables)]
13014 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13015 where
13016 E: serde::de::Error,
13017 {
13018 match value {
13019 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13020 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
13021 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13022 }
13023 }
13024 }
13025 deserializer.deserialize_identifier(GeneratedVisitor)
13026 }
13027 }
13028 struct GeneratedVisitor;
13029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13030 type Value = RefreshRequest;
13031
13032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13033 formatter.write_str("struct meta.RefreshRequest")
13034 }
13035
13036 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
13037 where
13038 V: serde::de::MapAccess<'de>,
13039 {
13040 let mut table_id__ = None;
13041 let mut associated_source_id__ = None;
13042 while let Some(k) = map_.next_key()? {
13043 match k {
13044 GeneratedField::TableId => {
13045 if table_id__.is_some() {
13046 return Err(serde::de::Error::duplicate_field("tableId"));
13047 }
13048 table_id__ =
13049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13050 ;
13051 }
13052 GeneratedField::AssociatedSourceId => {
13053 if associated_source_id__.is_some() {
13054 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
13055 }
13056 associated_source_id__ =
13057 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13058 ;
13059 }
13060 }
13061 }
13062 Ok(RefreshRequest {
13063 table_id: table_id__.unwrap_or_default(),
13064 associated_source_id: associated_source_id__.unwrap_or_default(),
13065 })
13066 }
13067 }
13068 deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
13069 }
13070}
13071impl serde::Serialize for RefreshResponse {
13072 #[allow(deprecated)]
13073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13074 where
13075 S: serde::Serializer,
13076 {
13077 use serde::ser::SerializeStruct;
13078 let mut len = 0;
13079 if self.status.is_some() {
13080 len += 1;
13081 }
13082 let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
13083 if let Some(v) = self.status.as_ref() {
13084 struct_ser.serialize_field("status", v)?;
13085 }
13086 struct_ser.end()
13087 }
13088}
13089impl<'de> serde::Deserialize<'de> for RefreshResponse {
13090 #[allow(deprecated)]
13091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13092 where
13093 D: serde::Deserializer<'de>,
13094 {
13095 const FIELDS: &[&str] = &[
13096 "status",
13097 ];
13098
13099 #[allow(clippy::enum_variant_names)]
13100 enum GeneratedField {
13101 Status,
13102 }
13103 impl<'de> serde::Deserialize<'de> for GeneratedField {
13104 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13105 where
13106 D: serde::Deserializer<'de>,
13107 {
13108 struct GeneratedVisitor;
13109
13110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13111 type Value = GeneratedField;
13112
13113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13114 write!(formatter, "expected one of: {:?}", &FIELDS)
13115 }
13116
13117 #[allow(unused_variables)]
13118 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13119 where
13120 E: serde::de::Error,
13121 {
13122 match value {
13123 "status" => Ok(GeneratedField::Status),
13124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13125 }
13126 }
13127 }
13128 deserializer.deserialize_identifier(GeneratedVisitor)
13129 }
13130 }
13131 struct GeneratedVisitor;
13132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13133 type Value = RefreshResponse;
13134
13135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13136 formatter.write_str("struct meta.RefreshResponse")
13137 }
13138
13139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
13140 where
13141 V: serde::de::MapAccess<'de>,
13142 {
13143 let mut status__ = None;
13144 while let Some(k) = map_.next_key()? {
13145 match k {
13146 GeneratedField::Status => {
13147 if status__.is_some() {
13148 return Err(serde::de::Error::duplicate_field("status"));
13149 }
13150 status__ = map_.next_value()?;
13151 }
13152 }
13153 }
13154 Ok(RefreshResponse {
13155 status: status__,
13156 })
13157 }
13158 }
13159 deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
13160 }
13161}
13162impl serde::Serialize for RelationIdInfos {
13163 #[allow(deprecated)]
13164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13165 where
13166 S: serde::Serializer,
13167 {
13168 use serde::ser::SerializeStruct;
13169 let mut len = 0;
13170 if !self.map.is_empty() {
13171 len += 1;
13172 }
13173 let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
13174 if !self.map.is_empty() {
13175 struct_ser.serialize_field("map", &self.map)?;
13176 }
13177 struct_ser.end()
13178 }
13179}
13180impl<'de> serde::Deserialize<'de> for RelationIdInfos {
13181 #[allow(deprecated)]
13182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13183 where
13184 D: serde::Deserializer<'de>,
13185 {
13186 const FIELDS: &[&str] = &[
13187 "map",
13188 ];
13189
13190 #[allow(clippy::enum_variant_names)]
13191 enum GeneratedField {
13192 Map,
13193 }
13194 impl<'de> serde::Deserialize<'de> for GeneratedField {
13195 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13196 where
13197 D: serde::Deserializer<'de>,
13198 {
13199 struct GeneratedVisitor;
13200
13201 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13202 type Value = GeneratedField;
13203
13204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13205 write!(formatter, "expected one of: {:?}", &FIELDS)
13206 }
13207
13208 #[allow(unused_variables)]
13209 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13210 where
13211 E: serde::de::Error,
13212 {
13213 match value {
13214 "map" => Ok(GeneratedField::Map),
13215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13216 }
13217 }
13218 }
13219 deserializer.deserialize_identifier(GeneratedVisitor)
13220 }
13221 }
13222 struct GeneratedVisitor;
13223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13224 type Value = RelationIdInfos;
13225
13226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13227 formatter.write_str("struct meta.RelationIdInfos")
13228 }
13229
13230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
13231 where
13232 V: serde::de::MapAccess<'de>,
13233 {
13234 let mut map__ = None;
13235 while let Some(k) = map_.next_key()? {
13236 match k {
13237 GeneratedField::Map => {
13238 if map__.is_some() {
13239 return Err(serde::de::Error::duplicate_field("map"));
13240 }
13241 map__ = Some(
13242 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13243 .into_iter().map(|(k,v)| (k.0, v)).collect()
13244 );
13245 }
13246 }
13247 }
13248 Ok(RelationIdInfos {
13249 map: map__.unwrap_or_default(),
13250 })
13251 }
13252 }
13253 deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
13254 }
13255}
13256impl serde::Serialize for RescheduleRequest {
13257 #[allow(deprecated)]
13258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13259 where
13260 S: serde::Serializer,
13261 {
13262 use serde::ser::SerializeStruct;
13263 let mut len = 0;
13264 if self.revision != 0 {
13265 len += 1;
13266 }
13267 if self.resolve_no_shuffle_upstream {
13268 len += 1;
13269 }
13270 if !self.worker_reschedules.is_empty() {
13271 len += 1;
13272 }
13273 let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
13274 if self.revision != 0 {
13275 #[allow(clippy::needless_borrow)]
13276 #[allow(clippy::needless_borrows_for_generic_args)]
13277 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13278 }
13279 if self.resolve_no_shuffle_upstream {
13280 struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
13281 }
13282 if !self.worker_reschedules.is_empty() {
13283 struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
13284 }
13285 struct_ser.end()
13286 }
13287}
13288impl<'de> serde::Deserialize<'de> for RescheduleRequest {
13289 #[allow(deprecated)]
13290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13291 where
13292 D: serde::Deserializer<'de>,
13293 {
13294 const FIELDS: &[&str] = &[
13295 "revision",
13296 "resolve_no_shuffle_upstream",
13297 "resolveNoShuffleUpstream",
13298 "worker_reschedules",
13299 "workerReschedules",
13300 ];
13301
13302 #[allow(clippy::enum_variant_names)]
13303 enum GeneratedField {
13304 Revision,
13305 ResolveNoShuffleUpstream,
13306 WorkerReschedules,
13307 }
13308 impl<'de> serde::Deserialize<'de> for GeneratedField {
13309 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13310 where
13311 D: serde::Deserializer<'de>,
13312 {
13313 struct GeneratedVisitor;
13314
13315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13316 type Value = GeneratedField;
13317
13318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13319 write!(formatter, "expected one of: {:?}", &FIELDS)
13320 }
13321
13322 #[allow(unused_variables)]
13323 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13324 where
13325 E: serde::de::Error,
13326 {
13327 match value {
13328 "revision" => Ok(GeneratedField::Revision),
13329 "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
13330 "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
13331 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13332 }
13333 }
13334 }
13335 deserializer.deserialize_identifier(GeneratedVisitor)
13336 }
13337 }
13338 struct GeneratedVisitor;
13339 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13340 type Value = RescheduleRequest;
13341
13342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13343 formatter.write_str("struct meta.RescheduleRequest")
13344 }
13345
13346 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
13347 where
13348 V: serde::de::MapAccess<'de>,
13349 {
13350 let mut revision__ = None;
13351 let mut resolve_no_shuffle_upstream__ = None;
13352 let mut worker_reschedules__ = None;
13353 while let Some(k) = map_.next_key()? {
13354 match k {
13355 GeneratedField::Revision => {
13356 if revision__.is_some() {
13357 return Err(serde::de::Error::duplicate_field("revision"));
13358 }
13359 revision__ =
13360 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13361 ;
13362 }
13363 GeneratedField::ResolveNoShuffleUpstream => {
13364 if resolve_no_shuffle_upstream__.is_some() {
13365 return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
13366 }
13367 resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
13368 }
13369 GeneratedField::WorkerReschedules => {
13370 if worker_reschedules__.is_some() {
13371 return Err(serde::de::Error::duplicate_field("workerReschedules"));
13372 }
13373 worker_reschedules__ = Some(
13374 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13375 .into_iter().map(|(k,v)| (k.0, v)).collect()
13376 );
13377 }
13378 }
13379 }
13380 Ok(RescheduleRequest {
13381 revision: revision__.unwrap_or_default(),
13382 resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
13383 worker_reschedules: worker_reschedules__.unwrap_or_default(),
13384 })
13385 }
13386 }
13387 deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
13388 }
13389}
13390impl serde::Serialize for RescheduleResponse {
13391 #[allow(deprecated)]
13392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13393 where
13394 S: serde::Serializer,
13395 {
13396 use serde::ser::SerializeStruct;
13397 let mut len = 0;
13398 if self.success {
13399 len += 1;
13400 }
13401 if self.revision != 0 {
13402 len += 1;
13403 }
13404 let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
13405 if self.success {
13406 struct_ser.serialize_field("success", &self.success)?;
13407 }
13408 if self.revision != 0 {
13409 #[allow(clippy::needless_borrow)]
13410 #[allow(clippy::needless_borrows_for_generic_args)]
13411 struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13412 }
13413 struct_ser.end()
13414 }
13415}
13416impl<'de> serde::Deserialize<'de> for RescheduleResponse {
13417 #[allow(deprecated)]
13418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13419 where
13420 D: serde::Deserializer<'de>,
13421 {
13422 const FIELDS: &[&str] = &[
13423 "success",
13424 "revision",
13425 ];
13426
13427 #[allow(clippy::enum_variant_names)]
13428 enum GeneratedField {
13429 Success,
13430 Revision,
13431 }
13432 impl<'de> serde::Deserialize<'de> for GeneratedField {
13433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13434 where
13435 D: serde::Deserializer<'de>,
13436 {
13437 struct GeneratedVisitor;
13438
13439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13440 type Value = GeneratedField;
13441
13442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13443 write!(formatter, "expected one of: {:?}", &FIELDS)
13444 }
13445
13446 #[allow(unused_variables)]
13447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13448 where
13449 E: serde::de::Error,
13450 {
13451 match value {
13452 "success" => Ok(GeneratedField::Success),
13453 "revision" => Ok(GeneratedField::Revision),
13454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13455 }
13456 }
13457 }
13458 deserializer.deserialize_identifier(GeneratedVisitor)
13459 }
13460 }
13461 struct GeneratedVisitor;
13462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13463 type Value = RescheduleResponse;
13464
13465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13466 formatter.write_str("struct meta.RescheduleResponse")
13467 }
13468
13469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
13470 where
13471 V: serde::de::MapAccess<'de>,
13472 {
13473 let mut success__ = None;
13474 let mut revision__ = None;
13475 while let Some(k) = map_.next_key()? {
13476 match k {
13477 GeneratedField::Success => {
13478 if success__.is_some() {
13479 return Err(serde::de::Error::duplicate_field("success"));
13480 }
13481 success__ = Some(map_.next_value()?);
13482 }
13483 GeneratedField::Revision => {
13484 if revision__.is_some() {
13485 return Err(serde::de::Error::duplicate_field("revision"));
13486 }
13487 revision__ =
13488 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13489 ;
13490 }
13491 }
13492 }
13493 Ok(RescheduleResponse {
13494 success: success__.unwrap_or_default(),
13495 revision: revision__.unwrap_or_default(),
13496 })
13497 }
13498 }
13499 deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
13500 }
13501}
13502impl serde::Serialize for ResumeRequest {
13503 #[allow(deprecated)]
13504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13505 where
13506 S: serde::Serializer,
13507 {
13508 use serde::ser::SerializeStruct;
13509 let len = 0;
13510 let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
13511 struct_ser.end()
13512 }
13513}
13514impl<'de> serde::Deserialize<'de> for ResumeRequest {
13515 #[allow(deprecated)]
13516 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13517 where
13518 D: serde::Deserializer<'de>,
13519 {
13520 const FIELDS: &[&str] = &[
13521 ];
13522
13523 #[allow(clippy::enum_variant_names)]
13524 enum GeneratedField {
13525 }
13526 impl<'de> serde::Deserialize<'de> for GeneratedField {
13527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13528 where
13529 D: serde::Deserializer<'de>,
13530 {
13531 struct GeneratedVisitor;
13532
13533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13534 type Value = GeneratedField;
13535
13536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13537 write!(formatter, "expected one of: {:?}", &FIELDS)
13538 }
13539
13540 #[allow(unused_variables)]
13541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13542 where
13543 E: serde::de::Error,
13544 {
13545 Err(serde::de::Error::unknown_field(value, FIELDS))
13546 }
13547 }
13548 deserializer.deserialize_identifier(GeneratedVisitor)
13549 }
13550 }
13551 struct GeneratedVisitor;
13552 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13553 type Value = ResumeRequest;
13554
13555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13556 formatter.write_str("struct meta.ResumeRequest")
13557 }
13558
13559 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
13560 where
13561 V: serde::de::MapAccess<'de>,
13562 {
13563 while map_.next_key::<GeneratedField>()?.is_some() {
13564 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13565 }
13566 Ok(ResumeRequest {
13567 })
13568 }
13569 }
13570 deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13571 }
13572}
13573impl serde::Serialize for ResumeResponse {
13574 #[allow(deprecated)]
13575 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13576 where
13577 S: serde::Serializer,
13578 {
13579 use serde::ser::SerializeStruct;
13580 let len = 0;
13581 let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13582 struct_ser.end()
13583 }
13584}
13585impl<'de> serde::Deserialize<'de> for ResumeResponse {
13586 #[allow(deprecated)]
13587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13588 where
13589 D: serde::Deserializer<'de>,
13590 {
13591 const FIELDS: &[&str] = &[
13592 ];
13593
13594 #[allow(clippy::enum_variant_names)]
13595 enum GeneratedField {
13596 }
13597 impl<'de> serde::Deserialize<'de> for GeneratedField {
13598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13599 where
13600 D: serde::Deserializer<'de>,
13601 {
13602 struct GeneratedVisitor;
13603
13604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13605 type Value = GeneratedField;
13606
13607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13608 write!(formatter, "expected one of: {:?}", &FIELDS)
13609 }
13610
13611 #[allow(unused_variables)]
13612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13613 where
13614 E: serde::de::Error,
13615 {
13616 Err(serde::de::Error::unknown_field(value, FIELDS))
13617 }
13618 }
13619 deserializer.deserialize_identifier(GeneratedVisitor)
13620 }
13621 }
13622 struct GeneratedVisitor;
13623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13624 type Value = ResumeResponse;
13625
13626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13627 formatter.write_str("struct meta.ResumeResponse")
13628 }
13629
13630 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13631 where
13632 V: serde::de::MapAccess<'de>,
13633 {
13634 while map_.next_key::<GeneratedField>()?.is_some() {
13635 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13636 }
13637 Ok(ResumeResponse {
13638 })
13639 }
13640 }
13641 deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13642 }
13643}
13644impl serde::Serialize for SetSessionParamRequest {
13645 #[allow(deprecated)]
13646 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13647 where
13648 S: serde::Serializer,
13649 {
13650 use serde::ser::SerializeStruct;
13651 let mut len = 0;
13652 if !self.param.is_empty() {
13653 len += 1;
13654 }
13655 if self.value.is_some() {
13656 len += 1;
13657 }
13658 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13659 if !self.param.is_empty() {
13660 struct_ser.serialize_field("param", &self.param)?;
13661 }
13662 if let Some(v) = self.value.as_ref() {
13663 struct_ser.serialize_field("value", v)?;
13664 }
13665 struct_ser.end()
13666 }
13667}
13668impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13669 #[allow(deprecated)]
13670 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13671 where
13672 D: serde::Deserializer<'de>,
13673 {
13674 const FIELDS: &[&str] = &[
13675 "param",
13676 "value",
13677 ];
13678
13679 #[allow(clippy::enum_variant_names)]
13680 enum GeneratedField {
13681 Param,
13682 Value,
13683 }
13684 impl<'de> serde::Deserialize<'de> for GeneratedField {
13685 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13686 where
13687 D: serde::Deserializer<'de>,
13688 {
13689 struct GeneratedVisitor;
13690
13691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13692 type Value = GeneratedField;
13693
13694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13695 write!(formatter, "expected one of: {:?}", &FIELDS)
13696 }
13697
13698 #[allow(unused_variables)]
13699 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13700 where
13701 E: serde::de::Error,
13702 {
13703 match value {
13704 "param" => Ok(GeneratedField::Param),
13705 "value" => Ok(GeneratedField::Value),
13706 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13707 }
13708 }
13709 }
13710 deserializer.deserialize_identifier(GeneratedVisitor)
13711 }
13712 }
13713 struct GeneratedVisitor;
13714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13715 type Value = SetSessionParamRequest;
13716
13717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13718 formatter.write_str("struct meta.SetSessionParamRequest")
13719 }
13720
13721 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13722 where
13723 V: serde::de::MapAccess<'de>,
13724 {
13725 let mut param__ = None;
13726 let mut value__ = None;
13727 while let Some(k) = map_.next_key()? {
13728 match k {
13729 GeneratedField::Param => {
13730 if param__.is_some() {
13731 return Err(serde::de::Error::duplicate_field("param"));
13732 }
13733 param__ = Some(map_.next_value()?);
13734 }
13735 GeneratedField::Value => {
13736 if value__.is_some() {
13737 return Err(serde::de::Error::duplicate_field("value"));
13738 }
13739 value__ = map_.next_value()?;
13740 }
13741 }
13742 }
13743 Ok(SetSessionParamRequest {
13744 param: param__.unwrap_or_default(),
13745 value: value__,
13746 })
13747 }
13748 }
13749 deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13750 }
13751}
13752impl serde::Serialize for SetSessionParamResponse {
13753 #[allow(deprecated)]
13754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13755 where
13756 S: serde::Serializer,
13757 {
13758 use serde::ser::SerializeStruct;
13759 let mut len = 0;
13760 if !self.param.is_empty() {
13761 len += 1;
13762 }
13763 let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13764 if !self.param.is_empty() {
13765 struct_ser.serialize_field("param", &self.param)?;
13766 }
13767 struct_ser.end()
13768 }
13769}
13770impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13771 #[allow(deprecated)]
13772 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13773 where
13774 D: serde::Deserializer<'de>,
13775 {
13776 const FIELDS: &[&str] = &[
13777 "param",
13778 ];
13779
13780 #[allow(clippy::enum_variant_names)]
13781 enum GeneratedField {
13782 Param,
13783 }
13784 impl<'de> serde::Deserialize<'de> for GeneratedField {
13785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13786 where
13787 D: serde::Deserializer<'de>,
13788 {
13789 struct GeneratedVisitor;
13790
13791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13792 type Value = GeneratedField;
13793
13794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13795 write!(formatter, "expected one of: {:?}", &FIELDS)
13796 }
13797
13798 #[allow(unused_variables)]
13799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13800 where
13801 E: serde::de::Error,
13802 {
13803 match value {
13804 "param" => Ok(GeneratedField::Param),
13805 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13806 }
13807 }
13808 }
13809 deserializer.deserialize_identifier(GeneratedVisitor)
13810 }
13811 }
13812 struct GeneratedVisitor;
13813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13814 type Value = SetSessionParamResponse;
13815
13816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13817 formatter.write_str("struct meta.SetSessionParamResponse")
13818 }
13819
13820 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13821 where
13822 V: serde::de::MapAccess<'de>,
13823 {
13824 let mut param__ = None;
13825 while let Some(k) = map_.next_key()? {
13826 match k {
13827 GeneratedField::Param => {
13828 if param__.is_some() {
13829 return Err(serde::de::Error::duplicate_field("param"));
13830 }
13831 param__ = Some(map_.next_value()?);
13832 }
13833 }
13834 }
13835 Ok(SetSessionParamResponse {
13836 param: param__.unwrap_or_default(),
13837 })
13838 }
13839 }
13840 deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13841 }
13842}
13843impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13844 #[allow(deprecated)]
13845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13846 where
13847 S: serde::Serializer,
13848 {
13849 use serde::ser::SerializeStruct;
13850 let mut len = 0;
13851 if self.job_id != 0 {
13852 len += 1;
13853 }
13854 if self.aligned {
13855 len += 1;
13856 }
13857 let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13858 if self.job_id != 0 {
13859 struct_ser.serialize_field("jobId", &self.job_id)?;
13860 }
13861 if self.aligned {
13862 struct_ser.serialize_field("aligned", &self.aligned)?;
13863 }
13864 struct_ser.end()
13865 }
13866}
13867impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
13868 #[allow(deprecated)]
13869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13870 where
13871 D: serde::Deserializer<'de>,
13872 {
13873 const FIELDS: &[&str] = &[
13874 "job_id",
13875 "jobId",
13876 "aligned",
13877 ];
13878
13879 #[allow(clippy::enum_variant_names)]
13880 enum GeneratedField {
13881 JobId,
13882 Aligned,
13883 }
13884 impl<'de> serde::Deserialize<'de> for GeneratedField {
13885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13886 where
13887 D: serde::Deserializer<'de>,
13888 {
13889 struct GeneratedVisitor;
13890
13891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13892 type Value = GeneratedField;
13893
13894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13895 write!(formatter, "expected one of: {:?}", &FIELDS)
13896 }
13897
13898 #[allow(unused_variables)]
13899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13900 where
13901 E: serde::de::Error,
13902 {
13903 match value {
13904 "jobId" | "job_id" => Ok(GeneratedField::JobId),
13905 "aligned" => Ok(GeneratedField::Aligned),
13906 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13907 }
13908 }
13909 }
13910 deserializer.deserialize_identifier(GeneratedVisitor)
13911 }
13912 }
13913 struct GeneratedVisitor;
13914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13915 type Value = SetSyncLogStoreAlignedRequest;
13916
13917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13918 formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
13919 }
13920
13921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
13922 where
13923 V: serde::de::MapAccess<'de>,
13924 {
13925 let mut job_id__ = None;
13926 let mut aligned__ = None;
13927 while let Some(k) = map_.next_key()? {
13928 match k {
13929 GeneratedField::JobId => {
13930 if job_id__.is_some() {
13931 return Err(serde::de::Error::duplicate_field("jobId"));
13932 }
13933 job_id__ =
13934 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13935 ;
13936 }
13937 GeneratedField::Aligned => {
13938 if aligned__.is_some() {
13939 return Err(serde::de::Error::duplicate_field("aligned"));
13940 }
13941 aligned__ = Some(map_.next_value()?);
13942 }
13943 }
13944 }
13945 Ok(SetSyncLogStoreAlignedRequest {
13946 job_id: job_id__.unwrap_or_default(),
13947 aligned: aligned__.unwrap_or_default(),
13948 })
13949 }
13950 }
13951 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
13952 }
13953}
13954impl serde::Serialize for SetSyncLogStoreAlignedResponse {
13955 #[allow(deprecated)]
13956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13957 where
13958 S: serde::Serializer,
13959 {
13960 use serde::ser::SerializeStruct;
13961 let len = 0;
13962 let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
13963 struct_ser.end()
13964 }
13965}
13966impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
13967 #[allow(deprecated)]
13968 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13969 where
13970 D: serde::Deserializer<'de>,
13971 {
13972 const FIELDS: &[&str] = &[
13973 ];
13974
13975 #[allow(clippy::enum_variant_names)]
13976 enum GeneratedField {
13977 }
13978 impl<'de> serde::Deserialize<'de> for GeneratedField {
13979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13980 where
13981 D: serde::Deserializer<'de>,
13982 {
13983 struct GeneratedVisitor;
13984
13985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13986 type Value = GeneratedField;
13987
13988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13989 write!(formatter, "expected one of: {:?}", &FIELDS)
13990 }
13991
13992 #[allow(unused_variables)]
13993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13994 where
13995 E: serde::de::Error,
13996 {
13997 Err(serde::de::Error::unknown_field(value, FIELDS))
13998 }
13999 }
14000 deserializer.deserialize_identifier(GeneratedVisitor)
14001 }
14002 }
14003 struct GeneratedVisitor;
14004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14005 type Value = SetSyncLogStoreAlignedResponse;
14006
14007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14008 formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
14009 }
14010
14011 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
14012 where
14013 V: serde::de::MapAccess<'de>,
14014 {
14015 while map_.next_key::<GeneratedField>()?.is_some() {
14016 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14017 }
14018 Ok(SetSyncLogStoreAlignedResponse {
14019 })
14020 }
14021 }
14022 deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
14023 }
14024}
14025impl serde::Serialize for SetSystemParamRequest {
14026 #[allow(deprecated)]
14027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14028 where
14029 S: serde::Serializer,
14030 {
14031 use serde::ser::SerializeStruct;
14032 let mut len = 0;
14033 if !self.param.is_empty() {
14034 len += 1;
14035 }
14036 if self.value.is_some() {
14037 len += 1;
14038 }
14039 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
14040 if !self.param.is_empty() {
14041 struct_ser.serialize_field("param", &self.param)?;
14042 }
14043 if let Some(v) = self.value.as_ref() {
14044 struct_ser.serialize_field("value", v)?;
14045 }
14046 struct_ser.end()
14047 }
14048}
14049impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
14050 #[allow(deprecated)]
14051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14052 where
14053 D: serde::Deserializer<'de>,
14054 {
14055 const FIELDS: &[&str] = &[
14056 "param",
14057 "value",
14058 ];
14059
14060 #[allow(clippy::enum_variant_names)]
14061 enum GeneratedField {
14062 Param,
14063 Value,
14064 }
14065 impl<'de> serde::Deserialize<'de> for GeneratedField {
14066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14067 where
14068 D: serde::Deserializer<'de>,
14069 {
14070 struct GeneratedVisitor;
14071
14072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14073 type Value = GeneratedField;
14074
14075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14076 write!(formatter, "expected one of: {:?}", &FIELDS)
14077 }
14078
14079 #[allow(unused_variables)]
14080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14081 where
14082 E: serde::de::Error,
14083 {
14084 match value {
14085 "param" => Ok(GeneratedField::Param),
14086 "value" => Ok(GeneratedField::Value),
14087 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14088 }
14089 }
14090 }
14091 deserializer.deserialize_identifier(GeneratedVisitor)
14092 }
14093 }
14094 struct GeneratedVisitor;
14095 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14096 type Value = SetSystemParamRequest;
14097
14098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14099 formatter.write_str("struct meta.SetSystemParamRequest")
14100 }
14101
14102 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
14103 where
14104 V: serde::de::MapAccess<'de>,
14105 {
14106 let mut param__ = None;
14107 let mut value__ = None;
14108 while let Some(k) = map_.next_key()? {
14109 match k {
14110 GeneratedField::Param => {
14111 if param__.is_some() {
14112 return Err(serde::de::Error::duplicate_field("param"));
14113 }
14114 param__ = Some(map_.next_value()?);
14115 }
14116 GeneratedField::Value => {
14117 if value__.is_some() {
14118 return Err(serde::de::Error::duplicate_field("value"));
14119 }
14120 value__ = map_.next_value()?;
14121 }
14122 }
14123 }
14124 Ok(SetSystemParamRequest {
14125 param: param__.unwrap_or_default(),
14126 value: value__,
14127 })
14128 }
14129 }
14130 deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
14131 }
14132}
14133impl serde::Serialize for SetSystemParamResponse {
14134 #[allow(deprecated)]
14135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14136 where
14137 S: serde::Serializer,
14138 {
14139 use serde::ser::SerializeStruct;
14140 let mut len = 0;
14141 if self.params.is_some() {
14142 len += 1;
14143 }
14144 let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
14145 if let Some(v) = self.params.as_ref() {
14146 struct_ser.serialize_field("params", v)?;
14147 }
14148 struct_ser.end()
14149 }
14150}
14151impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
14152 #[allow(deprecated)]
14153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14154 where
14155 D: serde::Deserializer<'de>,
14156 {
14157 const FIELDS: &[&str] = &[
14158 "params",
14159 ];
14160
14161 #[allow(clippy::enum_variant_names)]
14162 enum GeneratedField {
14163 Params,
14164 }
14165 impl<'de> serde::Deserialize<'de> for GeneratedField {
14166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14167 where
14168 D: serde::Deserializer<'de>,
14169 {
14170 struct GeneratedVisitor;
14171
14172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14173 type Value = GeneratedField;
14174
14175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14176 write!(formatter, "expected one of: {:?}", &FIELDS)
14177 }
14178
14179 #[allow(unused_variables)]
14180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14181 where
14182 E: serde::de::Error,
14183 {
14184 match value {
14185 "params" => Ok(GeneratedField::Params),
14186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14187 }
14188 }
14189 }
14190 deserializer.deserialize_identifier(GeneratedVisitor)
14191 }
14192 }
14193 struct GeneratedVisitor;
14194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14195 type Value = SetSystemParamResponse;
14196
14197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14198 formatter.write_str("struct meta.SetSystemParamResponse")
14199 }
14200
14201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
14202 where
14203 V: serde::de::MapAccess<'de>,
14204 {
14205 let mut params__ = None;
14206 while let Some(k) = map_.next_key()? {
14207 match k {
14208 GeneratedField::Params => {
14209 if params__.is_some() {
14210 return Err(serde::de::Error::duplicate_field("params"));
14211 }
14212 params__ = map_.next_value()?;
14213 }
14214 }
14215 }
14216 Ok(SetSystemParamResponse {
14217 params: params__,
14218 })
14219 }
14220 }
14221 deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
14222 }
14223}
14224impl serde::Serialize for SubscribeRequest {
14225 #[allow(deprecated)]
14226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14227 where
14228 S: serde::Serializer,
14229 {
14230 use serde::ser::SerializeStruct;
14231 let mut len = 0;
14232 if self.subscribe_type != 0 {
14233 len += 1;
14234 }
14235 if self.host.is_some() {
14236 len += 1;
14237 }
14238 if self.worker_id != 0 {
14239 len += 1;
14240 }
14241 let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
14242 if self.subscribe_type != 0 {
14243 let v = SubscribeType::try_from(self.subscribe_type)
14244 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
14245 struct_ser.serialize_field("subscribeType", &v)?;
14246 }
14247 if let Some(v) = self.host.as_ref() {
14248 struct_ser.serialize_field("host", v)?;
14249 }
14250 if self.worker_id != 0 {
14251 struct_ser.serialize_field("workerId", &self.worker_id)?;
14252 }
14253 struct_ser.end()
14254 }
14255}
14256impl<'de> serde::Deserialize<'de> for SubscribeRequest {
14257 #[allow(deprecated)]
14258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14259 where
14260 D: serde::Deserializer<'de>,
14261 {
14262 const FIELDS: &[&str] = &[
14263 "subscribe_type",
14264 "subscribeType",
14265 "host",
14266 "worker_id",
14267 "workerId",
14268 ];
14269
14270 #[allow(clippy::enum_variant_names)]
14271 enum GeneratedField {
14272 SubscribeType,
14273 Host,
14274 WorkerId,
14275 }
14276 impl<'de> serde::Deserialize<'de> for GeneratedField {
14277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14278 where
14279 D: serde::Deserializer<'de>,
14280 {
14281 struct GeneratedVisitor;
14282
14283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14284 type Value = GeneratedField;
14285
14286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14287 write!(formatter, "expected one of: {:?}", &FIELDS)
14288 }
14289
14290 #[allow(unused_variables)]
14291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14292 where
14293 E: serde::de::Error,
14294 {
14295 match value {
14296 "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
14297 "host" => Ok(GeneratedField::Host),
14298 "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
14299 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14300 }
14301 }
14302 }
14303 deserializer.deserialize_identifier(GeneratedVisitor)
14304 }
14305 }
14306 struct GeneratedVisitor;
14307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14308 type Value = SubscribeRequest;
14309
14310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14311 formatter.write_str("struct meta.SubscribeRequest")
14312 }
14313
14314 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
14315 where
14316 V: serde::de::MapAccess<'de>,
14317 {
14318 let mut subscribe_type__ = None;
14319 let mut host__ = None;
14320 let mut worker_id__ = None;
14321 while let Some(k) = map_.next_key()? {
14322 match k {
14323 GeneratedField::SubscribeType => {
14324 if subscribe_type__.is_some() {
14325 return Err(serde::de::Error::duplicate_field("subscribeType"));
14326 }
14327 subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
14328 }
14329 GeneratedField::Host => {
14330 if host__.is_some() {
14331 return Err(serde::de::Error::duplicate_field("host"));
14332 }
14333 host__ = map_.next_value()?;
14334 }
14335 GeneratedField::WorkerId => {
14336 if worker_id__.is_some() {
14337 return Err(serde::de::Error::duplicate_field("workerId"));
14338 }
14339 worker_id__ =
14340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14341 ;
14342 }
14343 }
14344 }
14345 Ok(SubscribeRequest {
14346 subscribe_type: subscribe_type__.unwrap_or_default(),
14347 host: host__,
14348 worker_id: worker_id__.unwrap_or_default(),
14349 })
14350 }
14351 }
14352 deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
14353 }
14354}
14355impl serde::Serialize for SubscribeResponse {
14356 #[allow(deprecated)]
14357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14358 where
14359 S: serde::Serializer,
14360 {
14361 use serde::ser::SerializeStruct;
14362 let mut len = 0;
14363 if self.status.is_some() {
14364 len += 1;
14365 }
14366 if self.operation != 0 {
14367 len += 1;
14368 }
14369 if self.version != 0 {
14370 len += 1;
14371 }
14372 if self.info.is_some() {
14373 len += 1;
14374 }
14375 let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
14376 if let Some(v) = self.status.as_ref() {
14377 struct_ser.serialize_field("status", v)?;
14378 }
14379 if self.operation != 0 {
14380 let v = subscribe_response::Operation::try_from(self.operation)
14381 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
14382 struct_ser.serialize_field("operation", &v)?;
14383 }
14384 if self.version != 0 {
14385 #[allow(clippy::needless_borrow)]
14386 #[allow(clippy::needless_borrows_for_generic_args)]
14387 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
14388 }
14389 if let Some(v) = self.info.as_ref() {
14390 match v {
14391 subscribe_response::Info::Database(v) => {
14392 struct_ser.serialize_field("database", v)?;
14393 }
14394 subscribe_response::Info::Schema(v) => {
14395 struct_ser.serialize_field("schema", v)?;
14396 }
14397 subscribe_response::Info::Function(v) => {
14398 struct_ser.serialize_field("function", v)?;
14399 }
14400 subscribe_response::Info::User(v) => {
14401 struct_ser.serialize_field("user", v)?;
14402 }
14403 subscribe_response::Info::SessionParam(v) => {
14404 struct_ser.serialize_field("sessionParam", v)?;
14405 }
14406 subscribe_response::Info::Node(v) => {
14407 struct_ser.serialize_field("node", v)?;
14408 }
14409 subscribe_response::Info::HummockVersionDeltas(v) => {
14410 struct_ser.serialize_field("hummockVersionDeltas", v)?;
14411 }
14412 subscribe_response::Info::Snapshot(v) => {
14413 struct_ser.serialize_field("snapshot", v)?;
14414 }
14415 subscribe_response::Info::MetaBackupManifestId(v) => {
14416 struct_ser.serialize_field("metaBackupManifestId", v)?;
14417 }
14418 subscribe_response::Info::SystemParams(v) => {
14419 struct_ser.serialize_field("systemParams", v)?;
14420 }
14421 subscribe_response::Info::HummockWriteLimits(v) => {
14422 struct_ser.serialize_field("hummockWriteLimits", v)?;
14423 }
14424 subscribe_response::Info::ObjectGroup(v) => {
14425 struct_ser.serialize_field("objectGroup", v)?;
14426 }
14427 subscribe_response::Info::Connection(v) => {
14428 struct_ser.serialize_field("connection", v)?;
14429 }
14430 subscribe_response::Info::HummockStats(v) => {
14431 struct_ser.serialize_field("hummockStats", v)?;
14432 }
14433 subscribe_response::Info::Recovery(v) => {
14434 struct_ser.serialize_field("recovery", v)?;
14435 }
14436 subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
14437 struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
14438 }
14439 subscribe_response::Info::ServingWorkerSlotMappings(v) => {
14440 struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
14441 }
14442 subscribe_response::Info::Secret(v) => {
14443 struct_ser.serialize_field("secret", v)?;
14444 }
14445 subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
14446 #[allow(clippy::needless_borrow)]
14447 #[allow(clippy::needless_borrows_for_generic_args)]
14448 struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
14449 }
14450 }
14451 }
14452 struct_ser.end()
14453 }
14454}
14455impl<'de> serde::Deserialize<'de> for SubscribeResponse {
14456 #[allow(deprecated)]
14457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14458 where
14459 D: serde::Deserializer<'de>,
14460 {
14461 const FIELDS: &[&str] = &[
14462 "status",
14463 "operation",
14464 "version",
14465 "database",
14466 "schema",
14467 "function",
14468 "user",
14469 "session_param",
14470 "sessionParam",
14471 "node",
14472 "hummock_version_deltas",
14473 "hummockVersionDeltas",
14474 "snapshot",
14475 "meta_backup_manifest_id",
14476 "metaBackupManifestId",
14477 "system_params",
14478 "systemParams",
14479 "hummock_write_limits",
14480 "hummockWriteLimits",
14481 "object_group",
14482 "objectGroup",
14483 "connection",
14484 "hummock_stats",
14485 "hummockStats",
14486 "recovery",
14487 "streaming_worker_slot_mapping",
14488 "streamingWorkerSlotMapping",
14489 "serving_worker_slot_mappings",
14490 "servingWorkerSlotMappings",
14491 "secret",
14492 "compute_node_total_cpu_count",
14493 "computeNodeTotalCpuCount",
14494 ];
14495
14496 #[allow(clippy::enum_variant_names)]
14497 enum GeneratedField {
14498 Status,
14499 Operation,
14500 Version,
14501 Database,
14502 Schema,
14503 Function,
14504 User,
14505 SessionParam,
14506 Node,
14507 HummockVersionDeltas,
14508 Snapshot,
14509 MetaBackupManifestId,
14510 SystemParams,
14511 HummockWriteLimits,
14512 ObjectGroup,
14513 Connection,
14514 HummockStats,
14515 Recovery,
14516 StreamingWorkerSlotMapping,
14517 ServingWorkerSlotMappings,
14518 Secret,
14519 ComputeNodeTotalCpuCount,
14520 }
14521 impl<'de> serde::Deserialize<'de> for GeneratedField {
14522 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14523 where
14524 D: serde::Deserializer<'de>,
14525 {
14526 struct GeneratedVisitor;
14527
14528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14529 type Value = GeneratedField;
14530
14531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14532 write!(formatter, "expected one of: {:?}", &FIELDS)
14533 }
14534
14535 #[allow(unused_variables)]
14536 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14537 where
14538 E: serde::de::Error,
14539 {
14540 match value {
14541 "status" => Ok(GeneratedField::Status),
14542 "operation" => Ok(GeneratedField::Operation),
14543 "version" => Ok(GeneratedField::Version),
14544 "database" => Ok(GeneratedField::Database),
14545 "schema" => Ok(GeneratedField::Schema),
14546 "function" => Ok(GeneratedField::Function),
14547 "user" => Ok(GeneratedField::User),
14548 "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14549 "node" => Ok(GeneratedField::Node),
14550 "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14551 "snapshot" => Ok(GeneratedField::Snapshot),
14552 "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14553 "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14554 "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14555 "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14556 "connection" => Ok(GeneratedField::Connection),
14557 "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14558 "recovery" => Ok(GeneratedField::Recovery),
14559 "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14560 "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14561 "secret" => Ok(GeneratedField::Secret),
14562 "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
14563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14564 }
14565 }
14566 }
14567 deserializer.deserialize_identifier(GeneratedVisitor)
14568 }
14569 }
14570 struct GeneratedVisitor;
14571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14572 type Value = SubscribeResponse;
14573
14574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14575 formatter.write_str("struct meta.SubscribeResponse")
14576 }
14577
14578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14579 where
14580 V: serde::de::MapAccess<'de>,
14581 {
14582 let mut status__ = None;
14583 let mut operation__ = None;
14584 let mut version__ = None;
14585 let mut info__ = None;
14586 while let Some(k) = map_.next_key()? {
14587 match k {
14588 GeneratedField::Status => {
14589 if status__.is_some() {
14590 return Err(serde::de::Error::duplicate_field("status"));
14591 }
14592 status__ = map_.next_value()?;
14593 }
14594 GeneratedField::Operation => {
14595 if operation__.is_some() {
14596 return Err(serde::de::Error::duplicate_field("operation"));
14597 }
14598 operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14599 }
14600 GeneratedField::Version => {
14601 if version__.is_some() {
14602 return Err(serde::de::Error::duplicate_field("version"));
14603 }
14604 version__ =
14605 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14606 ;
14607 }
14608 GeneratedField::Database => {
14609 if info__.is_some() {
14610 return Err(serde::de::Error::duplicate_field("database"));
14611 }
14612 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14613;
14614 }
14615 GeneratedField::Schema => {
14616 if info__.is_some() {
14617 return Err(serde::de::Error::duplicate_field("schema"));
14618 }
14619 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14620;
14621 }
14622 GeneratedField::Function => {
14623 if info__.is_some() {
14624 return Err(serde::de::Error::duplicate_field("function"));
14625 }
14626 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14627;
14628 }
14629 GeneratedField::User => {
14630 if info__.is_some() {
14631 return Err(serde::de::Error::duplicate_field("user"));
14632 }
14633 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14634;
14635 }
14636 GeneratedField::SessionParam => {
14637 if info__.is_some() {
14638 return Err(serde::de::Error::duplicate_field("sessionParam"));
14639 }
14640 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14641;
14642 }
14643 GeneratedField::Node => {
14644 if info__.is_some() {
14645 return Err(serde::de::Error::duplicate_field("node"));
14646 }
14647 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14648;
14649 }
14650 GeneratedField::HummockVersionDeltas => {
14651 if info__.is_some() {
14652 return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14653 }
14654 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14655;
14656 }
14657 GeneratedField::Snapshot => {
14658 if info__.is_some() {
14659 return Err(serde::de::Error::duplicate_field("snapshot"));
14660 }
14661 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14662;
14663 }
14664 GeneratedField::MetaBackupManifestId => {
14665 if info__.is_some() {
14666 return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14667 }
14668 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14669;
14670 }
14671 GeneratedField::SystemParams => {
14672 if info__.is_some() {
14673 return Err(serde::de::Error::duplicate_field("systemParams"));
14674 }
14675 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14676;
14677 }
14678 GeneratedField::HummockWriteLimits => {
14679 if info__.is_some() {
14680 return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14681 }
14682 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14683;
14684 }
14685 GeneratedField::ObjectGroup => {
14686 if info__.is_some() {
14687 return Err(serde::de::Error::duplicate_field("objectGroup"));
14688 }
14689 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14690;
14691 }
14692 GeneratedField::Connection => {
14693 if info__.is_some() {
14694 return Err(serde::de::Error::duplicate_field("connection"));
14695 }
14696 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14697;
14698 }
14699 GeneratedField::HummockStats => {
14700 if info__.is_some() {
14701 return Err(serde::de::Error::duplicate_field("hummockStats"));
14702 }
14703 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14704;
14705 }
14706 GeneratedField::Recovery => {
14707 if info__.is_some() {
14708 return Err(serde::de::Error::duplicate_field("recovery"));
14709 }
14710 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14711;
14712 }
14713 GeneratedField::StreamingWorkerSlotMapping => {
14714 if info__.is_some() {
14715 return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14716 }
14717 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14718;
14719 }
14720 GeneratedField::ServingWorkerSlotMappings => {
14721 if info__.is_some() {
14722 return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14723 }
14724 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14725;
14726 }
14727 GeneratedField::Secret => {
14728 if info__.is_some() {
14729 return Err(serde::de::Error::duplicate_field("secret"));
14730 }
14731 info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14732;
14733 }
14734 GeneratedField::ComputeNodeTotalCpuCount => {
14735 if info__.is_some() {
14736 return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
14737 }
14738 info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
14739 }
14740 }
14741 }
14742 Ok(SubscribeResponse {
14743 status: status__,
14744 operation: operation__.unwrap_or_default(),
14745 version: version__.unwrap_or_default(),
14746 info: info__,
14747 })
14748 }
14749 }
14750 deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14751 }
14752}
14753impl serde::Serialize for subscribe_response::Operation {
14754 #[allow(deprecated)]
14755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14756 where
14757 S: serde::Serializer,
14758 {
14759 let variant = match self {
14760 Self::Unspecified => "UNSPECIFIED",
14761 Self::Add => "ADD",
14762 Self::Delete => "DELETE",
14763 Self::Update => "UPDATE",
14764 Self::Snapshot => "SNAPSHOT",
14765 };
14766 serializer.serialize_str(variant)
14767 }
14768}
14769impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14770 #[allow(deprecated)]
14771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14772 where
14773 D: serde::Deserializer<'de>,
14774 {
14775 const FIELDS: &[&str] = &[
14776 "UNSPECIFIED",
14777 "ADD",
14778 "DELETE",
14779 "UPDATE",
14780 "SNAPSHOT",
14781 ];
14782
14783 struct GeneratedVisitor;
14784
14785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14786 type Value = subscribe_response::Operation;
14787
14788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14789 write!(formatter, "expected one of: {:?}", &FIELDS)
14790 }
14791
14792 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14793 where
14794 E: serde::de::Error,
14795 {
14796 i32::try_from(v)
14797 .ok()
14798 .and_then(|x| x.try_into().ok())
14799 .ok_or_else(|| {
14800 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14801 })
14802 }
14803
14804 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14805 where
14806 E: serde::de::Error,
14807 {
14808 i32::try_from(v)
14809 .ok()
14810 .and_then(|x| x.try_into().ok())
14811 .ok_or_else(|| {
14812 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14813 })
14814 }
14815
14816 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14817 where
14818 E: serde::de::Error,
14819 {
14820 match value {
14821 "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14822 "ADD" => Ok(subscribe_response::Operation::Add),
14823 "DELETE" => Ok(subscribe_response::Operation::Delete),
14824 "UPDATE" => Ok(subscribe_response::Operation::Update),
14825 "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14826 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14827 }
14828 }
14829 }
14830 deserializer.deserialize_any(GeneratedVisitor)
14831 }
14832}
14833impl serde::Serialize for SubscribeType {
14834 #[allow(deprecated)]
14835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14836 where
14837 S: serde::Serializer,
14838 {
14839 let variant = match self {
14840 Self::Unspecified => "UNSPECIFIED",
14841 Self::Frontend => "FRONTEND",
14842 Self::Hummock => "HUMMOCK",
14843 Self::Compactor => "COMPACTOR",
14844 Self::Compute => "COMPUTE",
14845 };
14846 serializer.serialize_str(variant)
14847 }
14848}
14849impl<'de> serde::Deserialize<'de> for SubscribeType {
14850 #[allow(deprecated)]
14851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14852 where
14853 D: serde::Deserializer<'de>,
14854 {
14855 const FIELDS: &[&str] = &[
14856 "UNSPECIFIED",
14857 "FRONTEND",
14858 "HUMMOCK",
14859 "COMPACTOR",
14860 "COMPUTE",
14861 ];
14862
14863 struct GeneratedVisitor;
14864
14865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14866 type Value = SubscribeType;
14867
14868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14869 write!(formatter, "expected one of: {:?}", &FIELDS)
14870 }
14871
14872 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14873 where
14874 E: serde::de::Error,
14875 {
14876 i32::try_from(v)
14877 .ok()
14878 .and_then(|x| x.try_into().ok())
14879 .ok_or_else(|| {
14880 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14881 })
14882 }
14883
14884 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14885 where
14886 E: serde::de::Error,
14887 {
14888 i32::try_from(v)
14889 .ok()
14890 .and_then(|x| x.try_into().ok())
14891 .ok_or_else(|| {
14892 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14893 })
14894 }
14895
14896 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14897 where
14898 E: serde::de::Error,
14899 {
14900 match value {
14901 "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
14902 "FRONTEND" => Ok(SubscribeType::Frontend),
14903 "HUMMOCK" => Ok(SubscribeType::Hummock),
14904 "COMPACTOR" => Ok(SubscribeType::Compactor),
14905 "COMPUTE" => Ok(SubscribeType::Compute),
14906 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14907 }
14908 }
14909 }
14910 deserializer.deserialize_any(GeneratedVisitor)
14911 }
14912}
14913impl serde::Serialize for SystemParams {
14914 #[allow(deprecated)]
14915 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14916 where
14917 S: serde::Serializer,
14918 {
14919 use serde::ser::SerializeStruct;
14920 let mut len = 0;
14921 if self.barrier_interval_ms.is_some() {
14922 len += 1;
14923 }
14924 if self.checkpoint_frequency.is_some() {
14925 len += 1;
14926 }
14927 if self.sstable_size_mb.is_some() {
14928 len += 1;
14929 }
14930 if self.block_size_kb.is_some() {
14931 len += 1;
14932 }
14933 if self.bloom_false_positive.is_some() {
14934 len += 1;
14935 }
14936 if self.state_store.is_some() {
14937 len += 1;
14938 }
14939 if self.data_directory.is_some() {
14940 len += 1;
14941 }
14942 if self.backup_storage_url.is_some() {
14943 len += 1;
14944 }
14945 if self.backup_storage_directory.is_some() {
14946 len += 1;
14947 }
14948 if self.telemetry_enabled.is_some() {
14949 len += 1;
14950 }
14951 if self.parallel_compact_size_mb.is_some() {
14952 len += 1;
14953 }
14954 if self.max_concurrent_creating_streaming_jobs.is_some() {
14955 len += 1;
14956 }
14957 if self.pause_on_next_bootstrap.is_some() {
14958 len += 1;
14959 }
14960 if self.wasm_storage_url.is_some() {
14961 len += 1;
14962 }
14963 if self.enable_tracing.is_some() {
14964 len += 1;
14965 }
14966 if self.use_new_object_prefix_strategy.is_some() {
14967 len += 1;
14968 }
14969 if self.license_key.is_some() {
14970 len += 1;
14971 }
14972 if self.time_travel_retention_ms.is_some() {
14973 len += 1;
14974 }
14975 if self.adaptive_parallelism_strategy.is_some() {
14976 len += 1;
14977 }
14978 if self.per_database_isolation.is_some() {
14979 len += 1;
14980 }
14981 if self.enforce_secret.is_some() {
14982 len += 1;
14983 }
14984 let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
14985 if let Some(v) = self.barrier_interval_ms.as_ref() {
14986 struct_ser.serialize_field("barrierIntervalMs", v)?;
14987 }
14988 if let Some(v) = self.checkpoint_frequency.as_ref() {
14989 #[allow(clippy::needless_borrow)]
14990 #[allow(clippy::needless_borrows_for_generic_args)]
14991 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
14992 }
14993 if let Some(v) = self.sstable_size_mb.as_ref() {
14994 struct_ser.serialize_field("sstableSizeMb", v)?;
14995 }
14996 if let Some(v) = self.block_size_kb.as_ref() {
14997 struct_ser.serialize_field("blockSizeKb", v)?;
14998 }
14999 if let Some(v) = self.bloom_false_positive.as_ref() {
15000 struct_ser.serialize_field("bloomFalsePositive", v)?;
15001 }
15002 if let Some(v) = self.state_store.as_ref() {
15003 struct_ser.serialize_field("stateStore", v)?;
15004 }
15005 if let Some(v) = self.data_directory.as_ref() {
15006 struct_ser.serialize_field("dataDirectory", v)?;
15007 }
15008 if let Some(v) = self.backup_storage_url.as_ref() {
15009 struct_ser.serialize_field("backupStorageUrl", v)?;
15010 }
15011 if let Some(v) = self.backup_storage_directory.as_ref() {
15012 struct_ser.serialize_field("backupStorageDirectory", v)?;
15013 }
15014 if let Some(v) = self.telemetry_enabled.as_ref() {
15015 struct_ser.serialize_field("telemetryEnabled", v)?;
15016 }
15017 if let Some(v) = self.parallel_compact_size_mb.as_ref() {
15018 struct_ser.serialize_field("parallelCompactSizeMb", v)?;
15019 }
15020 if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
15021 struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
15022 }
15023 if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
15024 struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
15025 }
15026 if let Some(v) = self.wasm_storage_url.as_ref() {
15027 struct_ser.serialize_field("wasmStorageUrl", v)?;
15028 }
15029 if let Some(v) = self.enable_tracing.as_ref() {
15030 struct_ser.serialize_field("enableTracing", v)?;
15031 }
15032 if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
15033 struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
15034 }
15035 if let Some(v) = self.license_key.as_ref() {
15036 struct_ser.serialize_field("licenseKey", v)?;
15037 }
15038 if let Some(v) = self.time_travel_retention_ms.as_ref() {
15039 #[allow(clippy::needless_borrow)]
15040 #[allow(clippy::needless_borrows_for_generic_args)]
15041 struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
15042 }
15043 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
15044 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
15045 }
15046 if let Some(v) = self.per_database_isolation.as_ref() {
15047 struct_ser.serialize_field("perDatabaseIsolation", v)?;
15048 }
15049 if let Some(v) = self.enforce_secret.as_ref() {
15050 struct_ser.serialize_field("enforceSecret", v)?;
15051 }
15052 struct_ser.end()
15053 }
15054}
15055impl<'de> serde::Deserialize<'de> for SystemParams {
15056 #[allow(deprecated)]
15057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15058 where
15059 D: serde::Deserializer<'de>,
15060 {
15061 const FIELDS: &[&str] = &[
15062 "barrier_interval_ms",
15063 "barrierIntervalMs",
15064 "checkpoint_frequency",
15065 "checkpointFrequency",
15066 "sstable_size_mb",
15067 "sstableSizeMb",
15068 "block_size_kb",
15069 "blockSizeKb",
15070 "bloom_false_positive",
15071 "bloomFalsePositive",
15072 "state_store",
15073 "stateStore",
15074 "data_directory",
15075 "dataDirectory",
15076 "backup_storage_url",
15077 "backupStorageUrl",
15078 "backup_storage_directory",
15079 "backupStorageDirectory",
15080 "telemetry_enabled",
15081 "telemetryEnabled",
15082 "parallel_compact_size_mb",
15083 "parallelCompactSizeMb",
15084 "max_concurrent_creating_streaming_jobs",
15085 "maxConcurrentCreatingStreamingJobs",
15086 "pause_on_next_bootstrap",
15087 "pauseOnNextBootstrap",
15088 "wasm_storage_url",
15089 "wasmStorageUrl",
15090 "enable_tracing",
15091 "enableTracing",
15092 "use_new_object_prefix_strategy",
15093 "useNewObjectPrefixStrategy",
15094 "license_key",
15095 "licenseKey",
15096 "time_travel_retention_ms",
15097 "timeTravelRetentionMs",
15098 "adaptive_parallelism_strategy",
15099 "adaptiveParallelismStrategy",
15100 "per_database_isolation",
15101 "perDatabaseIsolation",
15102 "enforce_secret",
15103 "enforceSecret",
15104 ];
15105
15106 #[allow(clippy::enum_variant_names)]
15107 enum GeneratedField {
15108 BarrierIntervalMs,
15109 CheckpointFrequency,
15110 SstableSizeMb,
15111 BlockSizeKb,
15112 BloomFalsePositive,
15113 StateStore,
15114 DataDirectory,
15115 BackupStorageUrl,
15116 BackupStorageDirectory,
15117 TelemetryEnabled,
15118 ParallelCompactSizeMb,
15119 MaxConcurrentCreatingStreamingJobs,
15120 PauseOnNextBootstrap,
15121 WasmStorageUrl,
15122 EnableTracing,
15123 UseNewObjectPrefixStrategy,
15124 LicenseKey,
15125 TimeTravelRetentionMs,
15126 AdaptiveParallelismStrategy,
15127 PerDatabaseIsolation,
15128 EnforceSecret,
15129 }
15130 impl<'de> serde::Deserialize<'de> for GeneratedField {
15131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15132 where
15133 D: serde::Deserializer<'de>,
15134 {
15135 struct GeneratedVisitor;
15136
15137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15138 type Value = GeneratedField;
15139
15140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15141 write!(formatter, "expected one of: {:?}", &FIELDS)
15142 }
15143
15144 #[allow(unused_variables)]
15145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15146 where
15147 E: serde::de::Error,
15148 {
15149 match value {
15150 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
15151 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
15152 "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
15153 "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
15154 "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
15155 "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
15156 "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
15157 "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
15158 "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
15159 "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
15160 "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
15161 "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
15162 "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
15163 "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
15164 "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
15165 "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
15166 "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
15167 "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
15168 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15169 "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
15170 "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
15171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15172 }
15173 }
15174 }
15175 deserializer.deserialize_identifier(GeneratedVisitor)
15176 }
15177 }
15178 struct GeneratedVisitor;
15179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15180 type Value = SystemParams;
15181
15182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15183 formatter.write_str("struct meta.SystemParams")
15184 }
15185
15186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
15187 where
15188 V: serde::de::MapAccess<'de>,
15189 {
15190 let mut barrier_interval_ms__ = None;
15191 let mut checkpoint_frequency__ = None;
15192 let mut sstable_size_mb__ = None;
15193 let mut block_size_kb__ = None;
15194 let mut bloom_false_positive__ = None;
15195 let mut state_store__ = None;
15196 let mut data_directory__ = None;
15197 let mut backup_storage_url__ = None;
15198 let mut backup_storage_directory__ = None;
15199 let mut telemetry_enabled__ = None;
15200 let mut parallel_compact_size_mb__ = None;
15201 let mut max_concurrent_creating_streaming_jobs__ = None;
15202 let mut pause_on_next_bootstrap__ = None;
15203 let mut wasm_storage_url__ = None;
15204 let mut enable_tracing__ = None;
15205 let mut use_new_object_prefix_strategy__ = None;
15206 let mut license_key__ = None;
15207 let mut time_travel_retention_ms__ = None;
15208 let mut adaptive_parallelism_strategy__ = None;
15209 let mut per_database_isolation__ = None;
15210 let mut enforce_secret__ = None;
15211 while let Some(k) = map_.next_key()? {
15212 match k {
15213 GeneratedField::BarrierIntervalMs => {
15214 if barrier_interval_ms__.is_some() {
15215 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
15216 }
15217 barrier_interval_ms__ =
15218 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15219 ;
15220 }
15221 GeneratedField::CheckpointFrequency => {
15222 if checkpoint_frequency__.is_some() {
15223 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
15224 }
15225 checkpoint_frequency__ =
15226 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15227 ;
15228 }
15229 GeneratedField::SstableSizeMb => {
15230 if sstable_size_mb__.is_some() {
15231 return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
15232 }
15233 sstable_size_mb__ =
15234 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15235 ;
15236 }
15237 GeneratedField::BlockSizeKb => {
15238 if block_size_kb__.is_some() {
15239 return Err(serde::de::Error::duplicate_field("blockSizeKb"));
15240 }
15241 block_size_kb__ =
15242 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15243 ;
15244 }
15245 GeneratedField::BloomFalsePositive => {
15246 if bloom_false_positive__.is_some() {
15247 return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
15248 }
15249 bloom_false_positive__ =
15250 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15251 ;
15252 }
15253 GeneratedField::StateStore => {
15254 if state_store__.is_some() {
15255 return Err(serde::de::Error::duplicate_field("stateStore"));
15256 }
15257 state_store__ = map_.next_value()?;
15258 }
15259 GeneratedField::DataDirectory => {
15260 if data_directory__.is_some() {
15261 return Err(serde::de::Error::duplicate_field("dataDirectory"));
15262 }
15263 data_directory__ = map_.next_value()?;
15264 }
15265 GeneratedField::BackupStorageUrl => {
15266 if backup_storage_url__.is_some() {
15267 return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
15268 }
15269 backup_storage_url__ = map_.next_value()?;
15270 }
15271 GeneratedField::BackupStorageDirectory => {
15272 if backup_storage_directory__.is_some() {
15273 return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
15274 }
15275 backup_storage_directory__ = map_.next_value()?;
15276 }
15277 GeneratedField::TelemetryEnabled => {
15278 if telemetry_enabled__.is_some() {
15279 return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
15280 }
15281 telemetry_enabled__ = map_.next_value()?;
15282 }
15283 GeneratedField::ParallelCompactSizeMb => {
15284 if parallel_compact_size_mb__.is_some() {
15285 return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
15286 }
15287 parallel_compact_size_mb__ =
15288 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15289 ;
15290 }
15291 GeneratedField::MaxConcurrentCreatingStreamingJobs => {
15292 if max_concurrent_creating_streaming_jobs__.is_some() {
15293 return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
15294 }
15295 max_concurrent_creating_streaming_jobs__ =
15296 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15297 ;
15298 }
15299 GeneratedField::PauseOnNextBootstrap => {
15300 if pause_on_next_bootstrap__.is_some() {
15301 return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
15302 }
15303 pause_on_next_bootstrap__ = map_.next_value()?;
15304 }
15305 GeneratedField::WasmStorageUrl => {
15306 if wasm_storage_url__.is_some() {
15307 return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
15308 }
15309 wasm_storage_url__ = map_.next_value()?;
15310 }
15311 GeneratedField::EnableTracing => {
15312 if enable_tracing__.is_some() {
15313 return Err(serde::de::Error::duplicate_field("enableTracing"));
15314 }
15315 enable_tracing__ = map_.next_value()?;
15316 }
15317 GeneratedField::UseNewObjectPrefixStrategy => {
15318 if use_new_object_prefix_strategy__.is_some() {
15319 return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
15320 }
15321 use_new_object_prefix_strategy__ = map_.next_value()?;
15322 }
15323 GeneratedField::LicenseKey => {
15324 if license_key__.is_some() {
15325 return Err(serde::de::Error::duplicate_field("licenseKey"));
15326 }
15327 license_key__ = map_.next_value()?;
15328 }
15329 GeneratedField::TimeTravelRetentionMs => {
15330 if time_travel_retention_ms__.is_some() {
15331 return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
15332 }
15333 time_travel_retention_ms__ =
15334 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15335 ;
15336 }
15337 GeneratedField::AdaptiveParallelismStrategy => {
15338 if adaptive_parallelism_strategy__.is_some() {
15339 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15340 }
15341 adaptive_parallelism_strategy__ = map_.next_value()?;
15342 }
15343 GeneratedField::PerDatabaseIsolation => {
15344 if per_database_isolation__.is_some() {
15345 return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
15346 }
15347 per_database_isolation__ = map_.next_value()?;
15348 }
15349 GeneratedField::EnforceSecret => {
15350 if enforce_secret__.is_some() {
15351 return Err(serde::de::Error::duplicate_field("enforceSecret"));
15352 }
15353 enforce_secret__ = map_.next_value()?;
15354 }
15355 }
15356 }
15357 Ok(SystemParams {
15358 barrier_interval_ms: barrier_interval_ms__,
15359 checkpoint_frequency: checkpoint_frequency__,
15360 sstable_size_mb: sstable_size_mb__,
15361 block_size_kb: block_size_kb__,
15362 bloom_false_positive: bloom_false_positive__,
15363 state_store: state_store__,
15364 data_directory: data_directory__,
15365 backup_storage_url: backup_storage_url__,
15366 backup_storage_directory: backup_storage_directory__,
15367 telemetry_enabled: telemetry_enabled__,
15368 parallel_compact_size_mb: parallel_compact_size_mb__,
15369 max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
15370 pause_on_next_bootstrap: pause_on_next_bootstrap__,
15371 wasm_storage_url: wasm_storage_url__,
15372 enable_tracing: enable_tracing__,
15373 use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
15374 license_key: license_key__,
15375 time_travel_retention_ms: time_travel_retention_ms__,
15376 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
15377 per_database_isolation: per_database_isolation__,
15378 enforce_secret: enforce_secret__,
15379 })
15380 }
15381 }
15382 deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
15383 }
15384}
15385impl serde::Serialize for TableFragments {
15386 #[allow(deprecated)]
15387 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15388 where
15389 S: serde::Serializer,
15390 {
15391 use serde::ser::SerializeStruct;
15392 let mut len = 0;
15393 if self.table_id != 0 {
15394 len += 1;
15395 }
15396 if self.state != 0 {
15397 len += 1;
15398 }
15399 if !self.fragments.is_empty() {
15400 len += 1;
15401 }
15402 if !self.actor_status.is_empty() {
15403 len += 1;
15404 }
15405 if !self.actor_splits.is_empty() {
15406 len += 1;
15407 }
15408 if self.ctx.is_some() {
15409 len += 1;
15410 }
15411 if self.parallelism.is_some() {
15412 len += 1;
15413 }
15414 if self.max_parallelism.is_some() {
15415 len += 1;
15416 }
15417 if !self.node_label.is_empty() {
15418 len += 1;
15419 }
15420 if self.backfill_done {
15421 len += 1;
15422 }
15423 let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
15424 if self.table_id != 0 {
15425 struct_ser.serialize_field("tableId", &self.table_id)?;
15426 }
15427 if self.state != 0 {
15428 let v = table_fragments::State::try_from(self.state)
15429 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15430 struct_ser.serialize_field("state", &v)?;
15431 }
15432 if !self.fragments.is_empty() {
15433 struct_ser.serialize_field("fragments", &self.fragments)?;
15434 }
15435 if !self.actor_status.is_empty() {
15436 struct_ser.serialize_field("actorStatus", &self.actor_status)?;
15437 }
15438 if !self.actor_splits.is_empty() {
15439 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
15440 }
15441 if let Some(v) = self.ctx.as_ref() {
15442 struct_ser.serialize_field("ctx", v)?;
15443 }
15444 if let Some(v) = self.parallelism.as_ref() {
15445 struct_ser.serialize_field("parallelism", v)?;
15446 }
15447 if let Some(v) = self.max_parallelism.as_ref() {
15448 struct_ser.serialize_field("maxParallelism", v)?;
15449 }
15450 if !self.node_label.is_empty() {
15451 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15452 }
15453 if self.backfill_done {
15454 struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
15455 }
15456 struct_ser.end()
15457 }
15458}
15459impl<'de> serde::Deserialize<'de> for TableFragments {
15460 #[allow(deprecated)]
15461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15462 where
15463 D: serde::Deserializer<'de>,
15464 {
15465 const FIELDS: &[&str] = &[
15466 "table_id",
15467 "tableId",
15468 "state",
15469 "fragments",
15470 "actor_status",
15471 "actorStatus",
15472 "actor_splits",
15473 "actorSplits",
15474 "ctx",
15475 "parallelism",
15476 "max_parallelism",
15477 "maxParallelism",
15478 "node_label",
15479 "nodeLabel",
15480 "backfill_done",
15481 "backfillDone",
15482 ];
15483
15484 #[allow(clippy::enum_variant_names)]
15485 enum GeneratedField {
15486 TableId,
15487 State,
15488 Fragments,
15489 ActorStatus,
15490 ActorSplits,
15491 Ctx,
15492 Parallelism,
15493 MaxParallelism,
15494 NodeLabel,
15495 BackfillDone,
15496 }
15497 impl<'de> serde::Deserialize<'de> for GeneratedField {
15498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15499 where
15500 D: serde::Deserializer<'de>,
15501 {
15502 struct GeneratedVisitor;
15503
15504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15505 type Value = GeneratedField;
15506
15507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15508 write!(formatter, "expected one of: {:?}", &FIELDS)
15509 }
15510
15511 #[allow(unused_variables)]
15512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15513 where
15514 E: serde::de::Error,
15515 {
15516 match value {
15517 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15518 "state" => Ok(GeneratedField::State),
15519 "fragments" => Ok(GeneratedField::Fragments),
15520 "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
15521 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15522 "ctx" => Ok(GeneratedField::Ctx),
15523 "parallelism" => Ok(GeneratedField::Parallelism),
15524 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15525 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15526 "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15528 }
15529 }
15530 }
15531 deserializer.deserialize_identifier(GeneratedVisitor)
15532 }
15533 }
15534 struct GeneratedVisitor;
15535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15536 type Value = TableFragments;
15537
15538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15539 formatter.write_str("struct meta.TableFragments")
15540 }
15541
15542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15543 where
15544 V: serde::de::MapAccess<'de>,
15545 {
15546 let mut table_id__ = None;
15547 let mut state__ = None;
15548 let mut fragments__ = None;
15549 let mut actor_status__ = None;
15550 let mut actor_splits__ = None;
15551 let mut ctx__ = None;
15552 let mut parallelism__ = None;
15553 let mut max_parallelism__ = None;
15554 let mut node_label__ = None;
15555 let mut backfill_done__ = None;
15556 while let Some(k) = map_.next_key()? {
15557 match k {
15558 GeneratedField::TableId => {
15559 if table_id__.is_some() {
15560 return Err(serde::de::Error::duplicate_field("tableId"));
15561 }
15562 table_id__ =
15563 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15564 ;
15565 }
15566 GeneratedField::State => {
15567 if state__.is_some() {
15568 return Err(serde::de::Error::duplicate_field("state"));
15569 }
15570 state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15571 }
15572 GeneratedField::Fragments => {
15573 if fragments__.is_some() {
15574 return Err(serde::de::Error::duplicate_field("fragments"));
15575 }
15576 fragments__ = Some(
15577 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15578 .into_iter().map(|(k,v)| (k.0, v)).collect()
15579 );
15580 }
15581 GeneratedField::ActorStatus => {
15582 if actor_status__.is_some() {
15583 return Err(serde::de::Error::duplicate_field("actorStatus"));
15584 }
15585 actor_status__ = Some(
15586 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15587 .into_iter().map(|(k,v)| (k.0, v)).collect()
15588 );
15589 }
15590 GeneratedField::ActorSplits => {
15591 if actor_splits__.is_some() {
15592 return Err(serde::de::Error::duplicate_field("actorSplits"));
15593 }
15594 actor_splits__ = Some(
15595 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15596 .into_iter().map(|(k,v)| (k.0, v)).collect()
15597 );
15598 }
15599 GeneratedField::Ctx => {
15600 if ctx__.is_some() {
15601 return Err(serde::de::Error::duplicate_field("ctx"));
15602 }
15603 ctx__ = map_.next_value()?;
15604 }
15605 GeneratedField::Parallelism => {
15606 if parallelism__.is_some() {
15607 return Err(serde::de::Error::duplicate_field("parallelism"));
15608 }
15609 parallelism__ = map_.next_value()?;
15610 }
15611 GeneratedField::MaxParallelism => {
15612 if max_parallelism__.is_some() {
15613 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15614 }
15615 max_parallelism__ =
15616 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15617 ;
15618 }
15619 GeneratedField::NodeLabel => {
15620 if node_label__.is_some() {
15621 return Err(serde::de::Error::duplicate_field("nodeLabel"));
15622 }
15623 node_label__ = Some(map_.next_value()?);
15624 }
15625 GeneratedField::BackfillDone => {
15626 if backfill_done__.is_some() {
15627 return Err(serde::de::Error::duplicate_field("backfillDone"));
15628 }
15629 backfill_done__ = Some(map_.next_value()?);
15630 }
15631 }
15632 }
15633 Ok(TableFragments {
15634 table_id: table_id__.unwrap_or_default(),
15635 state: state__.unwrap_or_default(),
15636 fragments: fragments__.unwrap_or_default(),
15637 actor_status: actor_status__.unwrap_or_default(),
15638 actor_splits: actor_splits__.unwrap_or_default(),
15639 ctx: ctx__,
15640 parallelism: parallelism__,
15641 max_parallelism: max_parallelism__,
15642 node_label: node_label__.unwrap_or_default(),
15643 backfill_done: backfill_done__.unwrap_or_default(),
15644 })
15645 }
15646 }
15647 deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15648 }
15649}
15650impl serde::Serialize for table_fragments::ActorStatus {
15651 #[allow(deprecated)]
15652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15653 where
15654 S: serde::Serializer,
15655 {
15656 use serde::ser::SerializeStruct;
15657 let mut len = 0;
15658 if self.location.is_some() {
15659 len += 1;
15660 }
15661 if self.state != 0 {
15662 len += 1;
15663 }
15664 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15665 if let Some(v) = self.location.as_ref() {
15666 struct_ser.serialize_field("location", v)?;
15667 }
15668 if self.state != 0 {
15669 let v = table_fragments::actor_status::ActorState::try_from(self.state)
15670 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15671 struct_ser.serialize_field("state", &v)?;
15672 }
15673 struct_ser.end()
15674 }
15675}
15676impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15677 #[allow(deprecated)]
15678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15679 where
15680 D: serde::Deserializer<'de>,
15681 {
15682 const FIELDS: &[&str] = &[
15683 "location",
15684 "state",
15685 ];
15686
15687 #[allow(clippy::enum_variant_names)]
15688 enum GeneratedField {
15689 Location,
15690 State,
15691 }
15692 impl<'de> serde::Deserialize<'de> for GeneratedField {
15693 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15694 where
15695 D: serde::Deserializer<'de>,
15696 {
15697 struct GeneratedVisitor;
15698
15699 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15700 type Value = GeneratedField;
15701
15702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15703 write!(formatter, "expected one of: {:?}", &FIELDS)
15704 }
15705
15706 #[allow(unused_variables)]
15707 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15708 where
15709 E: serde::de::Error,
15710 {
15711 match value {
15712 "location" => Ok(GeneratedField::Location),
15713 "state" => Ok(GeneratedField::State),
15714 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15715 }
15716 }
15717 }
15718 deserializer.deserialize_identifier(GeneratedVisitor)
15719 }
15720 }
15721 struct GeneratedVisitor;
15722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15723 type Value = table_fragments::ActorStatus;
15724
15725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15726 formatter.write_str("struct meta.TableFragments.ActorStatus")
15727 }
15728
15729 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15730 where
15731 V: serde::de::MapAccess<'de>,
15732 {
15733 let mut location__ = None;
15734 let mut state__ = None;
15735 while let Some(k) = map_.next_key()? {
15736 match k {
15737 GeneratedField::Location => {
15738 if location__.is_some() {
15739 return Err(serde::de::Error::duplicate_field("location"));
15740 }
15741 location__ = map_.next_value()?;
15742 }
15743 GeneratedField::State => {
15744 if state__.is_some() {
15745 return Err(serde::de::Error::duplicate_field("state"));
15746 }
15747 state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15748 }
15749 }
15750 }
15751 Ok(table_fragments::ActorStatus {
15752 location: location__,
15753 state: state__.unwrap_or_default(),
15754 })
15755 }
15756 }
15757 deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15758 }
15759}
15760impl serde::Serialize for table_fragments::actor_status::ActorState {
15761 #[allow(deprecated)]
15762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15763 where
15764 S: serde::Serializer,
15765 {
15766 let variant = match self {
15767 Self::Unspecified => "UNSPECIFIED",
15768 Self::Inactive => "INACTIVE",
15769 Self::Running => "RUNNING",
15770 };
15771 serializer.serialize_str(variant)
15772 }
15773}
15774impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15775 #[allow(deprecated)]
15776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15777 where
15778 D: serde::Deserializer<'de>,
15779 {
15780 const FIELDS: &[&str] = &[
15781 "UNSPECIFIED",
15782 "INACTIVE",
15783 "RUNNING",
15784 ];
15785
15786 struct GeneratedVisitor;
15787
15788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15789 type Value = table_fragments::actor_status::ActorState;
15790
15791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15792 write!(formatter, "expected one of: {:?}", &FIELDS)
15793 }
15794
15795 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15796 where
15797 E: serde::de::Error,
15798 {
15799 i32::try_from(v)
15800 .ok()
15801 .and_then(|x| x.try_into().ok())
15802 .ok_or_else(|| {
15803 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15804 })
15805 }
15806
15807 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15808 where
15809 E: serde::de::Error,
15810 {
15811 i32::try_from(v)
15812 .ok()
15813 .and_then(|x| x.try_into().ok())
15814 .ok_or_else(|| {
15815 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15816 })
15817 }
15818
15819 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15820 where
15821 E: serde::de::Error,
15822 {
15823 match value {
15824 "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15825 "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15826 "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15827 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15828 }
15829 }
15830 }
15831 deserializer.deserialize_any(GeneratedVisitor)
15832 }
15833}
15834impl serde::Serialize for table_fragments::Fragment {
15835 #[allow(deprecated)]
15836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15837 where
15838 S: serde::Serializer,
15839 {
15840 use serde::ser::SerializeStruct;
15841 let mut len = 0;
15842 if self.fragment_id != 0 {
15843 len += 1;
15844 }
15845 if self.fragment_type_mask != 0 {
15846 len += 1;
15847 }
15848 if self.distribution_type != 0 {
15849 len += 1;
15850 }
15851 if !self.actors.is_empty() {
15852 len += 1;
15853 }
15854 if !self.state_table_ids.is_empty() {
15855 len += 1;
15856 }
15857 if !self.upstream_fragment_ids.is_empty() {
15858 len += 1;
15859 }
15860 if self.maybe_vnode_count.is_some() {
15861 len += 1;
15862 }
15863 if self.nodes.is_some() {
15864 len += 1;
15865 }
15866 let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15867 if self.fragment_id != 0 {
15868 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15869 }
15870 if self.fragment_type_mask != 0 {
15871 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15872 }
15873 if self.distribution_type != 0 {
15874 let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15875 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15876 struct_ser.serialize_field("distributionType", &v)?;
15877 }
15878 if !self.actors.is_empty() {
15879 struct_ser.serialize_field("actors", &self.actors)?;
15880 }
15881 if !self.state_table_ids.is_empty() {
15882 struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
15883 }
15884 if !self.upstream_fragment_ids.is_empty() {
15885 struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
15886 }
15887 if let Some(v) = self.maybe_vnode_count.as_ref() {
15888 struct_ser.serialize_field("maybeVnodeCount", v)?;
15889 }
15890 if let Some(v) = self.nodes.as_ref() {
15891 struct_ser.serialize_field("nodes", v)?;
15892 }
15893 struct_ser.end()
15894 }
15895}
15896impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
15897 #[allow(deprecated)]
15898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15899 where
15900 D: serde::Deserializer<'de>,
15901 {
15902 const FIELDS: &[&str] = &[
15903 "fragment_id",
15904 "fragmentId",
15905 "fragment_type_mask",
15906 "fragmentTypeMask",
15907 "distribution_type",
15908 "distributionType",
15909 "actors",
15910 "state_table_ids",
15911 "stateTableIds",
15912 "upstream_fragment_ids",
15913 "upstreamFragmentIds",
15914 "maybe_vnode_count",
15915 "maybeVnodeCount",
15916 "nodes",
15917 ];
15918
15919 #[allow(clippy::enum_variant_names)]
15920 enum GeneratedField {
15921 FragmentId,
15922 FragmentTypeMask,
15923 DistributionType,
15924 Actors,
15925 StateTableIds,
15926 UpstreamFragmentIds,
15927 MaybeVnodeCount,
15928 Nodes,
15929 }
15930 impl<'de> serde::Deserialize<'de> for GeneratedField {
15931 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15932 where
15933 D: serde::Deserializer<'de>,
15934 {
15935 struct GeneratedVisitor;
15936
15937 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15938 type Value = GeneratedField;
15939
15940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15941 write!(formatter, "expected one of: {:?}", &FIELDS)
15942 }
15943
15944 #[allow(unused_variables)]
15945 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15946 where
15947 E: serde::de::Error,
15948 {
15949 match value {
15950 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15951 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15952 "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
15953 "actors" => Ok(GeneratedField::Actors),
15954 "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
15955 "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
15956 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
15957 "nodes" => Ok(GeneratedField::Nodes),
15958 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15959 }
15960 }
15961 }
15962 deserializer.deserialize_identifier(GeneratedVisitor)
15963 }
15964 }
15965 struct GeneratedVisitor;
15966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15967 type Value = table_fragments::Fragment;
15968
15969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15970 formatter.write_str("struct meta.TableFragments.Fragment")
15971 }
15972
15973 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
15974 where
15975 V: serde::de::MapAccess<'de>,
15976 {
15977 let mut fragment_id__ = None;
15978 let mut fragment_type_mask__ = None;
15979 let mut distribution_type__ = None;
15980 let mut actors__ = None;
15981 let mut state_table_ids__ = None;
15982 let mut upstream_fragment_ids__ = None;
15983 let mut maybe_vnode_count__ = None;
15984 let mut nodes__ = None;
15985 while let Some(k) = map_.next_key()? {
15986 match k {
15987 GeneratedField::FragmentId => {
15988 if fragment_id__.is_some() {
15989 return Err(serde::de::Error::duplicate_field("fragmentId"));
15990 }
15991 fragment_id__ =
15992 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15993 ;
15994 }
15995 GeneratedField::FragmentTypeMask => {
15996 if fragment_type_mask__.is_some() {
15997 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
15998 }
15999 fragment_type_mask__ =
16000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16001 ;
16002 }
16003 GeneratedField::DistributionType => {
16004 if distribution_type__.is_some() {
16005 return Err(serde::de::Error::duplicate_field("distributionType"));
16006 }
16007 distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
16008 }
16009 GeneratedField::Actors => {
16010 if actors__.is_some() {
16011 return Err(serde::de::Error::duplicate_field("actors"));
16012 }
16013 actors__ = Some(map_.next_value()?);
16014 }
16015 GeneratedField::StateTableIds => {
16016 if state_table_ids__.is_some() {
16017 return Err(serde::de::Error::duplicate_field("stateTableIds"));
16018 }
16019 state_table_ids__ =
16020 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16021 .into_iter().map(|x| x.0).collect())
16022 ;
16023 }
16024 GeneratedField::UpstreamFragmentIds => {
16025 if upstream_fragment_ids__.is_some() {
16026 return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
16027 }
16028 upstream_fragment_ids__ =
16029 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16030 .into_iter().map(|x| x.0).collect())
16031 ;
16032 }
16033 GeneratedField::MaybeVnodeCount => {
16034 if maybe_vnode_count__.is_some() {
16035 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
16036 }
16037 maybe_vnode_count__ =
16038 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16039 ;
16040 }
16041 GeneratedField::Nodes => {
16042 if nodes__.is_some() {
16043 return Err(serde::de::Error::duplicate_field("nodes"));
16044 }
16045 nodes__ = map_.next_value()?;
16046 }
16047 }
16048 }
16049 Ok(table_fragments::Fragment {
16050 fragment_id: fragment_id__.unwrap_or_default(),
16051 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16052 distribution_type: distribution_type__.unwrap_or_default(),
16053 actors: actors__.unwrap_or_default(),
16054 state_table_ids: state_table_ids__.unwrap_or_default(),
16055 upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
16056 maybe_vnode_count: maybe_vnode_count__,
16057 nodes: nodes__,
16058 })
16059 }
16060 }
16061 deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
16062 }
16063}
16064impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
16065 #[allow(deprecated)]
16066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16067 where
16068 S: serde::Serializer,
16069 {
16070 let variant = match self {
16071 Self::Unspecified => "UNSPECIFIED",
16072 Self::Single => "SINGLE",
16073 Self::Hash => "HASH",
16074 };
16075 serializer.serialize_str(variant)
16076 }
16077}
16078impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
16079 #[allow(deprecated)]
16080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16081 where
16082 D: serde::Deserializer<'de>,
16083 {
16084 const FIELDS: &[&str] = &[
16085 "UNSPECIFIED",
16086 "SINGLE",
16087 "HASH",
16088 ];
16089
16090 struct GeneratedVisitor;
16091
16092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16093 type Value = table_fragments::fragment::FragmentDistributionType;
16094
16095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16096 write!(formatter, "expected one of: {:?}", &FIELDS)
16097 }
16098
16099 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16100 where
16101 E: serde::de::Error,
16102 {
16103 i32::try_from(v)
16104 .ok()
16105 .and_then(|x| x.try_into().ok())
16106 .ok_or_else(|| {
16107 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16108 })
16109 }
16110
16111 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16112 where
16113 E: serde::de::Error,
16114 {
16115 i32::try_from(v)
16116 .ok()
16117 .and_then(|x| x.try_into().ok())
16118 .ok_or_else(|| {
16119 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16120 })
16121 }
16122
16123 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16124 where
16125 E: serde::de::Error,
16126 {
16127 match value {
16128 "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
16129 "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
16130 "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
16131 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16132 }
16133 }
16134 }
16135 deserializer.deserialize_any(GeneratedVisitor)
16136 }
16137}
16138impl serde::Serialize for table_fragments::State {
16139 #[allow(deprecated)]
16140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16141 where
16142 S: serde::Serializer,
16143 {
16144 let variant = match self {
16145 Self::Unspecified => "UNSPECIFIED",
16146 Self::Initial => "INITIAL",
16147 Self::Creating => "CREATING",
16148 Self::Created => "CREATED",
16149 };
16150 serializer.serialize_str(variant)
16151 }
16152}
16153impl<'de> serde::Deserialize<'de> for table_fragments::State {
16154 #[allow(deprecated)]
16155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16156 where
16157 D: serde::Deserializer<'de>,
16158 {
16159 const FIELDS: &[&str] = &[
16160 "UNSPECIFIED",
16161 "INITIAL",
16162 "CREATING",
16163 "CREATED",
16164 ];
16165
16166 struct GeneratedVisitor;
16167
16168 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16169 type Value = table_fragments::State;
16170
16171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16172 write!(formatter, "expected one of: {:?}", &FIELDS)
16173 }
16174
16175 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16176 where
16177 E: serde::de::Error,
16178 {
16179 i32::try_from(v)
16180 .ok()
16181 .and_then(|x| x.try_into().ok())
16182 .ok_or_else(|| {
16183 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16184 })
16185 }
16186
16187 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16188 where
16189 E: serde::de::Error,
16190 {
16191 i32::try_from(v)
16192 .ok()
16193 .and_then(|x| x.try_into().ok())
16194 .ok_or_else(|| {
16195 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16196 })
16197 }
16198
16199 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16200 where
16201 E: serde::de::Error,
16202 {
16203 match value {
16204 "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
16205 "INITIAL" => Ok(table_fragments::State::Initial),
16206 "CREATING" => Ok(table_fragments::State::Creating),
16207 "CREATED" => Ok(table_fragments::State::Created),
16208 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16209 }
16210 }
16211 }
16212 deserializer.deserialize_any(GeneratedVisitor)
16213 }
16214}
16215impl serde::Serialize for TableParallelism {
16216 #[allow(deprecated)]
16217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16218 where
16219 S: serde::Serializer,
16220 {
16221 use serde::ser::SerializeStruct;
16222 let mut len = 0;
16223 if self.parallelism.is_some() {
16224 len += 1;
16225 }
16226 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
16227 if let Some(v) = self.parallelism.as_ref() {
16228 match v {
16229 table_parallelism::Parallelism::Fixed(v) => {
16230 struct_ser.serialize_field("fixed", v)?;
16231 }
16232 table_parallelism::Parallelism::Auto(v) => {
16233 struct_ser.serialize_field("auto", v)?;
16234 }
16235 table_parallelism::Parallelism::Custom(v) => {
16236 struct_ser.serialize_field("custom", v)?;
16237 }
16238 table_parallelism::Parallelism::Adaptive(v) => {
16239 struct_ser.serialize_field("adaptive", v)?;
16240 }
16241 }
16242 }
16243 struct_ser.end()
16244 }
16245}
16246impl<'de> serde::Deserialize<'de> for TableParallelism {
16247 #[allow(deprecated)]
16248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16249 where
16250 D: serde::Deserializer<'de>,
16251 {
16252 const FIELDS: &[&str] = &[
16253 "fixed",
16254 "auto",
16255 "custom",
16256 "adaptive",
16257 ];
16258
16259 #[allow(clippy::enum_variant_names)]
16260 enum GeneratedField {
16261 Fixed,
16262 Auto,
16263 Custom,
16264 Adaptive,
16265 }
16266 impl<'de> serde::Deserialize<'de> for GeneratedField {
16267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16268 where
16269 D: serde::Deserializer<'de>,
16270 {
16271 struct GeneratedVisitor;
16272
16273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16274 type Value = GeneratedField;
16275
16276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16277 write!(formatter, "expected one of: {:?}", &FIELDS)
16278 }
16279
16280 #[allow(unused_variables)]
16281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16282 where
16283 E: serde::de::Error,
16284 {
16285 match value {
16286 "fixed" => Ok(GeneratedField::Fixed),
16287 "auto" => Ok(GeneratedField::Auto),
16288 "custom" => Ok(GeneratedField::Custom),
16289 "adaptive" => Ok(GeneratedField::Adaptive),
16290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16291 }
16292 }
16293 }
16294 deserializer.deserialize_identifier(GeneratedVisitor)
16295 }
16296 }
16297 struct GeneratedVisitor;
16298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16299 type Value = TableParallelism;
16300
16301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16302 formatter.write_str("struct meta.TableParallelism")
16303 }
16304
16305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
16306 where
16307 V: serde::de::MapAccess<'de>,
16308 {
16309 let mut parallelism__ = None;
16310 while let Some(k) = map_.next_key()? {
16311 match k {
16312 GeneratedField::Fixed => {
16313 if parallelism__.is_some() {
16314 return Err(serde::de::Error::duplicate_field("fixed"));
16315 }
16316 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
16317;
16318 }
16319 GeneratedField::Auto => {
16320 if parallelism__.is_some() {
16321 return Err(serde::de::Error::duplicate_field("auto"));
16322 }
16323 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
16324;
16325 }
16326 GeneratedField::Custom => {
16327 if parallelism__.is_some() {
16328 return Err(serde::de::Error::duplicate_field("custom"));
16329 }
16330 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
16331;
16332 }
16333 GeneratedField::Adaptive => {
16334 if parallelism__.is_some() {
16335 return Err(serde::de::Error::duplicate_field("adaptive"));
16336 }
16337 parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
16338;
16339 }
16340 }
16341 }
16342 Ok(TableParallelism {
16343 parallelism: parallelism__,
16344 })
16345 }
16346 }
16347 deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
16348 }
16349}
16350impl serde::Serialize for table_parallelism::AdaptiveParallelism {
16351 #[allow(deprecated)]
16352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16353 where
16354 S: serde::Serializer,
16355 {
16356 use serde::ser::SerializeStruct;
16357 let len = 0;
16358 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
16359 struct_ser.end()
16360 }
16361}
16362impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
16363 #[allow(deprecated)]
16364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16365 where
16366 D: serde::Deserializer<'de>,
16367 {
16368 const FIELDS: &[&str] = &[
16369 ];
16370
16371 #[allow(clippy::enum_variant_names)]
16372 enum GeneratedField {
16373 }
16374 impl<'de> serde::Deserialize<'de> for GeneratedField {
16375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16376 where
16377 D: serde::Deserializer<'de>,
16378 {
16379 struct GeneratedVisitor;
16380
16381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16382 type Value = GeneratedField;
16383
16384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16385 write!(formatter, "expected one of: {:?}", &FIELDS)
16386 }
16387
16388 #[allow(unused_variables)]
16389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16390 where
16391 E: serde::de::Error,
16392 {
16393 Err(serde::de::Error::unknown_field(value, FIELDS))
16394 }
16395 }
16396 deserializer.deserialize_identifier(GeneratedVisitor)
16397 }
16398 }
16399 struct GeneratedVisitor;
16400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16401 type Value = table_parallelism::AdaptiveParallelism;
16402
16403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16404 formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
16405 }
16406
16407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
16408 where
16409 V: serde::de::MapAccess<'de>,
16410 {
16411 while map_.next_key::<GeneratedField>()?.is_some() {
16412 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16413 }
16414 Ok(table_parallelism::AdaptiveParallelism {
16415 })
16416 }
16417 }
16418 deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
16419 }
16420}
16421impl serde::Serialize for table_parallelism::AutoParallelism {
16422 #[allow(deprecated)]
16423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16424 where
16425 S: serde::Serializer,
16426 {
16427 use serde::ser::SerializeStruct;
16428 let len = 0;
16429 let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
16430 struct_ser.end()
16431 }
16432}
16433impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
16434 #[allow(deprecated)]
16435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16436 where
16437 D: serde::Deserializer<'de>,
16438 {
16439 const FIELDS: &[&str] = &[
16440 ];
16441
16442 #[allow(clippy::enum_variant_names)]
16443 enum GeneratedField {
16444 }
16445 impl<'de> serde::Deserialize<'de> for GeneratedField {
16446 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16447 where
16448 D: serde::Deserializer<'de>,
16449 {
16450 struct GeneratedVisitor;
16451
16452 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16453 type Value = GeneratedField;
16454
16455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16456 write!(formatter, "expected one of: {:?}", &FIELDS)
16457 }
16458
16459 #[allow(unused_variables)]
16460 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16461 where
16462 E: serde::de::Error,
16463 {
16464 Err(serde::de::Error::unknown_field(value, FIELDS))
16465 }
16466 }
16467 deserializer.deserialize_identifier(GeneratedVisitor)
16468 }
16469 }
16470 struct GeneratedVisitor;
16471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16472 type Value = table_parallelism::AutoParallelism;
16473
16474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16475 formatter.write_str("struct meta.TableParallelism.AutoParallelism")
16476 }
16477
16478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
16479 where
16480 V: serde::de::MapAccess<'de>,
16481 {
16482 while map_.next_key::<GeneratedField>()?.is_some() {
16483 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16484 }
16485 Ok(table_parallelism::AutoParallelism {
16486 })
16487 }
16488 }
16489 deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
16490 }
16491}
16492impl serde::Serialize for table_parallelism::CustomParallelism {
16493 #[allow(deprecated)]
16494 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16495 where
16496 S: serde::Serializer,
16497 {
16498 use serde::ser::SerializeStruct;
16499 let len = 0;
16500 let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
16501 struct_ser.end()
16502 }
16503}
16504impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
16505 #[allow(deprecated)]
16506 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16507 where
16508 D: serde::Deserializer<'de>,
16509 {
16510 const FIELDS: &[&str] = &[
16511 ];
16512
16513 #[allow(clippy::enum_variant_names)]
16514 enum GeneratedField {
16515 }
16516 impl<'de> serde::Deserialize<'de> for GeneratedField {
16517 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16518 where
16519 D: serde::Deserializer<'de>,
16520 {
16521 struct GeneratedVisitor;
16522
16523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16524 type Value = GeneratedField;
16525
16526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16527 write!(formatter, "expected one of: {:?}", &FIELDS)
16528 }
16529
16530 #[allow(unused_variables)]
16531 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16532 where
16533 E: serde::de::Error,
16534 {
16535 Err(serde::de::Error::unknown_field(value, FIELDS))
16536 }
16537 }
16538 deserializer.deserialize_identifier(GeneratedVisitor)
16539 }
16540 }
16541 struct GeneratedVisitor;
16542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16543 type Value = table_parallelism::CustomParallelism;
16544
16545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16546 formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16547 }
16548
16549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16550 where
16551 V: serde::de::MapAccess<'de>,
16552 {
16553 while map_.next_key::<GeneratedField>()?.is_some() {
16554 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16555 }
16556 Ok(table_parallelism::CustomParallelism {
16557 })
16558 }
16559 }
16560 deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16561 }
16562}
16563impl serde::Serialize for table_parallelism::FixedParallelism {
16564 #[allow(deprecated)]
16565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16566 where
16567 S: serde::Serializer,
16568 {
16569 use serde::ser::SerializeStruct;
16570 let mut len = 0;
16571 if self.parallelism != 0 {
16572 len += 1;
16573 }
16574 let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16575 if self.parallelism != 0 {
16576 struct_ser.serialize_field("parallelism", &self.parallelism)?;
16577 }
16578 struct_ser.end()
16579 }
16580}
16581impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16582 #[allow(deprecated)]
16583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16584 where
16585 D: serde::Deserializer<'de>,
16586 {
16587 const FIELDS: &[&str] = &[
16588 "parallelism",
16589 ];
16590
16591 #[allow(clippy::enum_variant_names)]
16592 enum GeneratedField {
16593 Parallelism,
16594 }
16595 impl<'de> serde::Deserialize<'de> for GeneratedField {
16596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16597 where
16598 D: serde::Deserializer<'de>,
16599 {
16600 struct GeneratedVisitor;
16601
16602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16603 type Value = GeneratedField;
16604
16605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16606 write!(formatter, "expected one of: {:?}", &FIELDS)
16607 }
16608
16609 #[allow(unused_variables)]
16610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16611 where
16612 E: serde::de::Error,
16613 {
16614 match value {
16615 "parallelism" => Ok(GeneratedField::Parallelism),
16616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16617 }
16618 }
16619 }
16620 deserializer.deserialize_identifier(GeneratedVisitor)
16621 }
16622 }
16623 struct GeneratedVisitor;
16624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16625 type Value = table_parallelism::FixedParallelism;
16626
16627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16628 formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16629 }
16630
16631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16632 where
16633 V: serde::de::MapAccess<'de>,
16634 {
16635 let mut parallelism__ = None;
16636 while let Some(k) = map_.next_key()? {
16637 match k {
16638 GeneratedField::Parallelism => {
16639 if parallelism__.is_some() {
16640 return Err(serde::de::Error::duplicate_field("parallelism"));
16641 }
16642 parallelism__ =
16643 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16644 ;
16645 }
16646 }
16647 }
16648 Ok(table_parallelism::FixedParallelism {
16649 parallelism: parallelism__.unwrap_or_default(),
16650 })
16651 }
16652 }
16653 deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16654 }
16655}
16656impl serde::Serialize for TelemetryInfoResponse {
16657 #[allow(deprecated)]
16658 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16659 where
16660 S: serde::Serializer,
16661 {
16662 use serde::ser::SerializeStruct;
16663 let mut len = 0;
16664 if self.tracking_id.is_some() {
16665 len += 1;
16666 }
16667 let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16668 if let Some(v) = self.tracking_id.as_ref() {
16669 struct_ser.serialize_field("trackingId", v)?;
16670 }
16671 struct_ser.end()
16672 }
16673}
16674impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16675 #[allow(deprecated)]
16676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16677 where
16678 D: serde::Deserializer<'de>,
16679 {
16680 const FIELDS: &[&str] = &[
16681 "tracking_id",
16682 "trackingId",
16683 ];
16684
16685 #[allow(clippy::enum_variant_names)]
16686 enum GeneratedField {
16687 TrackingId,
16688 }
16689 impl<'de> serde::Deserialize<'de> for GeneratedField {
16690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16691 where
16692 D: serde::Deserializer<'de>,
16693 {
16694 struct GeneratedVisitor;
16695
16696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16697 type Value = GeneratedField;
16698
16699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16700 write!(formatter, "expected one of: {:?}", &FIELDS)
16701 }
16702
16703 #[allow(unused_variables)]
16704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16705 where
16706 E: serde::de::Error,
16707 {
16708 match value {
16709 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16710 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16711 }
16712 }
16713 }
16714 deserializer.deserialize_identifier(GeneratedVisitor)
16715 }
16716 }
16717 struct GeneratedVisitor;
16718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16719 type Value = TelemetryInfoResponse;
16720
16721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16722 formatter.write_str("struct meta.TelemetryInfoResponse")
16723 }
16724
16725 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16726 where
16727 V: serde::de::MapAccess<'de>,
16728 {
16729 let mut tracking_id__ = None;
16730 while let Some(k) = map_.next_key()? {
16731 match k {
16732 GeneratedField::TrackingId => {
16733 if tracking_id__.is_some() {
16734 return Err(serde::de::Error::duplicate_field("trackingId"));
16735 }
16736 tracking_id__ = map_.next_value()?;
16737 }
16738 }
16739 }
16740 Ok(TelemetryInfoResponse {
16741 tracking_id: tracking_id__,
16742 })
16743 }
16744 }
16745 deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16746 }
16747}
16748impl serde::Serialize for ThrottleTarget {
16749 #[allow(deprecated)]
16750 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16751 where
16752 S: serde::Serializer,
16753 {
16754 let variant = match self {
16755 Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16756 Self::Source => "SOURCE",
16757 Self::Mv => "MV",
16758 Self::TableWithSource => "TABLE_WITH_SOURCE",
16759 Self::CdcTable => "CDC_TABLE",
16760 Self::TableDml => "TABLE_DML",
16761 Self::Sink => "SINK",
16762 Self::Fragment => "FRAGMENT",
16763 };
16764 serializer.serialize_str(variant)
16765 }
16766}
16767impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16768 #[allow(deprecated)]
16769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16770 where
16771 D: serde::Deserializer<'de>,
16772 {
16773 const FIELDS: &[&str] = &[
16774 "THROTTLE_TARGET_UNSPECIFIED",
16775 "SOURCE",
16776 "MV",
16777 "TABLE_WITH_SOURCE",
16778 "CDC_TABLE",
16779 "TABLE_DML",
16780 "SINK",
16781 "FRAGMENT",
16782 ];
16783
16784 struct GeneratedVisitor;
16785
16786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16787 type Value = ThrottleTarget;
16788
16789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16790 write!(formatter, "expected one of: {:?}", &FIELDS)
16791 }
16792
16793 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16794 where
16795 E: serde::de::Error,
16796 {
16797 i32::try_from(v)
16798 .ok()
16799 .and_then(|x| x.try_into().ok())
16800 .ok_or_else(|| {
16801 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16802 })
16803 }
16804
16805 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16806 where
16807 E: serde::de::Error,
16808 {
16809 i32::try_from(v)
16810 .ok()
16811 .and_then(|x| x.try_into().ok())
16812 .ok_or_else(|| {
16813 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16814 })
16815 }
16816
16817 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16818 where
16819 E: serde::de::Error,
16820 {
16821 match value {
16822 "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16823 "SOURCE" => Ok(ThrottleTarget::Source),
16824 "MV" => Ok(ThrottleTarget::Mv),
16825 "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16826 "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16827 "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16828 "SINK" => Ok(ThrottleTarget::Sink),
16829 "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16830 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16831 }
16832 }
16833 }
16834 deserializer.deserialize_any(GeneratedVisitor)
16835 }
16836}
16837impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16838 #[allow(deprecated)]
16839 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16840 where
16841 S: serde::Serializer,
16842 {
16843 use serde::ser::SerializeStruct;
16844 let mut len = 0;
16845 if self.id != 0 {
16846 len += 1;
16847 }
16848 if !self.node_label.is_empty() {
16849 len += 1;
16850 }
16851 let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16852 if self.id != 0 {
16853 struct_ser.serialize_field("id", &self.id)?;
16854 }
16855 if !self.node_label.is_empty() {
16856 struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16857 }
16858 struct_ser.end()
16859 }
16860}
16861impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16862 #[allow(deprecated)]
16863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16864 where
16865 D: serde::Deserializer<'de>,
16866 {
16867 const FIELDS: &[&str] = &[
16868 "id",
16869 "node_label",
16870 "nodeLabel",
16871 ];
16872
16873 #[allow(clippy::enum_variant_names)]
16874 enum GeneratedField {
16875 Id,
16876 NodeLabel,
16877 }
16878 impl<'de> serde::Deserialize<'de> for GeneratedField {
16879 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16880 where
16881 D: serde::Deserializer<'de>,
16882 {
16883 struct GeneratedVisitor;
16884
16885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16886 type Value = GeneratedField;
16887
16888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16889 write!(formatter, "expected one of: {:?}", &FIELDS)
16890 }
16891
16892 #[allow(unused_variables)]
16893 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16894 where
16895 E: serde::de::Error,
16896 {
16897 match value {
16898 "id" => Ok(GeneratedField::Id),
16899 "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16901 }
16902 }
16903 }
16904 deserializer.deserialize_identifier(GeneratedVisitor)
16905 }
16906 }
16907 struct GeneratedVisitor;
16908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16909 type Value = UpdateStreamingJobNodeLabelsRequest;
16910
16911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16912 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
16913 }
16914
16915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
16916 where
16917 V: serde::de::MapAccess<'de>,
16918 {
16919 let mut id__ = None;
16920 let mut node_label__ = None;
16921 while let Some(k) = map_.next_key()? {
16922 match k {
16923 GeneratedField::Id => {
16924 if id__.is_some() {
16925 return Err(serde::de::Error::duplicate_field("id"));
16926 }
16927 id__ =
16928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16929 ;
16930 }
16931 GeneratedField::NodeLabel => {
16932 if node_label__.is_some() {
16933 return Err(serde::de::Error::duplicate_field("nodeLabel"));
16934 }
16935 node_label__ = Some(map_.next_value()?);
16936 }
16937 }
16938 }
16939 Ok(UpdateStreamingJobNodeLabelsRequest {
16940 id: id__.unwrap_or_default(),
16941 node_label: node_label__.unwrap_or_default(),
16942 })
16943 }
16944 }
16945 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
16946 }
16947}
16948impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
16949 #[allow(deprecated)]
16950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16951 where
16952 S: serde::Serializer,
16953 {
16954 use serde::ser::SerializeStruct;
16955 let len = 0;
16956 let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
16957 struct_ser.end()
16958 }
16959}
16960impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
16961 #[allow(deprecated)]
16962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16963 where
16964 D: serde::Deserializer<'de>,
16965 {
16966 const FIELDS: &[&str] = &[
16967 ];
16968
16969 #[allow(clippy::enum_variant_names)]
16970 enum GeneratedField {
16971 }
16972 impl<'de> serde::Deserialize<'de> for GeneratedField {
16973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16974 where
16975 D: serde::Deserializer<'de>,
16976 {
16977 struct GeneratedVisitor;
16978
16979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16980 type Value = GeneratedField;
16981
16982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16983 write!(formatter, "expected one of: {:?}", &FIELDS)
16984 }
16985
16986 #[allow(unused_variables)]
16987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16988 where
16989 E: serde::de::Error,
16990 {
16991 Err(serde::de::Error::unknown_field(value, FIELDS))
16992 }
16993 }
16994 deserializer.deserialize_identifier(GeneratedVisitor)
16995 }
16996 }
16997 struct GeneratedVisitor;
16998 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16999 type Value = UpdateStreamingJobNodeLabelsResponse;
17000
17001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17002 formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
17003 }
17004
17005 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
17006 where
17007 V: serde::de::MapAccess<'de>,
17008 {
17009 while map_.next_key::<GeneratedField>()?.is_some() {
17010 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17011 }
17012 Ok(UpdateStreamingJobNodeLabelsResponse {
17013 })
17014 }
17015 }
17016 deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
17017 }
17018}
17019impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
17020 #[allow(deprecated)]
17021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17022 where
17023 S: serde::Serializer,
17024 {
17025 use serde::ser::SerializeStruct;
17026 let mut len = 0;
17027 if !self.worker_ids.is_empty() {
17028 len += 1;
17029 }
17030 if self.schedulability != 0 {
17031 len += 1;
17032 }
17033 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
17034 if !self.worker_ids.is_empty() {
17035 struct_ser.serialize_field("workerIds", &self.worker_ids)?;
17036 }
17037 if self.schedulability != 0 {
17038 let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
17039 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
17040 struct_ser.serialize_field("schedulability", &v)?;
17041 }
17042 struct_ser.end()
17043 }
17044}
17045impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
17046 #[allow(deprecated)]
17047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17048 where
17049 D: serde::Deserializer<'de>,
17050 {
17051 const FIELDS: &[&str] = &[
17052 "worker_ids",
17053 "workerIds",
17054 "schedulability",
17055 ];
17056
17057 #[allow(clippy::enum_variant_names)]
17058 enum GeneratedField {
17059 WorkerIds,
17060 Schedulability,
17061 }
17062 impl<'de> serde::Deserialize<'de> for GeneratedField {
17063 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17064 where
17065 D: serde::Deserializer<'de>,
17066 {
17067 struct GeneratedVisitor;
17068
17069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17070 type Value = GeneratedField;
17071
17072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17073 write!(formatter, "expected one of: {:?}", &FIELDS)
17074 }
17075
17076 #[allow(unused_variables)]
17077 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17078 where
17079 E: serde::de::Error,
17080 {
17081 match value {
17082 "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
17083 "schedulability" => Ok(GeneratedField::Schedulability),
17084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17085 }
17086 }
17087 }
17088 deserializer.deserialize_identifier(GeneratedVisitor)
17089 }
17090 }
17091 struct GeneratedVisitor;
17092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17093 type Value = UpdateWorkerNodeSchedulabilityRequest;
17094
17095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17096 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
17097 }
17098
17099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
17100 where
17101 V: serde::de::MapAccess<'de>,
17102 {
17103 let mut worker_ids__ = None;
17104 let mut schedulability__ = None;
17105 while let Some(k) = map_.next_key()? {
17106 match k {
17107 GeneratedField::WorkerIds => {
17108 if worker_ids__.is_some() {
17109 return Err(serde::de::Error::duplicate_field("workerIds"));
17110 }
17111 worker_ids__ =
17112 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17113 .into_iter().map(|x| x.0).collect())
17114 ;
17115 }
17116 GeneratedField::Schedulability => {
17117 if schedulability__.is_some() {
17118 return Err(serde::de::Error::duplicate_field("schedulability"));
17119 }
17120 schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
17121 }
17122 }
17123 }
17124 Ok(UpdateWorkerNodeSchedulabilityRequest {
17125 worker_ids: worker_ids__.unwrap_or_default(),
17126 schedulability: schedulability__.unwrap_or_default(),
17127 })
17128 }
17129 }
17130 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
17131 }
17132}
17133impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
17134 #[allow(deprecated)]
17135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17136 where
17137 S: serde::Serializer,
17138 {
17139 let variant = match self {
17140 Self::Unspecified => "UNSPECIFIED",
17141 Self::Schedulable => "SCHEDULABLE",
17142 Self::Unschedulable => "UNSCHEDULABLE",
17143 };
17144 serializer.serialize_str(variant)
17145 }
17146}
17147impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
17148 #[allow(deprecated)]
17149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17150 where
17151 D: serde::Deserializer<'de>,
17152 {
17153 const FIELDS: &[&str] = &[
17154 "UNSPECIFIED",
17155 "SCHEDULABLE",
17156 "UNSCHEDULABLE",
17157 ];
17158
17159 struct GeneratedVisitor;
17160
17161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17162 type Value = update_worker_node_schedulability_request::Schedulability;
17163
17164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17165 write!(formatter, "expected one of: {:?}", &FIELDS)
17166 }
17167
17168 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17169 where
17170 E: serde::de::Error,
17171 {
17172 i32::try_from(v)
17173 .ok()
17174 .and_then(|x| x.try_into().ok())
17175 .ok_or_else(|| {
17176 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17177 })
17178 }
17179
17180 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17181 where
17182 E: serde::de::Error,
17183 {
17184 i32::try_from(v)
17185 .ok()
17186 .and_then(|x| x.try_into().ok())
17187 .ok_or_else(|| {
17188 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17189 })
17190 }
17191
17192 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17193 where
17194 E: serde::de::Error,
17195 {
17196 match value {
17197 "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
17198 "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
17199 "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
17200 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17201 }
17202 }
17203 }
17204 deserializer.deserialize_any(GeneratedVisitor)
17205 }
17206}
17207impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
17208 #[allow(deprecated)]
17209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17210 where
17211 S: serde::Serializer,
17212 {
17213 use serde::ser::SerializeStruct;
17214 let mut len = 0;
17215 if self.status.is_some() {
17216 len += 1;
17217 }
17218 let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
17219 if let Some(v) = self.status.as_ref() {
17220 struct_ser.serialize_field("status", v)?;
17221 }
17222 struct_ser.end()
17223 }
17224}
17225impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
17226 #[allow(deprecated)]
17227 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17228 where
17229 D: serde::Deserializer<'de>,
17230 {
17231 const FIELDS: &[&str] = &[
17232 "status",
17233 ];
17234
17235 #[allow(clippy::enum_variant_names)]
17236 enum GeneratedField {
17237 Status,
17238 }
17239 impl<'de> serde::Deserialize<'de> for GeneratedField {
17240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17241 where
17242 D: serde::Deserializer<'de>,
17243 {
17244 struct GeneratedVisitor;
17245
17246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17247 type Value = GeneratedField;
17248
17249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17250 write!(formatter, "expected one of: {:?}", &FIELDS)
17251 }
17252
17253 #[allow(unused_variables)]
17254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17255 where
17256 E: serde::de::Error,
17257 {
17258 match value {
17259 "status" => Ok(GeneratedField::Status),
17260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17261 }
17262 }
17263 }
17264 deserializer.deserialize_identifier(GeneratedVisitor)
17265 }
17266 }
17267 struct GeneratedVisitor;
17268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17269 type Value = UpdateWorkerNodeSchedulabilityResponse;
17270
17271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17272 formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
17273 }
17274
17275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
17276 where
17277 V: serde::de::MapAccess<'de>,
17278 {
17279 let mut status__ = None;
17280 while let Some(k) = map_.next_key()? {
17281 match k {
17282 GeneratedField::Status => {
17283 if status__.is_some() {
17284 return Err(serde::de::Error::duplicate_field("status"));
17285 }
17286 status__ = map_.next_value()?;
17287 }
17288 }
17289 }
17290 Ok(UpdateWorkerNodeSchedulabilityResponse {
17291 status: status__,
17292 })
17293 }
17294 }
17295 deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
17296 }
17297}
17298impl serde::Serialize for WorkerReschedule {
17299 #[allow(deprecated)]
17300 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17301 where
17302 S: serde::Serializer,
17303 {
17304 use serde::ser::SerializeStruct;
17305 let mut len = 0;
17306 if !self.worker_actor_diff.is_empty() {
17307 len += 1;
17308 }
17309 let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
17310 if !self.worker_actor_diff.is_empty() {
17311 struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
17312 }
17313 struct_ser.end()
17314 }
17315}
17316impl<'de> serde::Deserialize<'de> for WorkerReschedule {
17317 #[allow(deprecated)]
17318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17319 where
17320 D: serde::Deserializer<'de>,
17321 {
17322 const FIELDS: &[&str] = &[
17323 "worker_actor_diff",
17324 "workerActorDiff",
17325 ];
17326
17327 #[allow(clippy::enum_variant_names)]
17328 enum GeneratedField {
17329 WorkerActorDiff,
17330 }
17331 impl<'de> serde::Deserialize<'de> for GeneratedField {
17332 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17333 where
17334 D: serde::Deserializer<'de>,
17335 {
17336 struct GeneratedVisitor;
17337
17338 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17339 type Value = GeneratedField;
17340
17341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17342 write!(formatter, "expected one of: {:?}", &FIELDS)
17343 }
17344
17345 #[allow(unused_variables)]
17346 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17347 where
17348 E: serde::de::Error,
17349 {
17350 match value {
17351 "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
17352 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17353 }
17354 }
17355 }
17356 deserializer.deserialize_identifier(GeneratedVisitor)
17357 }
17358 }
17359 struct GeneratedVisitor;
17360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17361 type Value = WorkerReschedule;
17362
17363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17364 formatter.write_str("struct meta.WorkerReschedule")
17365 }
17366
17367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
17368 where
17369 V: serde::de::MapAccess<'de>,
17370 {
17371 let mut worker_actor_diff__ = None;
17372 while let Some(k) = map_.next_key()? {
17373 match k {
17374 GeneratedField::WorkerActorDiff => {
17375 if worker_actor_diff__.is_some() {
17376 return Err(serde::de::Error::duplicate_field("workerActorDiff"));
17377 }
17378 worker_actor_diff__ = Some(
17379 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
17380 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17381 );
17382 }
17383 }
17384 }
17385 Ok(WorkerReschedule {
17386 worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
17387 })
17388 }
17389 }
17390 deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
17391 }
17392}