memtable-macros 0.2.0

Macro library that provides ability to derive typed tables and generate tables compile-time.
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

use super::{utils, TableColumn};
use darling::ast::Style;
use syn::{parse_quote, Expr, Generics, Ident, ItemFn, Path};

pub struct Args<'a> {
    pub root: &'a Path,
    pub generics: &'a Generics,
    pub columns: &'a [&'a TableColumn],
    pub origin_struct_name: &'a Ident,
    pub style: Style,
}

pub fn make(args: Args) -> ItemFn {
    let Args {
        root,
        generics,
        columns,
        origin_struct_name,
        style,
    } = args;

    let (_, ty_generics, _) = generics.split_for_impl();
    let fields = utils::make_field_tokens(columns);
    let utils::VariantMethodIdents { into_variant, .. } =
        utils::make_variant_method_idents(style, columns);
    let bug_msg = utils::bug_str();

    let create_struct_expr: Expr = match style {
        Style::Tuple => parse_quote! {
            #origin_struct_name(#(
                ::core::iter::Iterator::next(&mut iter)
                    .expect(#bug_msg)
                    .#into_variant()
                    .expect(#bug_msg)
            ),*)
        },
        Style::Struct => parse_quote! {
            #origin_struct_name {#(
                #fields: ::core::iter::Iterator::next(&mut iter)
                    .expect(#bug_msg)
                    .#into_variant()
                    .expect(#bug_msg)
            ),*}
        },
        Style::Unit => unreachable!(),
    };

    parse_quote! {
        /// Removes the row at the specified position, shifting up all rows after it
        pub fn remove_row(
            &mut self,
            row: ::core::primitive::usize,
        ) -> ::core::option::Option<#origin_struct_name #ty_generics> {
            #root::Table::remove_row(&mut self.0, row).and_then(|row| {
                // Build an iterator so we can consume the row values
                let mut iter = ::core::iter::IntoIterator::into_iter(row);

                // NOTE: Because we don't allow access to the underlying table
                //       at the level where the cell enum can be changed to
                //       another type, this should NEVER fail. We want to rely
                //       on that guarantee as it would be considered corrupt
                //       if the data is removed (by single cell) or changes
                //       types underneath.
                ::core::option::Option::Some(#create_struct_expr)
            })
        }
    }
}