purveyor 0.1.4

Macros to generate server and client code from a simple protocol definition
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

pub use paste;

#[macro_export]
macro_rules! protocol {
    (
        type Error = $err:ident;

        $(
            $module:ident {
                $(
                    fn $handler:ident ( $($arg:ident : $type:ty ),* ) -> $ret:ty;
                )*
            }
        )*
    ) => {
        purveyor::paste::paste! {
            #[derive(Debug, Clone, borsh::BorshSerialize, borsh::BorshDeserialize)]
            pub enum Request {
                $(
                    $([<$module:camel $handler:camel>]( $($type),* )),*
                ),*
            }

            #[derive(Debug, Clone, borsh::BorshSerialize, borsh::BorshDeserialize)]
            pub enum Response {
                $(
                    $([<$module:camel $handler:camel>]( $ret )),*
                ),*
            }

            $(
                #[allow(async_fn_in_trait)]
                pub trait [<$module:camel Server>] {
                    type Error: Into<$err>;

                    $(async fn $handler(&self, $($arg: $type),* ) -> Result<$ret, Self::Error>;)*
                }
            )*

            pub trait Server: $([<$module:camel Server>]<Error = <Self as Server>::Error>+)* {
                type Error: Into<$err>;

                #[allow(async_fn_in_trait)]
                async fn receive(&self, request: Request) -> Result<Response, <Self as Server>::Error> {
                    Ok(match request {
                        $(
                            $(Request::[<$module:camel $handler:camel>]($($arg),*) => {
                                Response::[<$module:camel $handler:camel>](
                                [<$module:camel Server>]::$handler(
                                    self,
                                    $($arg),*
                                ).await?)
                            }),*
                        ),*
                    })
                }
            }

            #[allow(async_fn_in_trait)]
            pub trait Transport {
                async fn send(&self, request: Request) -> Result<Response, $err>;
            }

            $(
                pub struct [<$module:camel Client>]<'a, T: Transport> {
                    transport: &'a T,
                }

                impl<'a, T: Transport> [<$module:camel Client>]<'a, T> {
                    $(async fn $handler(&self, $($arg: $type),* ) -> Result<$ret, $err> {
                        if let Response::[<$module:camel $handler:camel>](out) = self.transport.send( Request::[<$module:camel $handler:camel>]( $($arg),* ) ).await? {
                            Ok(out)
                        } else {
                            unreachable!()
                        }
                    })*
                }
            )*

            pub struct Client<T: Transport> {
                transport: T,
            }

            impl<'a, T: Transport> Client<T> {
                pub fn new(transport: T) -> Self {
                    Self {
                        transport,
                    }
                }

                $(pub fn [<$module:snake>](&'a self) -> [<$module:camel Client>]<'a, T> {
                    [<$module:camel Client>] {
                        transport: &self.transport,
                    }
                })*
            }
        }
    };
}