Translator is a rust procedural macro which translates rust structs into other languages for exposure over a rust FFI (or however else you want to use them). Structs that are not [repr(C)] are ignored. The structs are translated into:
This macro isn't a magic bullet, but it will (hopefully) greatly reduce the cost of creating Rust libraries for use with other languages
Say you want to translate the following structs: ```rust
pub struct SomeStruct { //pub raw_message: [i16;5], pub foo: i32, pub bar: Baz, pub foobar: [u8;5] }
pub struct Baz { pub bob: f32 } ```
You would have to add the Translator macro, and the Translator to the derivations. You would also have to add the 'magic struct' to the end of the struct declarations. It would look like this:
```rust
extern crate translator;
pub struct SomeStruct { //pub raw_message: [i16;5], pub foo: i32, pub bar: Baz, pub foobar: [u8;5] }
pub struct Baz { pub bob: f32 }
struct FinalizeTranslatorStruct{} ```
When you compile, in the 'target' folder a new folder will be created named 'TranslateOutput' with 3 files (one for each language) with the following contents:
```c++ typedef struct SomeStructTag { int32t foo; Baz bar; uint8t foobar[5]; } SomeStruct;
typedef struct BazTag { float bob; } Baz; ```
```python class SomeStruct(Structure): fields = [ ("foo", cint), ("bar", Baz), ("foobar", cubyte * 5), ]
class Baz(Structure): fields = [ ("bob", c_float), ] ```
```csharp [StructLayout(LayoutKind.Sequential)] public struct SomeStruct { public int foo; public Baz bar; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] public byte[] foobar; }
[StructLayout(LayoutKind.Sequential)] public struct Baz { public float bob; } ```