dos-uid-derive 3.0.0

dos-actors UniqueIdentifier 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
119
120
121
122
123
124
125
126
127

/*!
# UID

A derive macro that implements the [UniqueIdentifier] trait.

## Examples

Setting the data type and port # to the default values: `Vec<f64>` and `50_000u32`, respectively:
```
use gmt_dos_clients::interface::UID;

#[derive(UID)]
enum Tag {}
```

The data type and port # are set with:
```
use gmt_dos_clients::interface::UID;

struct Q<T>(std::marker::PhantomData<T>);

enum ID {}

#[derive(UID)]
#[uid(data = Q<ID>, port = 9999)]
enum TU {}
```

An alias is a type that implements the [Read], [Write] or [Size] trait of another type that implements the same traits for the same client:
```
use gmt_dos_clients::interface::{UID, Data, Read, Size, Update, Write};
# struct Q<T>(std::marker::PhantomData<T>);
# enum ID {}
# #[derive(UID)]
# #[uid(data = Q<ID>, port = 9999)]
# enum TU {}

struct Client {}
impl Update for Client {}
impl Write<TU> for Client {
    fn write(&mut self) -> Option<Data<TU>> {
        None
    }
}
impl Read<TU> for Client {
    fn read(&mut self, _data: Data<TU>) {}
}
impl Size<TU> for Client {
    fn len(&self) -> usize {
        1234
    }
}

#[derive(UID)]
#[uid(data = Q<ID>, port = 999)]
#[alias(name = TU, client = Client, traits = Write, Read, Size)]
enum TUT {}
```

[UniqueIdentifier]: https://docs.rs/gmt_dos-clients/latest/gmt_dos_clients/interface/trait.UniqueIdentifier.html
[Read]: https://docs.rs/gmt_dos-clients/latest/gmt_dos_clients/interface/trait.Read.html
[Write]: https://docs.rs/gmt_dos-clients/latest/gmt_dos_clients/interface/trait.Write.html
[Size]: https://docs.rs/gmt_dos-clients/latest/gmt_dos_clients/interface/trait.Size.html
*/

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Ident};

#[proc_macro_derive(UID, attributes(uid, alias))]
pub fn derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let ident = input.ident.clone();
    let parser = Parser::new(input).unwrap();
    let expanded = parser.expand(&ident);
    let a = quote! {
        #expanded

    };

    proc_macro::TokenStream::from(a)
}

mod alias;
mod uid;

/// Derive attributes parser
///
/// #[uid(...)]
/// #[alias(...)]
#[derive(Debug, Clone, Default)]
struct Parser {
    pub uid_attrs: uid::Attributes,
    pub alias_attrs: alias::Attributes,
}

impl Parser {
    fn new(input: DeriveInput) -> syn::Result<Parser> {
        let mut parser: Parser = Default::default();
        for attr in input.attrs {
            if attr.path().is_ident("uid") {
                parser.uid_attrs = attr.parse_args()?;
            }
            if attr.path().is_ident("alias") {
                parser.alias_attrs = attr.parse_args()?;
            }
        }
        Ok(parser)
    }
}

type Expanded = proc_macro2::TokenStream;

trait Expand {
    fn expand(&self, ident: &Ident) -> Expanded;
}

impl Expand for Parser {
    fn expand(&self, ident: &Ident) -> Expanded {
        let uid = self.uid_attrs.expand(ident);
        let alias = self.alias_attrs.expand(ident);
        quote! {
            #alias
            #uid
        }
    }
}