packable-derive 0.10.0

Derive macro for the `packable` crate.
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

// Copyright 2023 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use proc_macro2::TokenStream;
use quote::quote;
use syn::{Ident, Path};

use crate::{record_info::RecordInfo, unpack_visitor_info::UnpackVisitorInfo};

pub(crate) struct Fragments {
    // The pattern used to destructure the record.
    pub(crate) pattern: TokenStream,
    // An expression that packs the record.
    pub(crate) pack: TokenStream,
    // An expression that unpacks the record.
    pub(crate) unpack: TokenStream,
}

impl Fragments {
    pub(crate) fn new(
        info: RecordInfo,
        verify_with: Option<Path>,
        unpack_visitor_info: &UnpackVisitorInfo,
        crate_name: &Ident,
    ) -> Self {
        let RecordInfo {
            path,
            fields_unpack_error_with,
            fields_verify_with,
            fields_ident,
            fields_pattern_ident,
            fields_type,
        } = info;

        let fields_verification = fields_verify_with.into_iter().zip(fields_ident.iter()).map(
            |(verify_with, field_ident)| match verify_with {
                Some(verify_with) => if unpack_visitor_info.explicit {
                    quote! {
                        if let Some(visitor) = visitor {
                            #verify_with(&#field_ident, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;
                        }
                    }
                } else {
                    quote! {
                        if visitor.is_some() {
                            #verify_with(&#field_ident).map_err(#crate_name::error::UnpackError::from_packable)?;
                        }
                    }
                },
                None => quote!(),
            },
        );

        let verify_with = match verify_with {
            Some(verify_with) => {
                if unpack_visitor_info.explicit {
                    quote! {
                        if let Some(visitor) = visitor {
                            #verify_with(&unpacked, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;
                        }
                    }
                } else {
                    quote! {
                        if visitor.is_some() {
                            #verify_with(&unpacked).map_err(#crate_name::error::UnpackError::from_packable)?;
                        }
                    }
                }
            }
            None => quote!(),
        };

        Self {
            pattern: quote!(#path { #(#fields_pattern_ident: #fields_ident),* }),
            pack: quote! {
                #(<#fields_type as #crate_name::Packable>::pack(#fields_ident, packer)?;) *
                Ok(())
            },
            unpack: quote! {
                #(
                    let #fields_ident = <#fields_type as #crate_name::Packable>::unpack(unpacker, visitor.map(Borrow::<<#fields_type as #crate_name::Packable>::UnpackVisitor>::borrow)).map_packable_err(#fields_unpack_error_with).coerce()?;
                    #fields_verification
                )*

                let unpacked = #path {
                    #(#fields_pattern_ident: #fields_ident,)*
                };

                #verify_with

                Ok(unpacked)
            },
        }
    }
}