flapigen 0.9.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

# flapigen [![Build Status](https://github.com/Dushistov/flapigen-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/Dushistov/flapigen-rs/actions/workflows/ci.yml) [![License](https://img.shields.io/badge/license-BSD-green.svg)](https://github.com/Dushistov/flapigen-rs/blob/master/LICENSE) [![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/flapigen)



Tool for connecting programs or libraries written in Rust with other languages.
Foreign language api generator - flapigen. Former name rust_swig was changed to not confuse
with [swig](https://github.com/swig/swig).
Currently implemented support for `C++` and `Java`, but you can write support
for any language of your choice. For an instruction how to integrate flapigen with your
project look [here](https://dushistov.github.io/flapigen-rs/getting-started.html).

Suppose you have the following Rust code:

```rust
struct Foo {
    data: i32
}

impl Foo {
    fn new(val: i32) -> Foo {
        Foo{data: val}
    }

    fn f(&self, a: i32, b: i32) -> i32 {
        self.data + a + b
    }

    fn set_field(&mut self, v: i32) {
        self.data = v;
    }
}

fn f2(a: i32) -> i32 {
    a * 2
}
```

and you want to write in Java something like this:

```Java
Foo foo = new Foo(5);
int res = foo.f(1, 2);
assert res == 8;
```
or in C++ something like this:

```C++
Foo foo(5);
int res = foo.f(1, 2);
assert(res == 8);
```

In order to implement it flapigen suggests the following functionality,
in Rust project you write (in Rust language):

```rust
foreign_class!(class Foo {
    self_type Foo;
    constructor Foo::new(_: i32) -> Foo;
    fn Foo::set_field(&mut self, _: i32);
    fn Foo::f(&self, _: i32, _: i32) -> i32;
    fn f2(_: i32) -> i32;
});
```

and that's all, as a result flapigen generates JNI wrappers for Rust functions
and Java code to call these JNI functions
or generates C compatible wrappers in case of C++ and
C++ code to call these C functions.

If you want the interface file (the file containing `foreign_class!` and so on)
to be automatically generated for you, checkout [rifgen](https://crates.io/crates/rifgen).

## Users Guide

[📚 Read the `flapigen` users guide here! 📚](https://dushistov.github.io/flapigen-rs/)