risingwave_pb/
source.serde.rs

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