reproto-backend-java 0.3.10

Rethinking Protocol Generators
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

/// Code generator for the given path.

use backend::errors::Result;
use listeners::{ClassAdded, EnumAdded, InterfaceAdded, ServiceAdded, TupleAdded};
use std::path::Path;
use std::rc::Rc;

pub trait Codegen {
    /// Build the given piece of code in the given path.
    fn generate(&self, out_path: &Path) -> Result<()>;
}

impl<T> Codegen for Rc<T>
where
    T: Codegen,
{
    fn generate(&self, out_path: &Path) -> Result<()> {
        self.as_ref().generate(out_path)
    }
}

/// Generate service-based code.
pub trait ServiceCodegen {
    fn generate(&self, e: ServiceAdded) -> Result<()>;
}

impl<T> ServiceCodegen for Rc<T>
where
    T: ServiceCodegen,
{
    fn generate(&self, e: ServiceAdded) -> Result<()> {
        self.as_ref().generate(e)
    }
}

/// Generate class-based code.
pub trait ClassCodegen {
    fn generate(&self, e: ClassAdded) -> Result<()>;
}

impl<T> ClassCodegen for Rc<T>
where
    T: ClassCodegen,
{
    fn generate(&self, e: ClassAdded) -> Result<()> {
        self.as_ref().generate(e)
    }
}

/// Generate tuple-based code.
pub trait TupleCodegen {
    fn generate(&self, e: TupleAdded) -> Result<()>;
}

impl<T> TupleCodegen for Rc<T>
where
    T: TupleCodegen,
{
    fn generate(&self, e: TupleAdded) -> Result<()> {
        self.as_ref().generate(e)
    }
}

/// Generate interface-based code.
pub trait InterfaceCodegen {
    fn generate(&self, e: InterfaceAdded) -> Result<()>;
}

impl<T> InterfaceCodegen for Rc<T>
where
    T: InterfaceCodegen,
{
    fn generate(&self, e: InterfaceAdded) -> Result<()> {
        self.as_ref().generate(e)
    }
}

/// Generate enum-based code.
pub trait EnumCodegen {
    fn generate(&self, e: EnumAdded) -> Result<()>;
}

impl<T> EnumCodegen for Rc<T>
where
    T: EnumCodegen,
{
    fn generate(&self, e: EnumAdded) -> Result<()> {
        self.as_ref().generate(e)
    }
}