line-protocol-derive 0.1.0

Implementation of Influx's line protocol (derive macros)
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
120
121
122
123
124
125
126
127
128
129
130
131
132

use proc_macro2::Literal;
use quote::{ToTokens, format_ident, quote};

pub enum GeneratorMember {
    Named(String),
    Unnamed(usize),
}

impl ToTokens for GeneratorMember {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(match self {
            GeneratorMember::Named(s) => {
                let s = format_ident!("{}", s);
                quote!(self.#s)
            }
            GeneratorMember::Unnamed(n) => {
                let n = Literal::usize_unsuffixed(*n);
                quote!(self.#n)
            }
        })
    }
}

pub struct GeneratorMeasurement {
    pub name: String,
}

impl ToTokens for GeneratorMeasurement {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let name = &self.name;

        tokens.extend(quote!(
            .measurement(#name)
        ))
    }
}

pub struct GeneratorTag {
    pub name: String,
    pub member: GeneratorMember,
}

impl ToTokens for GeneratorTag {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let name = &self.name;
        let member = &self.member;

        tokens.extend(quote!(
            .tag(#name, &#member)
        ))
    }
}

pub struct GeneratorField {
    pub name: String,
    pub member: GeneratorMember,
}

impl ToTokens for GeneratorField {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let name = &self.name;
        let member = &self.member;

        tokens.extend(quote!(
            .field(#name, &#member)
        ))
    }
}

pub struct GeneratorTimestamp {
    pub member: GeneratorMember,
}

impl ToTokens for GeneratorTimestamp {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let member = &self.member;

        tokens.extend(quote!(
            .timestamp(&#member)
        ))
    }
}

pub struct GeneratorImpl {
    pub target: String,
    pub measurement: GeneratorMeasurement,
    pub tags: Vec<GeneratorTag>,
    pub fields: Vec<GeneratorField>,
    pub timestamp: Option<GeneratorTimestamp>,
}

impl ToTokens for GeneratorImpl {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let target = format_ident!("{}", &self.target);
        let measurement = &self.measurement;
        let tags = &self.tags;
        let fields = &self.fields;

        let builder_tokens = if let Some(timestamp) = &self.timestamp {
            quote!(
                line_protocol::LineProtocolBuilder::default()
                    #measurement
                    #(#tags)*
                    #(#fields)*
                    #timestamp
                    .build()
            )
        } else {
            quote!(
                line_protocol::LineProtocolBuilder::default()
                    #measurement
                    #(#tags)*
                    #(#fields)*
                    .build()
            )
        };

        tokens.extend(quote!(
            impl LineProtocol for #target {
                fn to_line_protocol(&self) -> Option<String> {
                    #builder_tokens
                }
            }
        ));
    }
}

impl GeneratorImpl {
    pub fn tokenstream(&self) -> proc_macro2::TokenStream {
        quote!(#self)
    }
}