data_bucket_derive 0.3.17

DataBucket is container for WorkTable
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

use proc_macro2::TokenStream;
use quote::quote;
use syn::{Fields, ItemEnum};

pub struct EnumGenerator {
    pub enum_def: ItemEnum,
}

impl EnumGenerator {
    pub fn gen_impl(&self) -> syn::Result<TokenStream> {
        if !self.enum_def.generics.params.is_empty() {
            return Err(syn::Error::new_spanned(
                &self.enum_def.generics,
                "SizeMeasure does not yet support generic enums",
            ));
        }

        if let Some(variant) = self
            .enum_def
            .variants
            .iter()
            .find(|variant| !matches!(variant.fields, Fields::Unit))
        {
            return Err(syn::Error::new_spanned(
                variant,
                "SizeMeasure supports only fieldless enums; payload sizes may be data-dependent",
            ));
        }

        let enum_ident = &self.enum_def.ident;
        Ok(quote! {
            impl SizeMeasurable for #enum_ident
            where
                #enum_ident: rkyv::Archive,
                <#enum_ident as rkyv::Archive>::Archived: Sized,
            {
                fn aligned_size(&self) -> usize {
                    std::mem::size_of::<<#enum_ident as rkyv::Archive>::Archived>()
                }
            }
        })
    }
}

#[cfg(test)]
mod tests {
    use super::EnumGenerator;
    use syn::parse_quote;

    #[test]
    fn rejects_payload_bearing_enums() {
        let enum_def = parse_quote! {
            enum Payload {
                Empty,
                Value(u64),
            }
        };

        let error = EnumGenerator { enum_def }.gen_impl().unwrap_err();
        assert!(error.to_string().contains("fieldless enums"));
    }
}