cyclonedds 1.8.0

Safe Rust wrapper for Eclipse CycloneDDS
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

use cyclonedds::*;
use std::time::Duration;

#[derive(DdsTypeDerive, Clone, Debug, PartialEq)]
struct AddRequest {
    correlation_id: u64,
    a: i32,
    b: i32,
}

impl RequestReply for AddRequest {
    fn correlation_id(&self) -> u64 {
        self.correlation_id
    }
    fn set_correlation_id(&mut self, id: u64) {
        self.correlation_id = id;
    }
}

#[derive(DdsTypeDerive, Clone, Debug, PartialEq)]
struct AddReply {
    correlation_id: u64,
    result: i32,
}

impl RequestReply for AddReply {
    fn correlation_id(&self) -> u64 {
        self.correlation_id
    }
    fn set_correlation_id(&mut self, id: u64) {
        self.correlation_id = id;
    }
}

fn main() {
    let participant = DomainParticipant::new(0).unwrap();

    let requester = Requester::<AddRequest, AddReply>::new(
        &participant, "CalcService", None, None,
    )
    .unwrap();

    let replier = Replier::<AddRequest, AddReply>::new(
        &participant, "CalcService", None, None,
    )
    .unwrap();

    // Spawn replier in background
    std::thread::spawn(move || {
        loop {
            if let Some(req) = replier.receive_request(Duration::from_secs(1)).unwrap() {
                let reply = AddReply {
                    correlation_id: req.correlation_id(),
                    result: req.a + req.b,
                };
                replier.send_reply(reply).unwrap();
                println!("Replier: {} + {} = {}", req.a, req.b, req.a + req.b);
            }
        }
    });

    // Give replier time to start
    std::thread::sleep(Duration::from_millis(200));

    // Send requests
    for i in 1..=5 {
        let req = AddRequest {
            correlation_id: 0,
            a: i,
            b: i * 2,
        };
        let rep = requester.request(req, Duration::from_secs(1)).unwrap();
        println!("Requester: got reply = {} (corr_id={})", rep.result, rep.correlation_id());
        assert_eq!(rep.result, i + i * 2);
    }

    println!("Request-Reply example completed successfully!");
}