aldrin_core/
convert_value.rs

1use crate::buf_ext::{BufMutExt, ValueBufExt};
2use crate::message::MessageOps;
3use crate::tags::{self, KeyTagImpl};
4use crate::{
5    DeserializeError, ProtocolVersion, SerializeError, SerializedValue, SerializedValueSlice,
6    ValueKind, MAX_VALUE_DEPTH,
7};
8use bytes::{Buf, BufMut, BytesMut};
9use std::borrow::Cow;
10use thiserror::Error;
11
12pub(crate) fn convert(
13    value: &SerializedValueSlice,
14    from: Option<ProtocolVersion>,
15    to: ProtocolVersion,
16) -> Result<Cow<'_, SerializedValueSlice>, ValueConversionError> {
17    const MAX: ProtocolVersion = ProtocolVersion::V1_20;
18
19    let from = Epoch::try_from(from.unwrap_or(MAX))?;
20    let to = Epoch::try_from(to)?;
21
22    if to < from {
23        let mut src = &**value;
24        let mut dst = SerializedValue::new().into_bytes_mut();
25
26        let convert = Convert::new(&mut src, &mut dst, to, 0)?;
27        convert.convert()?;
28
29        if src.is_empty() {
30            Ok(Cow::Owned(SerializedValue::from_bytes_mut(dst)))
31        } else {
32            Err(ValueConversionError::Deserialize(
33                DeserializeError::TrailingData,
34            ))
35        }
36    } else {
37        Ok(Cow::Borrowed(value))
38    }
39}
40
41pub(crate) fn convert_mut(
42    value: &mut SerializedValue,
43    from: Option<ProtocolVersion>,
44    to: ProtocolVersion,
45) -> Result<(), ValueConversionError> {
46    match convert(value, from, to)? {
47        Cow::Owned(converted) => {
48            *value = converted;
49            Ok(())
50        }
51
52        Cow::Borrowed(_) => Ok(()),
53    }
54}
55
56pub(crate) fn convert_in_message(
57    msg: &mut impl MessageOps,
58    from: Option<ProtocolVersion>,
59    to: ProtocolVersion,
60) -> Result<(), ValueConversionError> {
61    match msg.value_mut() {
62        Some(value) => convert_mut(value, from, to),
63        None => Ok(()),
64    }
65}
66
67/// Error when converting a value.
68#[derive(Error, Debug, Copy, Clone, PartialEq, Eq)]
69pub enum ValueConversionError {
70    /// The requested version is invalid.
71    #[error("invalid protocol version")]
72    InvalidVersion,
73
74    /// A value failed to serialize.
75    #[error(transparent)]
76    Serialize(#[from] SerializeError),
77
78    /// A value failed to deserialize.
79    #[error(transparent)]
80    Deserialize(#[from] DeserializeError),
81}
82
83#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
84enum Epoch {
85    V1,
86    V2,
87}
88
89impl TryFrom<ProtocolVersion> for Epoch {
90    type Error = ValueConversionError;
91
92    fn try_from(version: ProtocolVersion) -> Result<Self, Self::Error> {
93        const V1_MIN: ProtocolVersion = ProtocolVersion::V1_14;
94        const V1_MAX: ProtocolVersion = ProtocolVersion::V1_19;
95        const V2_MIN: ProtocolVersion = ProtocolVersion::V1_20;
96        const V2_MAX: ProtocolVersion = ProtocolVersion::V1_20;
97
98        if (version >= V1_MIN) && (version <= V1_MAX) {
99            Ok(Self::V1)
100        } else if (version >= V2_MIN) && (version <= V2_MAX) {
101            Ok(Self::V2)
102        } else {
103            Err(ValueConversionError::InvalidVersion)
104        }
105    }
106}
107
108struct Convert<'a, 'b> {
109    src: &'a mut &'b [u8],
110    dst: &'a mut BytesMut,
111    epoch: Epoch,
112    depth: u8,
113}
114
115impl<'a, 'b> Convert<'a, 'b> {
116    pub(crate) fn new(
117        src: &'a mut &'b [u8],
118        dst: &'a mut BytesMut,
119        epoch: Epoch,
120        depth: u8,
121    ) -> Result<Self, ValueConversionError> {
122        debug_assert!(epoch < Epoch::V2);
123
124        let mut this = Self {
125            src,
126            dst,
127            epoch,
128            depth,
129        };
130
131        this.increment_depth()?;
132        Ok(this)
133    }
134
135    fn increment_depth(&mut self) -> Result<(), ValueConversionError> {
136        self.depth += 1;
137
138        if self.depth <= MAX_VALUE_DEPTH {
139            Ok(())
140        } else {
141            Err(ValueConversionError::Deserialize(
142                DeserializeError::TooDeeplyNested,
143            ))
144        }
145    }
146
147    fn convert(self) -> Result<(), ValueConversionError> {
148        match self.src.try_get_discriminant_u8()? {
149            ValueKind::None => self.convert_none(),
150            ValueKind::Some => self.convert_some(),
151            ValueKind::Bool => self.convert_bool(),
152            ValueKind::U8 => self.convert_u8(),
153            ValueKind::I8 => self.convert_i8(),
154            ValueKind::U16 => self.convert_u16(),
155            ValueKind::I16 => self.convert_i16(),
156            ValueKind::U32 => self.convert_u32(),
157            ValueKind::I32 => self.convert_i32(),
158            ValueKind::U64 => self.convert_u64(),
159            ValueKind::I64 => self.convert_i64(),
160            ValueKind::F32 => self.convert_f32(),
161            ValueKind::F64 => self.convert_f64(),
162            ValueKind::String => self.convert_string(),
163            ValueKind::Uuid => self.convert_uuid(),
164            ValueKind::ObjectId => self.convert_object_id(),
165            ValueKind::ServiceId => self.convert_service_id(),
166            ValueKind::Vec1 => self.convert_vec1(),
167            ValueKind::Bytes1 => self.convert_bytes1(),
168            ValueKind::U8Map1 => self.convert_map1::<tags::U8>(),
169            ValueKind::I8Map1 => self.convert_map1::<tags::I8>(),
170            ValueKind::U16Map1 => self.convert_map1::<tags::U16>(),
171            ValueKind::I16Map1 => self.convert_map1::<tags::I16>(),
172            ValueKind::U32Map1 => self.convert_map1::<tags::U32>(),
173            ValueKind::I32Map1 => self.convert_map1::<tags::I32>(),
174            ValueKind::U64Map1 => self.convert_map1::<tags::U64>(),
175            ValueKind::I64Map1 => self.convert_map1::<tags::I64>(),
176            ValueKind::StringMap1 => self.convert_map1::<tags::String>(),
177            ValueKind::UuidMap1 => self.convert_map1::<tags::Uuid>(),
178            ValueKind::U8Set1 => self.convert_set1::<tags::U8>(),
179            ValueKind::I8Set1 => self.convert_set1::<tags::I8>(),
180            ValueKind::U16Set1 => self.convert_set1::<tags::U16>(),
181            ValueKind::I16Set1 => self.convert_set1::<tags::I16>(),
182            ValueKind::U32Set1 => self.convert_set1::<tags::U32>(),
183            ValueKind::I32Set1 => self.convert_set1::<tags::I32>(),
184            ValueKind::U64Set1 => self.convert_set1::<tags::U64>(),
185            ValueKind::I64Set1 => self.convert_set1::<tags::I64>(),
186            ValueKind::StringSet1 => self.convert_set1::<tags::String>(),
187            ValueKind::UuidSet1 => self.convert_set1::<tags::Uuid>(),
188            ValueKind::Struct1 => self.convert_struct1(),
189            ValueKind::Enum => self.convert_enum(),
190            ValueKind::Sender => self.convert_sender(),
191            ValueKind::Receiver => self.convert_receiver(),
192            ValueKind::Vec2 => self.convert_vec2(),
193            ValueKind::Bytes2 => self.convert_bytes2(),
194            ValueKind::U8Map2 => self.convert_map2::<tags::U8>(),
195            ValueKind::I8Map2 => self.convert_map2::<tags::I8>(),
196            ValueKind::U16Map2 => self.convert_map2::<tags::U16>(),
197            ValueKind::I16Map2 => self.convert_map2::<tags::I16>(),
198            ValueKind::U32Map2 => self.convert_map2::<tags::U32>(),
199            ValueKind::I32Map2 => self.convert_map2::<tags::I32>(),
200            ValueKind::U64Map2 => self.convert_map2::<tags::U64>(),
201            ValueKind::I64Map2 => self.convert_map2::<tags::I64>(),
202            ValueKind::StringMap2 => self.convert_map2::<tags::String>(),
203            ValueKind::UuidMap2 => self.convert_map2::<tags::Uuid>(),
204            ValueKind::U8Set2 => self.convert_set2::<tags::U8>(),
205            ValueKind::I8Set2 => self.convert_set2::<tags::I8>(),
206            ValueKind::U16Set2 => self.convert_set2::<tags::U16>(),
207            ValueKind::I16Set2 => self.convert_set2::<tags::I16>(),
208            ValueKind::U32Set2 => self.convert_set2::<tags::U32>(),
209            ValueKind::I32Set2 => self.convert_set2::<tags::I32>(),
210            ValueKind::U64Set2 => self.convert_set2::<tags::U64>(),
211            ValueKind::I64Set2 => self.convert_set2::<tags::I64>(),
212            ValueKind::StringSet2 => self.convert_set2::<tags::String>(),
213            ValueKind::UuidSet2 => self.convert_set2::<tags::Uuid>(),
214            ValueKind::Struct2 => self.convert_struct2(),
215        }
216    }
217
218    fn convert_next(&mut self) -> Result<(), ValueConversionError> {
219        let this = Convert::new(self.src, self.dst, self.epoch, self.depth)?;
220        this.convert()
221    }
222
223    fn convert_none(self) -> Result<(), ValueConversionError> {
224        self.dst.put_discriminant_u8(ValueKind::None);
225        Ok(())
226    }
227
228    fn convert_some(mut self) -> Result<(), ValueConversionError> {
229        self.dst.put_discriminant_u8(ValueKind::Some);
230        self.convert_next()
231    }
232
233    fn convert_bool(self) -> Result<(), ValueConversionError> {
234        self.dst.put_discriminant_u8(ValueKind::Bool);
235
236        let value = self
237            .src
238            .try_get_u8()
239            .map(|v| v != 0)
240            .map_err(|_| DeserializeError::UnexpectedEoi)?;
241
242        self.dst.put_u8(value.into());
243        Ok(())
244    }
245
246    fn convert_u8(self) -> Result<(), ValueConversionError> {
247        self.dst.put_discriminant_u8(ValueKind::U8);
248
249        let value = self
250            .src
251            .try_get_u8()
252            .map_err(|_| DeserializeError::UnexpectedEoi)?;
253
254        self.dst.put_u8(value);
255        Ok(())
256    }
257
258    fn convert_i8(self) -> Result<(), ValueConversionError> {
259        self.dst.put_discriminant_u8(ValueKind::I8);
260
261        let value = self
262            .src
263            .try_get_i8()
264            .map_err(|_| DeserializeError::UnexpectedEoi)?;
265
266        self.dst.put_i8(value);
267        Ok(())
268    }
269
270    fn convert_u16(self) -> Result<(), ValueConversionError> {
271        self.dst.put_discriminant_u8(ValueKind::U16);
272        let value = self.src.try_get_varint_u16_le()?;
273        self.dst.put_varint_u16_le(value);
274        Ok(())
275    }
276
277    fn convert_i16(self) -> Result<(), ValueConversionError> {
278        self.dst.put_discriminant_u8(ValueKind::I16);
279        let value = self.src.try_get_varint_i16_le()?;
280        self.dst.put_varint_i16_le(value);
281        Ok(())
282    }
283
284    fn convert_u32(self) -> Result<(), ValueConversionError> {
285        self.dst.put_discriminant_u8(ValueKind::U32);
286        let value = self.src.try_get_varint_u32_le()?;
287        self.dst.put_varint_u32_le(value);
288        Ok(())
289    }
290
291    fn convert_i32(self) -> Result<(), ValueConversionError> {
292        self.dst.put_discriminant_u8(ValueKind::I32);
293        let value = self.src.try_get_varint_i32_le()?;
294        self.dst.put_varint_i32_le(value);
295        Ok(())
296    }
297
298    fn convert_u64(self) -> Result<(), ValueConversionError> {
299        self.dst.put_discriminant_u8(ValueKind::U64);
300        let value = self.src.try_get_varint_u64_le()?;
301        self.dst.put_varint_u64_le(value);
302        Ok(())
303    }
304
305    fn convert_i64(self) -> Result<(), ValueConversionError> {
306        self.dst.put_discriminant_u8(ValueKind::I64);
307        let value = self.src.try_get_varint_i64_le()?;
308        self.dst.put_varint_i64_le(value);
309        Ok(())
310    }
311
312    fn convert_f32(self) -> Result<(), ValueConversionError> {
313        self.dst.put_discriminant_u8(ValueKind::F32);
314
315        let value = self
316            .src
317            .try_get_f32_le()
318            .map_err(|_| DeserializeError::UnexpectedEoi)?;
319
320        self.dst.put_u32_le(value.to_bits());
321        Ok(())
322    }
323
324    fn convert_f64(self) -> Result<(), ValueConversionError> {
325        self.dst.put_discriminant_u8(ValueKind::F64);
326
327        let value = self
328            .src
329            .try_get_f64_le()
330            .map_err(|_| DeserializeError::UnexpectedEoi)?;
331
332        self.dst.put_u64_le(value.to_bits());
333        Ok(())
334    }
335
336    fn convert_string(self) -> Result<(), ValueConversionError> {
337        self.dst.put_discriminant_u8(ValueKind::String);
338        let len = self.src.try_get_varint_u32_le()? as usize;
339
340        if self.src.len() >= len {
341            self.dst.put_varint_u32_le(len as u32);
342            self.dst.put_slice(&self.src[..len]);
343            self.src.advance(len);
344
345            Ok(())
346        } else {
347            Err(ValueConversionError::Deserialize(
348                DeserializeError::UnexpectedEoi,
349            ))
350        }
351    }
352
353    fn convert_uuid(self) -> Result<(), ValueConversionError> {
354        self.dst.put_discriminant_u8(ValueKind::Uuid);
355        let mut bytes = uuid::Bytes::default();
356
357        self.src
358            .try_copy_to_slice(&mut bytes)
359            .map_err(|_| DeserializeError::UnexpectedEoi)?;
360
361        self.dst.put_slice(&bytes);
362        Ok(())
363    }
364
365    fn convert_object_id(self) -> Result<(), ValueConversionError> {
366        self.dst.put_discriminant_u8(ValueKind::ObjectId);
367        let mut bytes = uuid::Bytes::default();
368
369        self.src
370            .try_copy_to_slice(&mut bytes)
371            .map_err(|_| DeserializeError::UnexpectedEoi)?;
372        self.dst.put_slice(&bytes);
373
374        self.src
375            .try_copy_to_slice(&mut bytes)
376            .map_err(|_| DeserializeError::UnexpectedEoi)?;
377        self.dst.put_slice(&bytes);
378
379        Ok(())
380    }
381
382    fn convert_service_id(self) -> Result<(), ValueConversionError> {
383        self.dst.put_discriminant_u8(ValueKind::ServiceId);
384        let mut bytes = uuid::Bytes::default();
385
386        self.src
387            .try_copy_to_slice(&mut bytes)
388            .map_err(|_| DeserializeError::UnexpectedEoi)?;
389        self.dst.put_slice(&bytes);
390
391        self.src
392            .try_copy_to_slice(&mut bytes)
393            .map_err(|_| DeserializeError::UnexpectedEoi)?;
394        self.dst.put_slice(&bytes);
395
396        self.src
397            .try_copy_to_slice(&mut bytes)
398            .map_err(|_| DeserializeError::UnexpectedEoi)?;
399        self.dst.put_slice(&bytes);
400
401        self.src
402            .try_copy_to_slice(&mut bytes)
403            .map_err(|_| DeserializeError::UnexpectedEoi)?;
404        self.dst.put_slice(&bytes);
405
406        Ok(())
407    }
408
409    fn convert_vec1(mut self) -> Result<(), ValueConversionError> {
410        self.dst.put_discriminant_u8(ValueKind::Vec1);
411
412        let len = self.src.try_get_varint_u32_le()?;
413        self.dst.put_varint_u32_le(len);
414
415        for _ in 0..len {
416            self.convert_next()?;
417        }
418
419        Ok(())
420    }
421
422    fn convert_bytes1(self) -> Result<(), ValueConversionError> {
423        self.dst.put_discriminant_u8(ValueKind::Bytes1);
424        let len = self.src.try_get_varint_u32_le()? as usize;
425
426        if self.src.len() >= len {
427            self.dst.put_varint_u32_le(len as u32);
428            self.dst.put_slice(&self.src[..len]);
429            self.src.advance(len);
430
431            Ok(())
432        } else {
433            Err(ValueConversionError::Deserialize(
434                DeserializeError::UnexpectedEoi,
435            ))
436        }
437    }
438
439    fn convert_map1<K: KeyTagImpl>(mut self) -> Result<(), ValueConversionError> {
440        self.dst.put_discriminant_u8(K::VALUE_KIND_MAP1);
441
442        let len = self.src.try_get_varint_u32_le()?;
443        self.dst.put_varint_u32_le(len);
444
445        for _ in 0..len {
446            K::convert(self.src, self.dst)?;
447            self.convert_next()?;
448        }
449
450        Ok(())
451    }
452
453    fn convert_set1<K: KeyTagImpl>(self) -> Result<(), ValueConversionError> {
454        self.dst.put_discriminant_u8(K::VALUE_KIND_SET1);
455
456        let len = self.src.try_get_varint_u32_le()?;
457        self.dst.put_varint_u32_le(len);
458
459        for _ in 0..len {
460            K::convert(self.src, self.dst)?;
461        }
462
463        Ok(())
464    }
465
466    fn convert_struct1(mut self) -> Result<(), ValueConversionError> {
467        self.dst.put_discriminant_u8(ValueKind::Struct1);
468
469        let len = self.src.try_get_varint_u32_le()?;
470        self.dst.put_varint_u32_le(len);
471
472        for _ in 0..len {
473            let id = self.src.try_get_varint_u32_le()?;
474            self.dst.put_varint_u32_le(id);
475
476            self.convert_next()?;
477        }
478
479        Ok(())
480    }
481
482    fn convert_enum(mut self) -> Result<(), ValueConversionError> {
483        self.dst.put_discriminant_u8(ValueKind::Enum);
484
485        let id = self.src.try_get_varint_u32_le()?;
486        self.dst.put_varint_u32_le(id);
487
488        self.convert_next()
489    }
490
491    fn convert_sender(self) -> Result<(), ValueConversionError> {
492        self.dst.put_discriminant_u8(ValueKind::Sender);
493        let mut bytes = uuid::Bytes::default();
494
495        self.src
496            .try_copy_to_slice(&mut bytes)
497            .map_err(|_| DeserializeError::UnexpectedEoi)?;
498
499        self.dst.put_slice(&bytes);
500        Ok(())
501    }
502
503    fn convert_receiver(self) -> Result<(), ValueConversionError> {
504        self.dst.put_discriminant_u8(ValueKind::Receiver);
505        let mut bytes = uuid::Bytes::default();
506
507        self.src
508            .try_copy_to_slice(&mut bytes)
509            .map_err(|_| DeserializeError::UnexpectedEoi)?;
510
511        self.dst.put_slice(&bytes);
512        Ok(())
513    }
514
515    fn convert_vec2(self) -> Result<(), ValueConversionError> {
516        match self.epoch {
517            Epoch::V1 => self.convert_vec2_to_vec1(),
518            Epoch::V2 => unreachable!(),
519        }
520    }
521
522    fn convert_vec2_to_vec1(self) -> Result<(), ValueConversionError> {
523        let mut tmp = BytesMut::new();
524        let mut len = 0usize;
525
526        loop {
527            match self.src.try_get_discriminant_u8()? {
528                ValueKind::None => {
529                    let Ok(len) = len.try_into() else {
530                        return Err(ValueConversionError::Serialize(SerializeError::Overflow));
531                    };
532
533                    self.dst.put_discriminant_u8(ValueKind::Vec1);
534                    self.dst.put_varint_u32_le(len);
535                    self.dst.extend_from_slice(&tmp);
536
537                    break Ok(());
538                }
539
540                ValueKind::Some => {
541                    let convert = Convert::new(self.src, &mut tmp, self.epoch, self.depth)?;
542                    convert.convert()?;
543
544                    len += 1;
545                }
546
547                _ => {
548                    break Err(ValueConversionError::Deserialize(
549                        DeserializeError::InvalidSerialization,
550                    ));
551                }
552            }
553        }
554    }
555
556    fn convert_bytes2(self) -> Result<(), ValueConversionError> {
557        match self.epoch {
558            Epoch::V1 => self.convert_bytes2_to_bytes1(),
559            Epoch::V2 => unreachable!(),
560        }
561    }
562
563    fn convert_bytes2_to_bytes1(self) -> Result<(), ValueConversionError> {
564        let mut tmp = Vec::new();
565
566        loop {
567            let len = self.src.try_get_varint_u32_le()? as usize;
568
569            if len == 0 {
570                let Ok(len) = tmp.len().try_into() else {
571                    return Err(ValueConversionError::Serialize(SerializeError::Overflow));
572                };
573
574                self.dst.put_discriminant_u8(ValueKind::Bytes1);
575                self.dst.put_varint_u32_le(len);
576                self.dst.extend_from_slice(&tmp);
577
578                break Ok(());
579            }
580
581            if self.src.len() < len {
582                break Err(ValueConversionError::Deserialize(
583                    DeserializeError::InvalidSerialization,
584                ));
585            }
586
587            tmp.extend_from_slice(&self.src[..len]);
588            self.src.advance(len);
589        }
590    }
591
592    fn convert_map2<K: KeyTagImpl>(self) -> Result<(), ValueConversionError> {
593        match self.epoch {
594            Epoch::V1 => self.convert_map2_to_map1::<K>(),
595            Epoch::V2 => unreachable!(),
596        }
597    }
598
599    fn convert_map2_to_map1<K: KeyTagImpl>(self) -> Result<(), ValueConversionError> {
600        let mut tmp = BytesMut::new();
601        let mut len = 0usize;
602
603        loop {
604            match self.src.try_get_discriminant_u8()? {
605                ValueKind::None => {
606                    let Ok(len) = len.try_into() else {
607                        return Err(ValueConversionError::Serialize(SerializeError::Overflow));
608                    };
609
610                    self.dst.put_discriminant_u8(K::VALUE_KIND_MAP1);
611                    self.dst.put_varint_u32_le(len);
612                    self.dst.extend_from_slice(&tmp);
613
614                    break Ok(());
615                }
616
617                ValueKind::Some => {
618                    K::convert(self.src, &mut tmp)?;
619
620                    let convert = Convert::new(self.src, &mut tmp, self.epoch, self.depth)?;
621                    convert.convert()?;
622
623                    len += 1;
624                }
625
626                _ => {
627                    break Err(ValueConversionError::Deserialize(
628                        DeserializeError::InvalidSerialization,
629                    ));
630                }
631            }
632        }
633    }
634
635    fn convert_set2<K: KeyTagImpl>(self) -> Result<(), ValueConversionError> {
636        match self.epoch {
637            Epoch::V1 => self.convert_set2_to_set1::<K>(),
638            Epoch::V2 => unreachable!(),
639        }
640    }
641
642    fn convert_set2_to_set1<K: KeyTagImpl>(self) -> Result<(), ValueConversionError> {
643        let mut tmp = BytesMut::new();
644        let mut len = 0usize;
645
646        loop {
647            match self.src.try_get_discriminant_u8()? {
648                ValueKind::None => {
649                    let Ok(len) = len.try_into() else {
650                        return Err(ValueConversionError::Serialize(SerializeError::Overflow));
651                    };
652
653                    self.dst.put_discriminant_u8(K::VALUE_KIND_SET1);
654                    self.dst.put_varint_u32_le(len);
655                    self.dst.extend_from_slice(&tmp);
656
657                    break Ok(());
658                }
659
660                ValueKind::Some => {
661                    K::convert(self.src, &mut tmp)?;
662                    len += 1;
663                }
664
665                _ => {
666                    break Err(ValueConversionError::Deserialize(
667                        DeserializeError::InvalidSerialization,
668                    ));
669                }
670            }
671        }
672    }
673
674    fn convert_struct2(self) -> Result<(), ValueConversionError> {
675        match self.epoch {
676            Epoch::V1 => self.convert_struct2_to_struct1(),
677            Epoch::V2 => unreachable!(),
678        }
679    }
680
681    fn convert_struct2_to_struct1(self) -> Result<(), ValueConversionError> {
682        let mut tmp = BytesMut::new();
683        let mut len = 0usize;
684
685        loop {
686            match self.src.try_get_discriminant_u8()? {
687                ValueKind::None => {
688                    let Ok(len) = len.try_into() else {
689                        return Err(ValueConversionError::Serialize(SerializeError::Overflow));
690                    };
691
692                    self.dst.put_discriminant_u8(ValueKind::Struct1);
693                    self.dst.put_varint_u32_le(len);
694                    self.dst.extend_from_slice(&tmp);
695
696                    break Ok(());
697                }
698
699                ValueKind::Some => {
700                    let id = self.src.try_get_varint_u32_le()?;
701                    tmp.put_varint_u32_le(id);
702
703                    let convert = Convert::new(self.src, &mut tmp, self.epoch, self.depth)?;
704                    convert.convert()?;
705
706                    len += 1;
707                }
708
709                _ => {
710                    break Err(ValueConversionError::Deserialize(
711                        DeserializeError::InvalidSerialization,
712                    ));
713                }
714            }
715        }
716    }
717}
aldrin_core/convert_value.rs

aldrin_core/
convert_value.rs
