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
133

#![recursion_limit="256"]

extern crate proc_macro;
extern crate proc_macro2;
extern crate futures;
extern crate syn;
extern crate heck;

#[macro_use]
extern crate quote;

use proc_macro::TokenStream;
use proc_macro2::{Ident};
use syn::DeriveInput;
use heck::SnakeCase;
use quote::ToTokens;


#[proc_macro_derive(Worker)]
pub fn derive_worker(input: TokenStream) -> TokenStream {

    let ast: DeriveInput = syn::parse(input).unwrap();
    let dnum = match ast.data {
        syn::Data::Enum(v) => v,
        _ => panic!("must be enum"),
    };

    let name            = &ast.ident;
    let mod_name        = Ident::new(&format!("{}", name).to_snake_case(), name.span());

    let mut call_fns    = Vec::new();
    let mut trait_fns   = Vec::new();
    let mut matches     = Vec::new();

    for variant in dnum.variants {
        let mut args = Vec::new();
        let mut argnames  = Vec::new();
        match variant.fields {
            syn::Fields::Named(fields) => {
                for field in fields.named {
                    let name = field.ident.unwrap();
                    let typ  = field.ty.into_token_stream();

                    args.push(quote!{
                        #name : #typ
                    });
                    argnames.push(name);
                }
            },
            syn::Fields::Unnamed(_) => {
                panic!("cannot use unnamed args");
            },
            syn::Fields::Unit => (),
        };


        let varname = variant.ident;
        let fname = Ident::new(&format!("{}", varname).to_snake_case(), varname.span());

        let args_ = args.clone();
        trait_fns.push(quote! {
            fn #fname(self, #(#args_),*) -> Box<Future<Item=Option<Self>,Error=()> + Sync + Send>;
        });

        let name_       = name.clone();
        let varname_    = varname.clone();
        let argnames_   = argnames.clone();
        call_fns.push(if argnames.len() > 0 {quote! {
            pub fn #fname(&mut self, #(#args),*) -> impl futures::Future<Item=(), Error=futures::sync::mpsc::SendError<#name>> {
                self.tx.clone().send(#name_::#varname_{#(#argnames_),*}).and_then(|_|Ok(()))
            }
        }} else { quote! {
            pub fn #fname(&mut self, #(#args),*) -> impl futures::Future<Item=(), Error=futures::sync::mpsc::SendError<#name>> {
                self.tx.clone().send(#name_::#varname_).and_then(|_|Ok(()))
            }
        }});

        let argnames_ = argnames.clone();
        matches.push( if argnames.len() > 0 { quote! {
            #name::#varname { #(#argnames),* } => t.#fname(#(#argnames_),*)
        }} else { quote! {
            #name::#varname => t.#fname()
        }});
    }

    let expanded = quote! {mod #mod_name {
        use super::#name;
        use futures;
        use futures::Stream;
        use futures::Sink;
        use futures::Future;

        #[derive(Clone)]
        pub struct Handle {
            tx: futures::sync::mpsc::Sender<#name>,
        }
        impl Handle {
            #(#call_fns)*
        }

        pub trait Worker
            where Self: Sized,
        {
            #(#trait_fns)*

            fn canceled(self) {}
        }

        pub fn spawn<T: Worker> (buffer: usize, t: T) -> (impl Future<Item=(), Error=()>, Handle) {
            let (tx,rx) = futures::sync::mpsc::channel(buffer);


            let ft = rx.fold(t, |t, m|{
                match m {
                    #(#matches),*
                }.and_then(|v|v.ok_or(()))
            }).and_then(|t|{
                t.canceled();
                Ok(())
            });

            (
                ft,
                Handle {
                    tx,
                },
            )
        }
    }};

    // Hand the output tokens back to the compiler.
    expanded.into()
}