flapigen 0.11.0

Tool for connecting libraries written in Rust with other languages
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

r#"class SomeObserver {
public:
    virtual ~SomeObserver() noexcept {}

    virtual void onStateChanged(int32_t a0, bool a1) const noexcept = 0;

    virtual void onStateChangedWithoutArgs() const noexcept = 0;

    virtual void onStateChangedFoo(Foo foo) const noexcept = 0;

    virtual float getTextSize() const noexcept = 0;
"#;

r#"    static void c_SomeObserver_deref(void *opaque)
    {
        auto p = static_cast<SomeObserver *>(opaque);
        delete p;
    }

    static void c_onStateChanged(int32_t a0, char a1, void *opaque)
    {
        assert(opaque != nullptr);
        auto pi = static_cast<const SomeObserver *>(opaque);

        pi->onStateChanged(a0, (a1 != 0));
    }

    static void c_onStateChangedWithoutArgs(void *opaque)
    {
        assert(opaque != nullptr);
        auto pi = static_cast<const SomeObserver *>(opaque);

        pi->onStateChangedWithoutArgs();
    }

    static void c_onStateChangedFoo(FooOpaque * foo, void *opaque)
    {
        assert(opaque != nullptr);
        auto pi = static_cast<const SomeObserver *>(opaque);

        pi->onStateChangedFoo(Foo(static_cast<FooOpaque *>(foo)));
    }

    static float c_getTextSize(void *opaque)
    {
        assert(opaque != nullptr);
        auto pi = static_cast<const SomeObserver *>(opaque);

        auto ret = pi->getTextSize();
        return ret;
    }"#;

r#"struct C_SomeObserver {
    void *opaque;
    //! call by Rust side when callback not need anymore
    void (*C_SomeObserver_deref)(void *opaque);

    void (*onStateChanged)(int32_t a0, char a1, void *opaque);

    void (*onStateChangedWithoutArgs)(void *opaque);

    void (*onStateChangedFoo)(FooOpaque * foo, void *opaque);

    float (*getTextSize)(void *opaque);

};"#;

"void f1(std::unique_ptr<SomeObserver> cb) noexcept;";

r#"template<bool OWN_DATA>
    inline void ClassWithCallbacksWrapper<OWN_DATA>::f1(std::unique_ptr<SomeObserver> cb) noexcept
    {

        C_SomeObserver tmp = SomeObserver::to_c_interface(std::move(cb));
        const struct C_SomeObserver * const a0 = &tmp;

        ClassWithCallbacks_f1(this->self_, std::move(a0));
    }"#;

"void ClassWithCallbacks_f1(ClassWithCallbacksOpaque * const self, const struct C_SomeObserver * const cb);";