worktable_macros 0.9.0

Proc-macro companion crate for worktable: the worktable! macro and its derives. Formerly published as worktable_codegen.
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

use crate::common::name_generator::WorktableNameGenerator;
use crate::generators::in_memory::InMemoryGenerator;
use proc_macro2::TokenStream;
use quote::quote;

impl InMemoryGenerator {
    pub fn gen_wrapper_def(&self) -> TokenStream {
        let type_ = self.gen_wrapper_type();
        let impl_ = self.gen_wrapper_impl();
        let storable_impl = self.get_wrapper_storable_impl();
        let archived_wrapper_impl = self.get_archived_wrapper_impl();

        quote! {
            #type_
            #impl_
            #storable_impl
            #archived_wrapper_impl
        }
    }

    fn gen_wrapper_type(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let row_ident = name_generator.get_row_type_ident();
        let wrapper_ident = name_generator.get_wrapper_type_ident();

        quote! {
            #[derive(rkyv::Archive, Debug, rkyv::Deserialize, rkyv::Serialize)]
            #[repr(C)]
            pub struct #wrapper_ident {
                inner: #row_ident,
                is_ghosted: bool,
                is_deleted: bool,
                is_in_vacuum_process: bool,
            }
        }
    }

    pub fn gen_wrapper_impl(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let wrapper_ident = name_generator.get_wrapper_type_ident();
        let row_ident = name_generator.get_row_type_ident();

        quote! {

            impl RowWrapper<#row_ident> for #wrapper_ident {
                fn get_inner(self) -> #row_ident {
                    self.inner
                }

                fn is_ghosted(&self) -> bool {
                    self.is_ghosted
                }

                fn is_vacuumed(&self) -> bool {
                    self.is_in_vacuum_process
                }

                fn is_deleted(&self) -> bool {
                    self.is_deleted
                }

                fn from_inner(inner: #row_ident) -> Self {
                    Self {
                        inner,
                        is_ghosted: true,
                        is_deleted: false,
                        is_in_vacuum_process: false,
                    }
                }
            }
        }
    }

    fn get_wrapper_storable_impl(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let row_ident = name_generator.get_row_type_ident();
        let wrapper_ident = name_generator.get_wrapper_type_ident();

        quote! {
            impl StorableRow for #row_ident {
                type WrappedRow = #wrapper_ident;
            }
        }
    }

    fn get_archived_wrapper_impl(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let row_ident = name_generator.get_archived_wrapper_type_ident();

        quote! {
            impl ArchivedRowWrapper for #row_ident {
                fn unghost(&mut self) {
                    self.is_ghosted = false;
                }
                fn set_in_vacuum_process(&mut self) {
                    self.is_in_vacuum_process = true;
                }
                fn delete(&mut self) {
                    self.is_deleted = true;
                }
                fn is_deleted(&self) -> bool {
                    self.is_deleted
                }
            }
        }
    }
}