dos-uid-derive 5.0.1

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

use quote::quote;
use syn::{
    parse::{Parse, ParseStream},
    punctuated::Punctuated,
    DeriveInput, Ident, LitInt, Token, Type,
};

use crate::{Expand, Expanded};

/// ALIAS attributes
///
/// #[alias(name = <type>, client = <type>, traits = <Write,|Read,|Size>)]
#[derive(Debug, Clone, Default)]
pub struct Attributes {
    name: Option<Type>,
    client: Option<Type>,
    traits: Vec<Ident>,
    port: Option<syn::LitInt>,
    pub skip_uid: bool,
}

impl Parse for Attributes {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut alias_attrs: Attributes = Default::default();
        while let Ok(key) = input.parse::<Ident>() {
            let _ = input.parse::<Token!(=)>()?;
            if key == "name" {
                alias_attrs.name = input.parse::<Type>().ok();
            }
            if key == "client" {
                alias_attrs.client = input.parse::<Type>().ok();
            }
            if key == "traits" {
                alias_attrs.traits =
                    Punctuated::<Ident, Token![,]>::parse_separated_nonempty(input)?
                        .into_iter()
                        .collect();
            }
            if key == "port" {
                let _ = input.parse::<LitInt>().map(|port| {
                    alias_attrs.port = Some(port);
                });
            }
            let Ok(_) = input.parse::<Token!(,)>() else {
                return Ok(alias_attrs);
            };
        }
        Ok(alias_attrs)
    }
}

impl Expand for Attributes {
    fn expand(&self, input: &DeriveInput) -> Expanded {
        let Self {
            name,
            client,
            traits,
            skip_uid,
            port,
        } = self;
        let DeriveInput {
            ident, generics, ..
        } = input;
        let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
        let uid = if *skip_uid {
            quote!()
        } else {
            if let Some(port) = port {
                quote! {
                    impl #impl_generics ::interface::UniqueIdentifier for #ident #ty_generics #where_clause {
                        const PORT: u16 = #port;
                        type DataType = <#name as ::interface::UniqueIdentifier>::DataType;
                    }
                }
            } else {
                quote! {
                    impl #impl_generics ::interface::UniqueIdentifier for #ident #ty_generics #where_clause {
                        const PORT: u16 = <#name as ::interface::UniqueIdentifier>::PORT;
                        type DataType = <#name as ::interface::UniqueIdentifier>::DataType;
                    }
                }
            }
        };
        let mut write = quote!();
        let mut read = quote!();
        let mut size = quote!();
        for a_trait in traits {
            if a_trait.to_string().as_str().to_lowercase() == "write" {
                write = quote! {
                    impl #impl_generics ::interface::Write<#ident #ty_generics> for #client {
                        #[inline]
                        fn write(&mut self) -> Option<::interface::Data<#ident #ty_generics>> {
                            <Self as ::interface::Write<#name>>::write(self).map(|data| data.transmute())
                        }
                    }
                };
            }
            if a_trait.to_string().as_str().to_lowercase() == "read" {
                read = quote! {
                    impl #impl_generics ::interface::Read<#ident #ty_generics> for #client {
                        #[inline]
                        fn read(&mut self,data: ::interface::Data<#ident #ty_generics>) {
                            <Self as ::interface::Read<#name>>::read(self,data.transmute());
                        }
                    }
                };
            }
            if a_trait.to_string().as_str().to_lowercase() == "size" {
                size = quote! {
                    impl #impl_generics ::interface::Size<#ident #ty_generics> for #client {
                        #[inline]
                        fn len(&self) -> usize {
                            <Self as ::interface::Size<#name>>::len(self)
                        }
                    }
                };
            }
        }
        quote! {
            #uid
            #write
            #read
            #size
        }
    }
}