boomerang 0.3.0

Deterministic Middleware for Robotics
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

#![allow(dead_code)]
#![allow(unused_variables)]

use boomerang::{builder::prelude::*, runtime, Reaction, Reactor};

#[derive(Reactor)]
#[reactor(state = "()", reaction = "AReactionX")]
struct ABuilder {
    x: TypedPortKey<(), Input>,
    y: TypedPortKey<(), Output>,
}

#[derive(Reaction)]
#[reaction(reactor = "ABuilder")]
struct AReactionX<'a> {
    x: runtime::InputRef<'a, ()>,
    y: runtime::OutputRef<'a, ()>,
}

impl<'a> Trigger<ABuilder> for AReactionX<'a> {
    fn trigger(self, ctx: &mut runtime::Context, state: &mut ()) {}
}

#[derive(Reactor)]
#[reactor(state = "()", reaction = "BReactionStartup", reaction = "BReactionX")]
struct BBuilder {
    x: TypedPortKey<(), Input>,
    y: TypedPortKey<(), Output>,
}

#[derive(Reaction)]
#[reaction(reactor = "BBuilder", triggers(port = "x"))]
struct BReactionX;

impl Trigger<BBuilder> for BReactionX {
    fn trigger(self, ctx: &mut runtime::Context, state: &mut ()) {}
}

#[derive(Reaction)]
#[reaction(reactor = "BBuilder", triggers(startup))]
struct BReactionStartup<'a> {
    y: runtime::OutputRef<'a, ()>,
}

impl Trigger<BBuilder> for BReactionStartup<'_> {
    fn trigger(self, ctx: &mut runtime::Context, state: &mut ()) {}
}

#[derive(Reactor)]
#[reactor(
    state = "()",
    connection(from = "a.y", to = "b.x"),
    connection(from = "b.y", to = "a.x")
)]
struct CycleBuilder {
    #[reactor(child = "()")]
    a: ABuilder,
    #[reactor(child = "()")]
    b: BBuilder,
}

#[test]
fn cycle() {
    tracing_subscriber::fmt::init();
    let _ =
        boomerang_util::runner::build_and_test_reactor::<CycleBuilder>("cycle", (), true, false)
            .unwrap();
}