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