ftswarm_macros 0.2.0

Procedural macros for the ftswarm crate
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

use proc_macro::{TokenStream};
use proc_macro2::Ident;
use quote::quote;
use syn::{LitBool, Token};

struct ActorSwarmObject {
    typename: Ident,
    _comma: Token![,],
    digital: bool,
}

impl syn::parse::Parse for ActorSwarmObject {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let typename: Ident = input.parse()?;
        let _comma: Token![,] = input.parse()?;
        let normally_open: LitBool = input.parse()?;

        Ok(ActorSwarmObject {
            typename,
            _comma,
            digital: normally_open.value,
        })
    }
}

pub fn actor_swarm_object_impl(input: TokenStream) -> TokenStream {
    let ActorSwarmObject { typename, _comma: _, digital } = syn::parse_macro_input!(input as ActorSwarmObject);

    let impl_block = if digital {
        quote! {
            impl #typename {
                pub async fn set(&self, value: ValueState) -> Result<(), String> {
                    self.run_command(
                        RpcFunction::SetSpeed,
                        vec![Argument::Int(value.into())]
                    ).await.map(|_| ())
                }
            }
        }
    } else {
        quote! {
            impl #typename {
                pub async fn set(&self, value: i32) -> Result<(), String> {
                    let value = value.max(-255).min(255);

                    self.run_command(
                        RpcFunction::SetSpeed,
                        vec![Argument::Int(value as i64)]
                    ).await.map(|_| ())
                }
            }
        }
    };

    return quote! {
        #[derive(Clone, Updateable)]
        pub struct #typename {
            pub name: String,
            swarm: FtSwarm
        }

        impl_swarm_object!(#typename, ());

        impl NewSwarmObject<()> for #typename {
            default_new_swarm_object_impls!();

            fn new(name: &str, swarm: FtSwarm, _: ()) -> Box<Self> {
                Box::new(#typename {
                    name: name.to_string(),
                    swarm
                })
            }

            fn init(&mut self) -> impl Future<Output = ()> {
                async move {
                    self.run_command(
                        RpcFunction::SetActorType,
                        vec![Argument::ActorType(ActorType::#typename)]
                    ).await.unwrap();
                }
            }
        }

        #impl_block
    }.into()
}