protoc-rust-copra 0.1.1

Code generator works with the copra RPC framework
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

use protobuf::descriptor::ServiceDescriptorProto;
use protobuf::descriptorx::RootScope;
use std::io;

use super::name::*;

pub fn generate_client_stub(
    proto: &ServiceDescriptorProto,
    root: &RootScope,
) -> io::Result<String> {
    let service_name = service_name(proto)?;
    let stub_name = stub_name(proto)?;
    let method_names = method_names(proto)?;
    let wrapper_names = wrapper_names(proto)?;
    let request_types = request_types(proto, root)?;
    let response_types = response_types(proto, root)?;

    let mut gen = String::new();

    gen = gen
        + &format!(
            r"
#[derive(Clone)]
pub struct {}<'a> {{",
            stub_name
        );

    for ((wrap, resp), req) in wrapper_names
        .iter()
        .zip(response_types.iter())
        .zip(request_types.iter())
    {
        gen = gen
            + &format!(
                r"
    {}: ::copra::stub::RpcWrapper<'a,
        ::copra::codec::ProtobufCodec<{}, {}>>,
",
                wrap, resp, req
            );
    }

    gen = gen
        + &format!(
            r"}}

impl<'a> {}<'a> {{
    pub fn new(channel: &'a ::copra::channel::Channel) -> Self {{
        {} {{",
            stub_name, stub_name
        );

    for wrap in wrapper_names.iter() {
        gen = gen
            + &format!(
                r"
            {}: ::copra::stub::RpcWrapper::new(
                ::copra::codec::ProtobufCodec::new(), channel
            ),
",
                wrap
            );
    }

    gen = gen
        + r"        }
    }
";

    for (((method, req), resp), wrap) in method_names
        .iter()
        .zip(request_types.iter())
        .zip(response_types.iter())
        .zip(wrapper_names.iter())
    {
        gen = gen
            + &format!(
                r#"
    pub fn {}(
        &'a self, 
        msg: {},
    ) -> ::copra::stub::StubFuture<
        ::copra::codec::ProtobufCodec<
            {},
            {},
        >,
    > {{
        self.{}
            .call((msg, "{}".to_string(), "{}".to_string()))
    }}
"#,
                method, req, resp, req, wrap, service_name, method
            );
    }

    gen = gen + "}\n";

    Ok(gen)
}