rtactor 0.6.0

An Actor framework specially designed for Real-Time constrained use cases.
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

use assert2::let_assert;
use rtactor::{ActiveMailbox, Addr, Error, Message};
use std::cell::RefCell;
use std::time::Duration;
use std::vec::Vec;

#[test]
fn test_addr() {
    let mut addr = Addr::new();
    assert!(!addr.is_valid());

    let actor = ActiveMailbox::new(1);
    addr = actor.addr();
    assert!(addr.is_valid());
}

#[test]
#[allow(deprecated)]
fn test_deprecated_active_actor_addr() {
    let mut addr = Addr::new();
    assert!(!addr.is_valid());

    let actor = rtactor::ActiveActor::new(1);
    addr = actor.addr();
    assert!(addr.is_valid());
}

#[test]
/// Check if it's possible to send a buffer and extract it from an immutable Message reference.
/// This is important because this way it's possible not to do a memory copy of large buffers passed.
fn send_buffer_without_copy() {
    let mut receiver = ActiveMailbox::new(1);

    enum Notification {
        Buffer(RefCell<Option<Vec<u8>>>),
    }

    rtactor::send_notification(
        &receiver.addr(),
        Notification::Buffer(RefCell::new(Some(vec![0, 3, 5, 7]))),
    )
    .unwrap();

    let msg = &receiver.wait_message().unwrap();

    match msg {
        Message::Notification(notif) => {
            let notif = notif.data.downcast_ref::<Notification>().unwrap();

            match notif {
                Notification::Buffer(cell) => {
                    let v = cell.borrow_mut().take().unwrap();
                    assert_eq!(v, vec!(0, 3, 5, 7))
                }
            }
        }
        _ => panic!(),
    }
}

#[test]
/// Send a request from an active actor and use ActiveMailbox::responds() to respond.
fn test_responds() {
    let mut requester = ActiveMailbox::new(1);

    let_assert!(
        Err(Error::AddrUnreachable) =
            requester.request_for::<_, u32>(&Addr::INVALID, 0x1234, Duration::from_secs(5))
    );
    let requested_full_queue = ActiveMailbox::new(1);
    rtactor::send_notification(&requested_full_queue.addr(), 23).unwrap();

    let_assert!(
        Err(Error::QueueFull) =
            requester.request_for::<_, u32>(&requested_full_queue.addr(), 0x1234, Duration::ZERO)
    );

    let requester_addr = requester.addr();
    let mut requested = ActiveMailbox::new(1);
    let requested_addr = requested.addr();

    let join_handle = std::thread::spawn(move || {
        let_assert!(Ok(Message::Request(request)) = requested.wait_message());
        let_assert!(Some(val_ref) = request.data.downcast_ref::<i32>());
        let val = *val_ref;
        assert_eq!(val, -123);
        assert_eq!(request.src, requester_addr);
        let_assert!(Ok(()) = requested.responds::<i32>(request, -val));
    });

    let_assert!(
        Ok(ret_val) =
            requester.request_for::<_, i32>(&requested_addr, -123i32, Duration::from_secs(5))
    );

    assert_eq!(ret_val, 123);
    join_handle.join().unwrap();
}