trait-enumizer 0.1.1

Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
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

#![cfg(feature="flume")]

use trait_enumizer::flume_class;

trait MyIface {
    fn foo(&self) -> String;
    fn bar(&self, x: i32) -> i32;
    fn baz(&self, y: String, z: Vec<u8>);
}

struct Implementor {}

impl MyIface for Implementor {
    fn foo(&self) -> String {
        dbg!("foo");
        "qqq".to_owned()
    }

    fn bar(&self, x: i32) -> i32 {
        dbg!("bar", x);
        x * x + 1
    }

    fn baz(&self, y: String, z: Vec<u8>) {
        dbg!("baz", y, z);
    }
}

// Begin of the part which is supposed to be auto-generated

enum MyIfaceEnum {
    Foo { ret: flume_class!(Sender<String>) },
    Bar { x: i32, ret: flume_class!(Sender<i32>) },
    Baz { y: String, z: Vec<u8> },
}

impl MyIfaceEnum {
    fn try_call<I: MyIface>(self, o: &I) -> Result<(), flume_class!(SendError)> {
        match self {
            MyIfaceEnum::Foo { ret } => Ok(flume_class!(send::<String>(ret, o.foo()))?),
            MyIfaceEnum::Bar { x, ret } => Ok(flume_class!(send::<i32>(ret, o.bar(x)))?),
            MyIfaceEnum::Baz { y, z } => Ok(o.baz(y, z)),
        }
    }
}
trait MyIfaceResultified<E> {
    fn try_foo(&self) -> Result<Result<String, flume_class!(RecvError)>, E>;
    fn try_bar(&self, x: i32) -> Result<Result<i32, flume_class!(RecvError)>, E>;
    fn try_baz(&self, y: String, z: Vec<u8>) -> Result<(), E>;
}

struct MyIfaceProxy<E, F>(F)
where
    F: Fn(MyIfaceEnum) -> Result<(), E>;

impl<E, F> MyIfaceResultified<E> for MyIfaceProxy<E, F>
where
    F: Fn(MyIfaceEnum) -> Result<(), E>,
{
    fn try_foo(&self) -> Result<Result<String, flume_class!(RecvError)>, E> {
        let (tx, rx) = flume_class!(create::<String>());
        self.0(MyIfaceEnum::Foo { ret: tx })?;
        Ok(flume_class!(recv::<i32>(rx)))
    }

    fn try_bar(&self, x: i32) -> Result<Result<i32, flume_class!(RecvError)>, E> {
        let (tx, rx) = flume_class!(create::<i32>());
        self.0(MyIfaceEnum::Bar { x, ret: tx })?;
        Ok(flume_class!(recv::<i32>(rx)))
    }

    fn try_baz(&self, y: String, z: Vec<u8>) -> Result<(), E> {
        self.0(MyIfaceEnum::Baz { y, z })
    }
}

impl<E, F> MyIface for MyIfaceProxy<E, F>
where
    F: Fn(MyIfaceEnum) -> Result<(), E>,
    E :  std::fmt::Debug,
    flume_class!(RecvError) : std::fmt::Debug,
{
    fn foo(&self) -> String {
        MyIfaceResultified::try_foo(self).unwrap().unwrap()
    }

    fn bar(&self, x: i32) -> i32 {
        MyIfaceResultified::try_bar(self, x).unwrap().unwrap()
    }

    fn baz(&self, y: String, z: Vec<u8>) {
        MyIfaceResultified::try_baz(self, y, z).unwrap()
    }
}

// End of the part which is supposed to be auto-generated


#[test]
fn simple() {
    let o = Implementor {};
    let p = MyIfaceProxy::<_, _>(move |c| c.try_call(&o));
    dbg!(p.foo());
    dbg!(p.bar(4));
}


#[test]
fn threaded() {
    let (tx,rx) = flume::bounded::<MyIfaceEnum>(1);
    std::thread::spawn(move || {
        let o = Implementor {};
        for msg in rx {
            msg.try_call(&o).unwrap();
        }
    });
    let p = MyIfaceProxy::<_, _>(|c| tx.send(c));
    dbg!(p.foo());
    dbg!(p.bar(4));
}