basalt-derive 0.2.1

Derive macros for Encode/Decode/EncodedSize traits
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Shared code generation helpers for field attribute handling.
//!
//! These functions generate `TokenStream` fragments for a single field
//! based on its `FieldAttr`. They are used by both struct and enum
//! codegen paths, eliminating the duplication between the two.
//!
//! The `val` parameter is the expression that accesses the field value:
//! - For structs: `self.field_name`
//! - For enum variants: `field_name` (destructured binding)

use proc_macro2::TokenStream;
use quote::quote;

use crate::attrs::FieldAttr;

/// Generates the encode expression for a single field.
pub fn field_encode(val: &TokenStream, attr: &FieldAttr) -> TokenStream {
    if attr.varint {
        quote! { basalt_types::Encode::encode(&basalt_types::VarInt(*#val), buf)?; }
    } else if attr.optional {
        quote! {
            match #val {
                Some(value) => {
                    basalt_types::Encode::encode(&true, buf)?;
                    basalt_types::Encode::encode(value, buf)?;
                }
                None => {
                    basalt_types::Encode::encode(&false, buf)?;
                }
            }
        }
    } else if attr.length_varint && attr.element_varint {
        quote! {
            basalt_types::Encode::encode(&basalt_types::VarInt((#val).len() as i32), buf)?;
            for item in (#val) {
                basalt_types::Encode::encode(&basalt_types::VarInt(*item), buf)?;
            }
        }
    } else if attr.length_varint {
        quote! {
            basalt_types::Encode::encode(&basalt_types::VarInt((#val).len() as i32), buf)?;
            for item in (#val) {
                basalt_types::Encode::encode(item, buf)?;
            }
        }
    } else if attr.rest {
        quote! { buf.extend_from_slice(#val); }
    } else {
        quote! { basalt_types::Encode::encode(#val, buf)?; }
    }
}

/// Generates the decode expression for a single field.
///
/// `field_name` is the local variable name to bind the decoded value.
/// `field_type` is the type (only used for the default decode path).
pub fn field_decode(
    field_name: &syn::Ident,
    field_type: &syn::Type,
    attr: &FieldAttr,
) -> TokenStream {
    if attr.varint {
        quote! {
            let #field_name = {
                let var: basalt_types::VarInt = basalt_types::Decode::decode(buf)?;
                var.0
            };
        }
    } else if attr.optional {
        quote! {
            let #field_name = {
                let present: bool = basalt_types::Decode::decode(buf)?;
                if present {
                    Some(basalt_types::Decode::decode(buf)?)
                } else {
                    None
                }
            };
        }
    } else if attr.length_varint && attr.element_varint {
        quote! {
            let #field_name = {
                let len: basalt_types::VarInt = basalt_types::Decode::decode(buf)?;
                let len = len.0 as usize;
                // Cap allocation to remaining buffer to prevent OOM
                let mut items = Vec::with_capacity(len.min(buf.len()));
                for _ in 0..len {
                    let var: basalt_types::VarInt = basalt_types::Decode::decode(buf)?;
                    items.push(var.0);
                }
                items
            };
        }
    } else if attr.length_varint {
        quote! {
            let #field_name = {
                let len: basalt_types::VarInt = basalt_types::Decode::decode(buf)?;
                let len = len.0 as usize;
                // Cap allocation to remaining buffer to prevent OOM
                let mut items = Vec::with_capacity(len.min(buf.len()));
                for _ in 0..len {
                    items.push(basalt_types::Decode::decode(buf)?);
                }
                items
            };
        }
    } else if attr.rest {
        quote! {
            let #field_name = {
                let rest = buf.to_vec();
                *buf = &buf[buf.len()..];
                rest
            };
        }
    } else {
        quote! {
            let #field_name: #field_type = basalt_types::Decode::decode(buf)?;
        }
    }
}

/// Generates the encoded_size expression for a single field.
pub fn field_size(val: &TokenStream, attr: &FieldAttr) -> TokenStream {
    if attr.varint {
        quote! { basalt_types::EncodedSize::encoded_size(&basalt_types::VarInt(*#val)) }
    } else if attr.optional {
        quote! {
            1 + match #val {
                Some(value) => basalt_types::EncodedSize::encoded_size(value),
                None => 0,
            }
        }
    } else if attr.length_varint && attr.element_varint {
        quote! {
            basalt_types::EncodedSize::encoded_size(&basalt_types::VarInt((#val).len() as i32))
            + (#val).iter().map(|item| basalt_types::EncodedSize::encoded_size(&basalt_types::VarInt(*item))).sum::<usize>()
        }
    } else if attr.length_varint {
        quote! {
            basalt_types::EncodedSize::encoded_size(&basalt_types::VarInt((#val).len() as i32))
            + (#val).iter().map(|item| basalt_types::EncodedSize::encoded_size(item)).sum::<usize>()
        }
    } else if attr.rest {
        quote! { (#val).len() }
    } else {
        quote! { basalt_types::EncodedSize::encoded_size(#val) }
    }
}