tlb 0.8.0

TL-B serialization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use core::marker::PhantomData;

use crate::{
    Cell, Context, Ref, Same,
    de::{CellDeserializeAs, CellParser, CellParserError},
    ser::{CellBuilder, CellBuilderError, CellSerializeAs},
};

/// ```tlb
/// list_empty$_ {X:Type} = List X 0;
/// list$_ {X:Type} {n:#} prev:^(List X n) v:X = List X (n + 1);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct List<T = Same>(PhantomData<T>);

impl<T, As> CellSerializeAs<Vec<T>> for List<As>
where
    As: CellSerializeAs<T>,
    As::Args: Clone,
{
    type Args = As::Args;

    #[inline]
    fn store_as(
        source: &Vec<T>,
        builder: &mut CellBuilder,
        args: Self::Args,
    ) -> Result<(), CellBuilderError> {
        builder.store(
            source.iter().try_fold(Cell::builder(), |prev, v| {
                let mut list = Cell::builder();
                list.store_as::<_, Ref>(prev, ())?
                    .store_as::<_, &As>(v, args.clone())?;
                Ok(list)
            })?,
            (),
        )?;
        Ok(())
    }
}

impl<'de, T, As> CellDeserializeAs<'de, Vec<T>> for List<As>
where
    As: CellDeserializeAs<'de, T>,
    As::Args: Clone,
{
    type Args = As::Args;

    #[inline]
    fn parse_as(
        parser: &mut CellParser<'de>,
        args: Self::Args,
    ) -> Result<Vec<T>, CellParserError<'de>> {
        let mut v = Vec::new();
        let mut p: CellParser<'de> = parser.parse(())?;
        while !p.no_references_left() {
            v.push(
                p.parse_as::<_, As>(args.clone())
                    .with_context(|| format!("[{}]", v.len()))?,
            );
            p = p.parse_as::<_, Ref>(())?;
        }
        v.reverse();
        Ok(v)
    }
}