redb_model_derive 0.12.0

Redb model derive macro
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

//! `EntryArgs` field definitions for `uuid::Uuid`.
use proc_macro2::Literal;
use punctuated::Punctuated;
use quote::format_ident;
use syn::*;
use token::{Dot, Paren};

use super::external::ExternalType;
use crate::args::ty::RedbType;
use crate::args::EntryArgs;

/// `uuid::Uuid` marker type.
pub(super) struct UuidType;

impl ExternalType for UuidType {
    const IDENT_MATCH: &'static str = "Uuid";

    fn redb_ty(entry: &EntryArgs) -> RedbType {
        // `&'static [u8; 16]`

        let mut segments = Punctuated::new();
        segments.push(PathSegment {
            ident: format_ident!("u8"),
            arguments: syn::PathArguments::None,
        });

        let ty = Type::Reference(TypeReference {
            and_token: Token![&](entry.ident().span()),
            lifetime: Some(Lifetime {
                apostrophe: entry.ident().span(),
                ident: format_ident!("static"),
            }),
            mutability: None,
            elem: Box::new(Type::Array(TypeArray {
                bracket_token: token::Bracket(entry.ident().span()),
                elem: Box::new(Type::Path(TypePath {
                    qself: None,
                    path: Path {
                        leading_colon: None,
                        segments,
                    },
                })),
                semi_token: Token![;](entry.ident().span()),
                len: Expr::Lit(ExprLit {
                    attrs: Vec::new(),
                    lit: Lit::new(Literal::usize_suffixed(16)),
                }),
            })),
        });

        RedbType::new(ty)
    }

    fn from_op(entry: &EntryArgs) -> Expr {
        // `uuid::Uuid::from_bytes(*field)`

        let mut path = Path {
            leading_colon: None,
            segments: Punctuated::new(),
        };
        path.segments.push(PathSegment {
            ident: format_ident!("uuid"),
            arguments: syn::PathArguments::None,
        });
        path.segments.push(PathSegment {
            ident: format_ident!("Uuid"),
            arguments: syn::PathArguments::None,
        });
        path.segments.push(PathSegment {
            ident: format_ident!("from_bytes"),
            arguments: syn::PathArguments::None,
        });

        let mut args = Punctuated::new();
        let mut arg = Punctuated::new();
        arg.push(PathSegment {
            ident: entry.ident().clone(),
            arguments: syn::PathArguments::None,
        });
        args.push(Expr::Unary(ExprUnary {
            attrs: Vec::new(),
            op: syn::UnOp::Deref(Token![*](entry.ident().span())),
            expr: Box::new(Expr::Path(ExprPath {
                attrs: Vec::new(),
                qself: None,
                path: Path {
                    leading_colon: None,
                    segments: arg,
                },
            })),
        }));

        Expr::Call(ExprCall {
            attrs: Vec::new(),
            func: Box::new(Expr::Path(ExprPath {
                attrs: Vec::new(),
                qself: None,
                path,
            })),
            paren_token: Paren(entry.ident().span()),
            args,
        })
    }

    fn into_op(entry: &EntryArgs) -> Expr {
        // `field.as_bytes()`

        Expr::MethodCall(ExprMethodCall {
            attrs: vec![],
            receiver: Box::new(entry.ident_expr()),
            dot_token: Dot(entry.ident().span()),
            method: format_ident!("as_bytes"),
            turbofish: None,
            paren_token: Default::default(),
            args: Punctuated::new(),
        })
    }
}