rtlola-macros 0.1.0

Procedural macros for more convenient handling of HirModes in the RTLola-Frontend.
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

#[macro_use]
extern crate rtlola_macros;

fn main() {
    let hir_a = Hir { mode: ModeA { a: A {} } };
    hir_a.a(3);
    let hir_b = Hir { mode: ModeB { a: A {}, b: B {} } };
    hir_b.a(5);
    hir_b.b();

    let hir_c = Hir { mode: ModeC { a: A {}, b: B {}, c: C {} } };
    hir_c.a(5);
    hir_c.b();
    hir_c.c();
    foo(hir_c);
}

fn foo<M: HirMode + TraitB>(ir: Hir<M>) {
    ir.b()
}

struct Hir<M: HirMode> {
    mode: M,
}

trait HirMode {}

#[covers_functionality(TraitA, a)]
#[derive(HirMode)]
struct ModeA {
    a: A,
}

struct A {}

#[mode_functionality]
trait TraitA {
    fn a(&self, x: u32);
}

impl TraitA for A {
    fn a(&self, _x: u32) {
        println!("I'm an A.");
    }
}

#[covers_functionality(TraitA, a)]
#[covers_functionality(TraitB, b)]
#[derive(HirMode)]
struct ModeB {
    a: A,
    b: B,
}

struct B {}

#[mode_functionality]
trait TraitB {
    fn b(&self);
}

impl TraitB for B {
    fn b(&self) {
        println!("I'm a B.");
    }
}

#[covers_functionality(TraitA, a)]
#[covers_functionality(TraitB, b)]
#[covers_functionality(TraitC, c)]
#[derive(HirMode)]
struct ModeC {
    a: A,
    b: B,
    c: C,
}

struct C {}

#[mode_functionality]
trait TraitC {
    fn c(&self);
}

impl TraitC for C {
    fn c(&self) {
        println!("I'm a C.");
    }
}