tlb-ton 0.2.21

Common TL-B types for TON blockchain
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use tlb::{
    bits::{de::BitReaderExt, ser::BitWriterExt},
    de::{args::r#as::CellDeserializeAsWithArgs, CellParser, CellParserError},
    r#as::{ParseFully, Ref},
    ser::{args::r#as::CellSerializeAsWithArgs, CellBuilder, CellBuilderError},
};

/// [`BinTreeAug X Y`](https://docs.ton.org/develop/data-formats/tl-b-types#bintree)  
/// ```tlb
/// bta_leaf$0 {X:Type} {Y:Type} extra:Y leaf:X = BinTreeAug X Y;
/// bta_fork$1 {X:Type} {Y:Type} left:^(BinTreeAug X Y)
/// right:^(BinTreeAug X Y) extra:Y = BinTreeAug X Y;
/// ```
pub struct BinTreeAug<T, E = ()> {
    pub node: BinTreeNode<T, E>,
    pub extra: E,
}

impl<T, AsT, E, AsE> CellSerializeAsWithArgs<BinTreeAug<T, E>> for BinTreeAug<AsT, AsE>
where
    AsT: CellSerializeAsWithArgs<T>,
    AsT::Args: Clone,
    AsE: CellSerializeAsWithArgs<E>,
    AsE::Args: Clone,
{
    type Args = (AsT::Args, AsE::Args);

    #[inline]
    fn store_as_with(
        source: &BinTreeAug<T, E>,
        builder: &mut CellBuilder,
        (args, extra_args): Self::Args,
    ) -> Result<(), CellBuilderError> {
        builder
            .store_as_with::<_, &AsE>(&source.extra, extra_args.clone())?
            .store_as_with::<_, &BinTreeNode<AsT, AsE>>(&source.node, (args, extra_args))?;
        Ok(())
    }
}

impl<'de, T, AsT, E, AsE> CellDeserializeAsWithArgs<'de, BinTreeAug<T, E>> for BinTreeAug<AsT, AsE>
where
    AsT: CellDeserializeAsWithArgs<'de, T>,
    AsT::Args: Clone,
    AsE: CellDeserializeAsWithArgs<'de, E>,
    AsE::Args: Clone,
{
    type Args = (AsT::Args, AsE::Args);

    #[inline]
    fn parse_as_with(
        parser: &mut CellParser<'de>,
        (args, extra_args): Self::Args,
    ) -> Result<BinTreeAug<T, E>, CellParserError<'de>> {
        Ok(BinTreeAug {
            extra: parser.parse_as_with::<_, AsE>(extra_args.clone())?,
            node: parser
                .parse_as_with::<_, ParseFully<BinTreeNode<AsT, AsE>>>((args, extra_args))?,
        })
    }
}

/// [`BinTreeAugNode X Y`](https://docs.ton.org/develop/data-formats/tl-b-types#bintree)
/// Type parameter `E` is optional and stands for `extra`, so it can be reused
/// for [`BinTree X`](super::BinTree)
/// ```tlb
/// bta_leaf$0 {X:Type} {Y:Type} extra:Y leaf:X = BinTreeAug X Y;
/// bta_fork$1 {X:Type} {Y:Type} left:^(BinTreeAug X Y)
/// right:^(BinTreeAug X Y) extra:Y = BinTreeAug X Y;
/// ```
pub enum BinTreeNode<T, E = ()> {
    Leaf(T),
    Fork([Box<BinTreeAug<T, E>>; 2]),
}

impl<T, AsT, E, AsE> CellSerializeAsWithArgs<BinTreeNode<T, E>> for BinTreeNode<AsT, AsE>
where
    AsT: CellSerializeAsWithArgs<T>,
    AsT::Args: Clone,
    AsE: CellSerializeAsWithArgs<E>,
    AsE::Args: Clone,
{
    type Args = (AsT::Args, AsE::Args);

    #[inline]
    fn store_as_with(
        source: &BinTreeNode<T, E>,
        builder: &mut CellBuilder,
        (args, extra_args): Self::Args,
    ) -> Result<(), CellBuilderError> {
        match source {
            BinTreeNode::Leaf(leaf) => builder.pack(false)?.store_as_with::<_, &AsT>(leaf, args)?,
            BinTreeNode::Fork(fork) => builder
                .pack(true)?
                .store_as_with::<_, &[Box<Ref<BinTreeAug<AsT, AsE>>>; 2]>(
                    fork,
                    (args, extra_args),
                )?,
        };
        Ok(())
    }
}

impl<'de, T, AsT, E, AsE> CellDeserializeAsWithArgs<'de, BinTreeNode<T, E>>
    for BinTreeNode<AsT, AsE>
where
    AsT: CellDeserializeAsWithArgs<'de, T>,
    AsT::Args: Clone,
    AsE: CellDeserializeAsWithArgs<'de, E>,
    AsE::Args: Clone,
{
    type Args = (AsT::Args, AsE::Args);

    #[inline]
    fn parse_as_with(
        parser: &mut CellParser<'de>,
        (args, extra_args): Self::Args,
    ) -> Result<BinTreeNode<T, E>, CellParserError<'de>> {
        Ok(match parser.unpack()? {
            false => BinTreeNode::Leaf(parser.parse_as_with::<_, AsT>(args)?),
            true => BinTreeNode::Fork(
                parser.parse_as_with::<_, [Box<Ref<ParseFully<BinTreeAug<AsT, AsE>>>>; 2]>((
                    args, extra_args,
                ))?,
            ),
        })
    }
}