1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::source::*;
4impl serde::Serialize for CdcTableSnapshotSplit {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if self.split_id != 0 {
13 len += 1;
14 }
15 if !self.left_bound_inclusive.is_empty() {
16 len += 1;
17 }
18 if !self.right_bound_exclusive.is_empty() {
19 len += 1;
20 }
21 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplit", len)?;
22 if self.split_id != 0 {
23 #[allow(clippy::needless_borrow)]
24 #[allow(clippy::needless_borrows_for_generic_args)]
25 struct_ser.serialize_field("splitId", ToString::to_string(&self.split_id).as_str())?;
26 }
27 if !self.left_bound_inclusive.is_empty() {
28 #[allow(clippy::needless_borrow)]
29 #[allow(clippy::needless_borrows_for_generic_args)]
30 struct_ser.serialize_field("leftBoundInclusive", pbjson::private::base64::encode(&self.left_bound_inclusive).as_str())?;
31 }
32 if !self.right_bound_exclusive.is_empty() {
33 #[allow(clippy::needless_borrow)]
34 #[allow(clippy::needless_borrows_for_generic_args)]
35 struct_ser.serialize_field("rightBoundExclusive", pbjson::private::base64::encode(&self.right_bound_exclusive).as_str())?;
36 }
37 struct_ser.end()
38 }
39}
40impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplit {
41 #[allow(deprecated)]
42 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
43 where
44 D: serde::Deserializer<'de>,
45 {
46 const FIELDS: &[&str] = &[
47 "split_id",
48 "splitId",
49 "left_bound_inclusive",
50 "leftBoundInclusive",
51 "right_bound_exclusive",
52 "rightBoundExclusive",
53 ];
54
55 #[allow(clippy::enum_variant_names)]
56 enum GeneratedField {
57 SplitId,
58 LeftBoundInclusive,
59 RightBoundExclusive,
60 }
61 impl<'de> serde::Deserialize<'de> for GeneratedField {
62 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
63 where
64 D: serde::Deserializer<'de>,
65 {
66 struct GeneratedVisitor;
67
68 impl serde::de::Visitor<'_> for GeneratedVisitor {
69 type Value = GeneratedField;
70
71 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
72 write!(formatter, "expected one of: {:?}", &FIELDS)
73 }
74
75 #[allow(unused_variables)]
76 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
77 where
78 E: serde::de::Error,
79 {
80 match value {
81 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
82 "leftBoundInclusive" | "left_bound_inclusive" => Ok(GeneratedField::LeftBoundInclusive),
83 "rightBoundExclusive" | "right_bound_exclusive" => Ok(GeneratedField::RightBoundExclusive),
84 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
85 }
86 }
87 }
88 deserializer.deserialize_identifier(GeneratedVisitor)
89 }
90 }
91 struct GeneratedVisitor;
92 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
93 type Value = CdcTableSnapshotSplit;
94
95 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
96 formatter.write_str("struct source.CdcTableSnapshotSplit")
97 }
98
99 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplit, V::Error>
100 where
101 V: serde::de::MapAccess<'de>,
102 {
103 let mut split_id__ = None;
104 let mut left_bound_inclusive__ = None;
105 let mut right_bound_exclusive__ = None;
106 while let Some(k) = map_.next_key()? {
107 match k {
108 GeneratedField::SplitId => {
109 if split_id__.is_some() {
110 return Err(serde::de::Error::duplicate_field("splitId"));
111 }
112 split_id__ =
113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
114 ;
115 }
116 GeneratedField::LeftBoundInclusive => {
117 if left_bound_inclusive__.is_some() {
118 return Err(serde::de::Error::duplicate_field("leftBoundInclusive"));
119 }
120 left_bound_inclusive__ =
121 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
122 ;
123 }
124 GeneratedField::RightBoundExclusive => {
125 if right_bound_exclusive__.is_some() {
126 return Err(serde::de::Error::duplicate_field("rightBoundExclusive"));
127 }
128 right_bound_exclusive__ =
129 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
130 ;
131 }
132 }
133 }
134 Ok(CdcTableSnapshotSplit {
135 split_id: split_id__.unwrap_or_default(),
136 left_bound_inclusive: left_bound_inclusive__.unwrap_or_default(),
137 right_bound_exclusive: right_bound_exclusive__.unwrap_or_default(),
138 })
139 }
140 }
141 deserializer.deserialize_struct("source.CdcTableSnapshotSplit", FIELDS, GeneratedVisitor)
142 }
143}
144impl serde::Serialize for CdcTableSnapshotSplits {
145 #[allow(deprecated)]
146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
147 where
148 S: serde::Serializer,
149 {
150 use serde::ser::SerializeStruct;
151 let mut len = 0;
152 if !self.splits.is_empty() {
153 len += 1;
154 }
155 if self.generation != 0 {
156 len += 1;
157 }
158 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplits", len)?;
159 if !self.splits.is_empty() {
160 struct_ser.serialize_field("splits", &self.splits)?;
161 }
162 if self.generation != 0 {
163 #[allow(clippy::needless_borrow)]
164 #[allow(clippy::needless_borrows_for_generic_args)]
165 struct_ser.serialize_field("generation", ToString::to_string(&self.generation).as_str())?;
166 }
167 struct_ser.end()
168 }
169}
170impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplits {
171 #[allow(deprecated)]
172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
173 where
174 D: serde::Deserializer<'de>,
175 {
176 const FIELDS: &[&str] = &[
177 "splits",
178 "generation",
179 ];
180
181 #[allow(clippy::enum_variant_names)]
182 enum GeneratedField {
183 Splits,
184 Generation,
185 }
186 impl<'de> serde::Deserialize<'de> for GeneratedField {
187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
188 where
189 D: serde::Deserializer<'de>,
190 {
191 struct GeneratedVisitor;
192
193 impl serde::de::Visitor<'_> for GeneratedVisitor {
194 type Value = GeneratedField;
195
196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
197 write!(formatter, "expected one of: {:?}", &FIELDS)
198 }
199
200 #[allow(unused_variables)]
201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
202 where
203 E: serde::de::Error,
204 {
205 match value {
206 "splits" => Ok(GeneratedField::Splits),
207 "generation" => Ok(GeneratedField::Generation),
208 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
209 }
210 }
211 }
212 deserializer.deserialize_identifier(GeneratedVisitor)
213 }
214 }
215 struct GeneratedVisitor;
216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
217 type Value = CdcTableSnapshotSplits;
218
219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
220 formatter.write_str("struct source.CdcTableSnapshotSplits")
221 }
222
223 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplits, V::Error>
224 where
225 V: serde::de::MapAccess<'de>,
226 {
227 let mut splits__ = None;
228 let mut generation__ = None;
229 while let Some(k) = map_.next_key()? {
230 match k {
231 GeneratedField::Splits => {
232 if splits__.is_some() {
233 return Err(serde::de::Error::duplicate_field("splits"));
234 }
235 splits__ = Some(map_.next_value()?);
236 }
237 GeneratedField::Generation => {
238 if generation__.is_some() {
239 return Err(serde::de::Error::duplicate_field("generation"));
240 }
241 generation__ =
242 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
243 ;
244 }
245 }
246 }
247 Ok(CdcTableSnapshotSplits {
248 splits: splits__.unwrap_or_default(),
249 generation: generation__.unwrap_or_default(),
250 })
251 }
252 }
253 deserializer.deserialize_struct("source.CdcTableSnapshotSplits", FIELDS, GeneratedVisitor)
254 }
255}
256impl serde::Serialize for CdcTableSnapshotSplitsWithGeneration {
257 #[allow(deprecated)]
258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
259 where
260 S: serde::Serializer,
261 {
262 use serde::ser::SerializeStruct;
263 let mut len = 0;
264 if !self.splits.is_empty() {
265 len += 1;
266 }
267 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplitsWithGeneration", len)?;
268 if !self.splits.is_empty() {
269 struct_ser.serialize_field("splits", &self.splits)?;
270 }
271 struct_ser.end()
272 }
273}
274impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplitsWithGeneration {
275 #[allow(deprecated)]
276 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
277 where
278 D: serde::Deserializer<'de>,
279 {
280 const FIELDS: &[&str] = &[
281 "splits",
282 ];
283
284 #[allow(clippy::enum_variant_names)]
285 enum GeneratedField {
286 Splits,
287 }
288 impl<'de> serde::Deserialize<'de> for GeneratedField {
289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
290 where
291 D: serde::Deserializer<'de>,
292 {
293 struct GeneratedVisitor;
294
295 impl serde::de::Visitor<'_> for GeneratedVisitor {
296 type Value = GeneratedField;
297
298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
299 write!(formatter, "expected one of: {:?}", &FIELDS)
300 }
301
302 #[allow(unused_variables)]
303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
304 where
305 E: serde::de::Error,
306 {
307 match value {
308 "splits" => Ok(GeneratedField::Splits),
309 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
310 }
311 }
312 }
313 deserializer.deserialize_identifier(GeneratedVisitor)
314 }
315 }
316 struct GeneratedVisitor;
317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
318 type Value = CdcTableSnapshotSplitsWithGeneration;
319
320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
321 formatter.write_str("struct source.CdcTableSnapshotSplitsWithGeneration")
322 }
323
324 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplitsWithGeneration, V::Error>
325 where
326 V: serde::de::MapAccess<'de>,
327 {
328 let mut splits__ = None;
329 while let Some(k) = map_.next_key()? {
330 match k {
331 GeneratedField::Splits => {
332 if splits__.is_some() {
333 return Err(serde::de::Error::duplicate_field("splits"));
334 }
335 splits__ = Some(
336 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
337 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
338 );
339 }
340 }
341 }
342 Ok(CdcTableSnapshotSplitsWithGeneration {
343 splits: splits__.unwrap_or_default(),
344 })
345 }
346 }
347 deserializer.deserialize_struct("source.CdcTableSnapshotSplitsWithGeneration", FIELDS, GeneratedVisitor)
348 }
349}
350impl serde::Serialize for ConnectorSplit {
351 #[allow(deprecated)]
352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
353 where
354 S: serde::Serializer,
355 {
356 use serde::ser::SerializeStruct;
357 let mut len = 0;
358 if !self.split_type.is_empty() {
359 len += 1;
360 }
361 if !self.encoded_split.is_empty() {
362 len += 1;
363 }
364 let mut struct_ser = serializer.serialize_struct("source.ConnectorSplit", len)?;
365 if !self.split_type.is_empty() {
366 struct_ser.serialize_field("splitType", &self.split_type)?;
367 }
368 if !self.encoded_split.is_empty() {
369 #[allow(clippy::needless_borrow)]
370 #[allow(clippy::needless_borrows_for_generic_args)]
371 struct_ser.serialize_field("encodedSplit", pbjson::private::base64::encode(&self.encoded_split).as_str())?;
372 }
373 struct_ser.end()
374 }
375}
376impl<'de> serde::Deserialize<'de> for ConnectorSplit {
377 #[allow(deprecated)]
378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
379 where
380 D: serde::Deserializer<'de>,
381 {
382 const FIELDS: &[&str] = &[
383 "split_type",
384 "splitType",
385 "encoded_split",
386 "encodedSplit",
387 ];
388
389 #[allow(clippy::enum_variant_names)]
390 enum GeneratedField {
391 SplitType,
392 EncodedSplit,
393 }
394 impl<'de> serde::Deserialize<'de> for GeneratedField {
395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
396 where
397 D: serde::Deserializer<'de>,
398 {
399 struct GeneratedVisitor;
400
401 impl serde::de::Visitor<'_> for GeneratedVisitor {
402 type Value = GeneratedField;
403
404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
405 write!(formatter, "expected one of: {:?}", &FIELDS)
406 }
407
408 #[allow(unused_variables)]
409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
410 where
411 E: serde::de::Error,
412 {
413 match value {
414 "splitType" | "split_type" => Ok(GeneratedField::SplitType),
415 "encodedSplit" | "encoded_split" => Ok(GeneratedField::EncodedSplit),
416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
417 }
418 }
419 }
420 deserializer.deserialize_identifier(GeneratedVisitor)
421 }
422 }
423 struct GeneratedVisitor;
424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
425 type Value = ConnectorSplit;
426
427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
428 formatter.write_str("struct source.ConnectorSplit")
429 }
430
431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorSplit, V::Error>
432 where
433 V: serde::de::MapAccess<'de>,
434 {
435 let mut split_type__ = None;
436 let mut encoded_split__ = None;
437 while let Some(k) = map_.next_key()? {
438 match k {
439 GeneratedField::SplitType => {
440 if split_type__.is_some() {
441 return Err(serde::de::Error::duplicate_field("splitType"));
442 }
443 split_type__ = Some(map_.next_value()?);
444 }
445 GeneratedField::EncodedSplit => {
446 if encoded_split__.is_some() {
447 return Err(serde::de::Error::duplicate_field("encodedSplit"));
448 }
449 encoded_split__ =
450 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
451 ;
452 }
453 }
454 }
455 Ok(ConnectorSplit {
456 split_type: split_type__.unwrap_or_default(),
457 encoded_split: encoded_split__.unwrap_or_default(),
458 })
459 }
460 }
461 deserializer.deserialize_struct("source.ConnectorSplit", FIELDS, GeneratedVisitor)
462 }
463}
464impl serde::Serialize for ConnectorSplits {
465 #[allow(deprecated)]
466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
467 where
468 S: serde::Serializer,
469 {
470 use serde::ser::SerializeStruct;
471 let mut len = 0;
472 if !self.splits.is_empty() {
473 len += 1;
474 }
475 let mut struct_ser = serializer.serialize_struct("source.ConnectorSplits", len)?;
476 if !self.splits.is_empty() {
477 struct_ser.serialize_field("splits", &self.splits)?;
478 }
479 struct_ser.end()
480 }
481}
482impl<'de> serde::Deserialize<'de> for ConnectorSplits {
483 #[allow(deprecated)]
484 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
485 where
486 D: serde::Deserializer<'de>,
487 {
488 const FIELDS: &[&str] = &[
489 "splits",
490 ];
491
492 #[allow(clippy::enum_variant_names)]
493 enum GeneratedField {
494 Splits,
495 }
496 impl<'de> serde::Deserialize<'de> for GeneratedField {
497 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
498 where
499 D: serde::Deserializer<'de>,
500 {
501 struct GeneratedVisitor;
502
503 impl serde::de::Visitor<'_> for GeneratedVisitor {
504 type Value = GeneratedField;
505
506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
507 write!(formatter, "expected one of: {:?}", &FIELDS)
508 }
509
510 #[allow(unused_variables)]
511 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
512 where
513 E: serde::de::Error,
514 {
515 match value {
516 "splits" => Ok(GeneratedField::Splits),
517 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
518 }
519 }
520 }
521 deserializer.deserialize_identifier(GeneratedVisitor)
522 }
523 }
524 struct GeneratedVisitor;
525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
526 type Value = ConnectorSplits;
527
528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
529 formatter.write_str("struct source.ConnectorSplits")
530 }
531
532 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorSplits, V::Error>
533 where
534 V: serde::de::MapAccess<'de>,
535 {
536 let mut splits__ = None;
537 while let Some(k) = map_.next_key()? {
538 match k {
539 GeneratedField::Splits => {
540 if splits__.is_some() {
541 return Err(serde::de::Error::duplicate_field("splits"));
542 }
543 splits__ = Some(map_.next_value()?);
544 }
545 }
546 }
547 Ok(ConnectorSplits {
548 splits: splits__.unwrap_or_default(),
549 })
550 }
551 }
552 deserializer.deserialize_struct("source.ConnectorSplits", FIELDS, GeneratedVisitor)
553 }
554}
555impl serde::Serialize for SourceActorInfo {
556 #[allow(deprecated)]
557 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
558 where
559 S: serde::Serializer,
560 {
561 use serde::ser::SerializeStruct;
562 let mut len = 0;
563 if self.actor_id != 0 {
564 len += 1;
565 }
566 if self.splits.is_some() {
567 len += 1;
568 }
569 let mut struct_ser = serializer.serialize_struct("source.SourceActorInfo", len)?;
570 if self.actor_id != 0 {
571 struct_ser.serialize_field("actorId", &self.actor_id)?;
572 }
573 if let Some(v) = self.splits.as_ref() {
574 struct_ser.serialize_field("splits", v)?;
575 }
576 struct_ser.end()
577 }
578}
579impl<'de> serde::Deserialize<'de> for SourceActorInfo {
580 #[allow(deprecated)]
581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
582 where
583 D: serde::Deserializer<'de>,
584 {
585 const FIELDS: &[&str] = &[
586 "actor_id",
587 "actorId",
588 "splits",
589 ];
590
591 #[allow(clippy::enum_variant_names)]
592 enum GeneratedField {
593 ActorId,
594 Splits,
595 }
596 impl<'de> serde::Deserialize<'de> for GeneratedField {
597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
598 where
599 D: serde::Deserializer<'de>,
600 {
601 struct GeneratedVisitor;
602
603 impl serde::de::Visitor<'_> for GeneratedVisitor {
604 type Value = GeneratedField;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 write!(formatter, "expected one of: {:?}", &FIELDS)
608 }
609
610 #[allow(unused_variables)]
611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
612 where
613 E: serde::de::Error,
614 {
615 match value {
616 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
617 "splits" => Ok(GeneratedField::Splits),
618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
619 }
620 }
621 }
622 deserializer.deserialize_identifier(GeneratedVisitor)
623 }
624 }
625 struct GeneratedVisitor;
626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
627 type Value = SourceActorInfo;
628
629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
630 formatter.write_str("struct source.SourceActorInfo")
631 }
632
633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceActorInfo, V::Error>
634 where
635 V: serde::de::MapAccess<'de>,
636 {
637 let mut actor_id__ = None;
638 let mut splits__ = None;
639 while let Some(k) = map_.next_key()? {
640 match k {
641 GeneratedField::ActorId => {
642 if actor_id__.is_some() {
643 return Err(serde::de::Error::duplicate_field("actorId"));
644 }
645 actor_id__ =
646 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
647 ;
648 }
649 GeneratedField::Splits => {
650 if splits__.is_some() {
651 return Err(serde::de::Error::duplicate_field("splits"));
652 }
653 splits__ = map_.next_value()?;
654 }
655 }
656 }
657 Ok(SourceActorInfo {
658 actor_id: actor_id__.unwrap_or_default(),
659 splits: splits__,
660 })
661 }
662 }
663 deserializer.deserialize_struct("source.SourceActorInfo", FIELDS, GeneratedVisitor)
664 }
665}