rtps-idl 0.2.0

RTPS IDL to Rust code generator library
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

[![Apache 2.0 licensed][licence-badge]][licence-url]
# RTPS IDL to Rust code generator library

A library reading IDL input and generating corresponding Rust data types

## Intended Features
* Converting IDL types to Rust-types
* Converting IDL types to TokenStreams (hygiene proc-macros not stable yet)

## Add dependency
Put this in your Cargo.toml:
```toml
## Cargo.toml file
[dependencies]
rtps-idl = "0.1"
```

## RTPS-IDL to Rust Mapping
The 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_  | 

## Mapping by examples

## Templates

| IDL | Rust |
| ----- | ----- |
| `sequence<octet>` | `std::vec::Vec<u8>` |

### Typedef

| 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<octet> Foo; | pub type Foo = std::vec::Vec<u8> |


### Struct

| IDL | Rust |
| ----- | ----- |
| struct Foo {<br>&ensp;long l;<br>&ensp;short s;<br>} | pub struct Foo {<br>&ensp;l: i32,<br>&ensp;s: i16;<br>} |

### Union Switch

| IDL | Rust |
| ----- | ----- |
| union Foo switch (long) {<br>&ensp;case LABEL0: long l;<br>&ensp;case LABEL1:<br>&ensp;case LABEL2: short s;<br>&ensp;default: octet o[8];<br>} | pub enum Foo {<br>&ensp;LABEL0{l: i32},<br>&ensp;LABEL2{s: i16},<br>&ensp;LABEL1{s: i16},<br>&ensp;default{o: [u8; 8]},<br>}  |


## Credits
The underlying parser-generator  being used is [PEST][pest-url]

The original IDL-v4 grammar stems from [kpansky][idl-v4-grammar-url], and has been adapted for the needs of this project.

The CDR Serde implementation will be the  [cdr-rs
][cdr-rs-url] project at github.

[licence-badge]: https://img.shields.io/badge/License-Apache%202.0-blue.svg
[licence-url]: LICENSE.md
[pest-url]: https://pest.rs/
[idl-v4-grammar-url]: https://github.com/kpansky
[cdr-rs-url]: https://github.com/hrektts/cdr-rs