ftswarm_macros 0.2.1

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
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

mod digital_swarm_objects;
mod analog_swarm_objects;
mod actor_swarm_objects;

use proc_macro::TokenStream;
use proc_macro2::Ident;
use syn::{DeriveInput, Expr, Token};
use quote::quote;
use syn::parse::Parse;

use digital_swarm_objects::digital_swarm_object_impl;
use crate::actor_swarm_objects::actor_swarm_object_impl;
use crate::analog_swarm_objects::analog_swarm_object_impl;


/// This macro generates an empty `Updateable` trait implementation for a given struct.
#[proc_macro_derive(Updateable)]
pub fn updateable_derive(input: TokenStream) -> TokenStream {
    let ast: DeriveInput = syn::parse(input).unwrap();
    let name = &ast.ident;
    let gen = quote! {
        impl Updateable for #name {
            fn handle_subscription(&mut self, message: &ftswarm_proto::message_parser::rpc::RPCReturnParam) {
                // No-op
            }
        }
    };
    gen.into()
}

/// This macro generates a sane default implementation for the `Updateable` trait.
#[proc_macro]
pub fn impl_int_updateable(src: TokenStream) -> TokenStream {
    let ast: Ident = syn::parse(src).unwrap();
    let gen = quote! {
        impl Updateable for #ast {
            fn handle_subscription(&mut self, message: &RPCReturnParam) {
                if let RPCReturnParam::Int(value) = message {
                    self.value = *value;
                }
            }
        }

        impl #ast {
            pub async fn get_value(&self) -> i32 {
                self.value
            }
        }
    };
    gen.into()
}

#[proc_macro]
pub fn impl_bool_updateable(src: TokenStream) -> TokenStream {
    let ast: Ident = syn::parse(src).unwrap();
    let gen = quote! {
        impl Updateable for #ast {
            fn handle_subscription(&mut self, message: &RPCReturnParam) {
                if let RPCReturnParam::Int(value) = message {
                    self.value = *value == 1;
                }
            }
        }

        impl #ast {
            pub async fn get_value(&self) -> bool {
                self.value
            }
        }
    };
    gen.into()
}

struct TwoInput {
    a: Expr,
    _comma: Token![,],
    b: Expr,
}

impl Parse for TwoInput {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        Ok(Self {
            a: input.parse()?,
            _comma: input.parse()?,
            b: input.parse()?,
        })
    }
}

/// This macro generates a sane default implementation for the `NewSwarmObject` trait.
#[proc_macro]
pub fn impl_swarm_object(src: TokenStream) -> TokenStream {
    // parse a, b
    let TwoInput { a: name, _comma: _, b: param } = syn::parse_macro_input!(src as TwoInput);

    let gen = quote! {
        impl SwarmObject<#param> for #name {
        }
    };
    gen.into()
}

/// When using the `default_new_swarm_object_impls` macro, the `name` and `swarm` fields are automatically implemented.
#[proc_macro]
pub fn default_new_swarm_object_impls(_: TokenStream) -> TokenStream {
    return quote! {
        fn name(&self) -> &str {
            &self.name
        }

        fn swarm(&self) -> &FtSwarm {
            &self.swarm
        }
    }.into();
}

#[proc_macro]
pub fn digital_swarm_object(input: TokenStream) -> TokenStream {
    digital_swarm_object_impl(input)
}

#[proc_macro]
pub fn analog_swarm_object(input: TokenStream) -> TokenStream {
    analog_swarm_object_impl(input)
}

#[proc_macro]
pub fn actor_swarm_object(input: TokenStream) -> TokenStream {
    actor_swarm_object_impl(input)
}