A tool reading an IDL and generating corresponding Rust code.
Usage:
rtps-gen -I <include-dir> data.idl -o output.rsThe IDL types are mapped onto Rust as follows.
If a type-mapping has not been decided, it is marked with 'NA'.
As RTPS is a data-centric framework in contrast to
the the original OO background, the focus is put onto data structures, and ignoring interfaces and structures so far.
| IDL-Type | Rust-Type |
|---|---|
| module | module |
| boolean | bool |
| char/wchar | char |
| octet | u8 |
| string/wstring | std::string::String |
| short | i16 |
| long | i32 |
| long long | i64 |
| unsigned short | u16 |
| unsigned long | u32 |
| unsigned long long | u64 |
| float | f32 |
| double | f64 |
| fixed | NA |
| enum | enum |
| union | enum |
| struct | struct |
| sequence | std::vec::Vec |
| array, eg. 'T a[N]' | native array '[T;N]' |
| interface (non abstract) | NA |
| interface (abstract) | NA |
| constant (not within interface) | const |
| constant (within an interface) | NA |
| exception | std::result::Result |
| Any | NA |
| type declarations nested within interfaces | NA |
| typedef | type |
| pseudo objects | NA |
| readonly attribute | NA |
| readwrite attribute | NA |
| operation | NA |
| IDL | Rust |
|---|---|
sequence<octet> |
std::vec::Vec<u8> |
| IDL | Rust |
|---|---|
| typedef long Foo; | pub type Foo = i32; |
| typedef short Foo[2]; | pub type Foo = [i16;2] |
| typedef short Foo[2][3]; | pub type Foo = [[i16; 2]; 3] |
| typedef sequence Foo; | pub type Foo = std::vec::Vec |
| IDL | Rust |
|---|---|
| struct Foo { long l; short s; }; |
pub struct Foo { pub l: i32, pub s: i16; } |
| IDL | Rust |
|---|---|
| enum Foo { VARIANT0, VARIANT1, VARIANT2 }; | pub enum Foo { VARIANT0, VARIANT1, VARIANT2, } |
Note: Only switch types "switch (long)" is supported yet.
| IDL | Rust |
|---|---|
| union Foo switch (long) { case LABEL0: long l; case LABEL1: case LABEL2: short s; default: octet o[8]; }; |
pub enum Foo { LABEL0{l: i32}, LABEL2{s: i16}, LABEL1{s: i16}, default{o: [u8; 8]}, } |
| /* not yet, to be developed */ union Result switch (long) { case None: void _dummy; case Some: T t }; |
/* not yet, to be developed */ pub enum Result<T> { None, Some(T), } |