dbstruct-derive 0.4.0

Build a typed database by defining a struct
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

use syn::parse_quote;

use crate::model::backend::Backend;
use crate::model::{Field, Model};

pub struct Struct {
    pub ident: syn::Ident,
    pub vis: syn::Visibility,
    /// Extra variables such as the current length
    /// of the vector wrapper
    pub member_vars: Vec<syn::Field>,
    pub db: syn::Field,
}

pub fn vec_len_ident(ident: &syn::Ident) -> syn::Ident {
    let name = format!("{}_len", ident);
    syn::Ident::new(&name, proc_macro2::Span::call_site())
}

fn vec_len_field(field: &Field) -> syn::Field {
    syn::Field {
        attrs: Vec::new(),
        vis: syn::Visibility::Inherited,
        ident: Some(vec_len_ident(&field.ident)),
        colon_token: None,
        ty: parse_quote!(std::sync::Arc<std::sync::atomic::AtomicUsize>),
        mutability: syn::FieldMutability::None,
    }
}

pub fn deque_head_ident(ident: &syn::Ident) -> syn::Ident {
    let name = format!("{}_head", ident);
    syn::Ident::new(&name, proc_macro2::Span::call_site())
}

pub fn deque_tail_ident(ident: &syn::Ident) -> syn::Ident {
    let name = format!("{}_tail", ident);
    syn::Ident::new(&name, proc_macro2::Span::call_site())
}

pub fn no_syn_phantom_ident() -> syn::Ident {
    syn::Ident::new("prevent_sync", proc_macro2::Span::call_site())
}

fn deque_head_field(field: &Field) -> syn::Field {
    syn::Field {
        attrs: Vec::new(),
        vis: syn::Visibility::Inherited,
        ident: Some(deque_head_ident(&field.ident)),
        colon_token: None,
        ty: parse_quote!(::std::sync::Arc<::std::sync::atomic::AtomicU64>),
        mutability: syn::FieldMutability::None,
    }
}

fn deque_tail_field(field: &Field) -> syn::Field {
    syn::Field {
        attrs: Vec::new(),
        vis: syn::Visibility::Inherited,
        ident: Some(deque_tail_ident(&field.ident)),
        colon_token: None,
        ty: parse_quote!(::std::sync::Arc<::std::sync::atomic::AtomicU64>),
        mutability: syn::FieldMutability::None,
    }
}

fn no_sync_phantom() -> syn::Field {
    syn::Field {
        attrs: Vec::new(),
        vis: syn::Visibility::Inherited,
        ident: Some(no_syn_phantom_ident()),
        colon_token: None,
        ty: parse_quote!(::std::marker::PhantomData<::std::cell::Cell<()>>),
        mutability: syn::FieldMutability::None,
    }
}

impl From<&Model> for Struct {
    fn from(model: &Model) -> Self {
        use crate::model::Wrapper as W;

        let ty = match model.backend {
            Backend::Sled => parse_quote!(::dbstruct::sled::Tree),
            Backend::HashMap => parse_quote!(::dbstruct::stores::HashMap),
            Backend::BTreeMap => parse_quote!(::dbstruct::stores::BTreeMap),
            Backend::Trait { .. } => parse_quote!(DS),
            #[cfg(test)]
            Backend::Test => unreachable!("Test backend is not supported for codegen"),
        };

        let db = syn::Field {
            attrs: Vec::new(),
            vis: syn::Visibility::Inherited,
            ident: Some(syn::Ident::new("ds", proc_macro2::Span::call_site())),
            colon_token: None,
            ty,
            mutability: syn::FieldMutability::None,
        };

        let mut member_vars: Vec<_> = model
            .fields
            .iter()
            .flat_map(|field| match &field.wrapper {
                W::Vec { .. } => [vec_len_field(&field)].to_vec(),
                W::VecDeque { .. } => [deque_head_field(&field), deque_tail_field(&field)].to_vec(),
                _ => Vec::new(),
            })
            .collect();

        member_vars.push(no_sync_phantom());

        Struct {
            ident: model.ident.clone(),
            vis: model.vis.clone(),
            member_vars,
            db,
        }
    }
}