timer-deque-rs 0.8.0

A OS based timer and timer queue which implements timeout queues of different types.
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::{cmp::Ordering, fmt};

use timer_deque_rs::
{
    AbsoluteTime, TimerDequeTicket, TimerDequeTicketIssuer, TimerPoll, 
    deque_timeout::{DequeOnce, OrderTimerDeque, OrderedTimerDequeMode}
};

#[derive(Debug, PartialEq, Eq)]
struct TestItem(TimerDequeTicket);

impl fmt::Display for TestItem
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "0 = {}", self.0)
    }
}

fn main()
{
    let ev_watch = TimerPoll::new().unwrap();

    let time_list = 
        OrderTimerDeque
            ::<DequeOnce, TimerDequeTicketIssuer<_>>
            ::new("test_label".into(), 4, false, true).unwrap();

    // add timer to event monitor
    let mut time_list_polled = ev_watch.add(time_list).unwrap();


    let abs_time = AbsoluteTime::now();

    // add to timer
    let tss_set1 = DequeOnce::new(abs_time.clone().add_sec(3));
    let ticket1 = time_list_polled.get_inner_mut().add(tss_set1).unwrap();
    let ent1 = TestItem(ticket1);

    let tss_set2 = DequeOnce::new(abs_time.clone().add_sec(7));
    let ticket2 = time_list_polled.get_inner_mut().add(tss_set2).unwrap();
    let ent2 = TestItem(ticket2);

    let tss_set3 = DequeOnce::new(abs_time.clone().add_sec(10));
    let ticket3 = time_list_polled.get_inner_mut().add(tss_set3).unwrap();
    let ent3 = TestItem(ticket3);

    // poll timer

    let res = ev_watch.poll(Option::None).unwrap();

    let poll_timeout = AbsoluteTime::now();

    println!("poll with result: {:?}", res);

    // call deque insance to handle the timer result

    assert_eq!(res.as_ref().unwrap().len(), 1); // only one item

    let res = res.unwrap().pop().unwrap();

    let timeout_items = 
        time_list_polled.get_inner_mut().handle_timer_event(res).unwrap();
    

    assert_eq!(timeout_items.is_some(), true); // only one item
    assert_eq!(timeout_items.as_ref().unwrap().len(), 1); // only one item
    assert_eq!(timeout_items.as_ref().unwrap()[0], ent1.0); // item 1
    assert_eq!(ent1.0.is_queued(), false);

    let timedout = timeout_items.unwrap()[0];

    println!("timer item: {}, timeout: {}, curtime: {}", &timedout, tss_set1, poll_timeout);
    assert_eq!(tss_set1.get_absolut_timeout().seconds_cmp(&poll_timeout) == Ordering::Equal, true);

    // removing second item from queue, so ent3 should be next to fire
    println!("item {} removing from shed. queue", ent2);

    let res = time_list_polled.get_inner_mut().remove_from_queue(&ent2.0.get_deque_id()).unwrap();
 
    println!("queue len: {}", time_list_polled.get_inner().timer_queue_len());
    assert_eq!(res, Some(*ent2.0.get_deque_id()));
    assert_eq!(time_list_polled.get_inner().timer_queue_len(), 1); // only ent3 left
   

    // -----
    // wait for events (ent3)
    let res = ev_watch.poll(Option::None).unwrap();

    let poll_timeout = AbsoluteTime::now();

    assert_eq!(res.as_ref().unwrap().len(), 1); // only one item

    let res = res.unwrap().pop().unwrap();

    println!("poll with result: {}", res);

    let timeout_items = 
        time_list_polled.get_inner_mut().handle_timer_event(res).unwrap();

    assert_eq!(timeout_items.as_ref().unwrap().len(), 1); // only one item
    assert_eq!(timeout_items.as_ref().unwrap()[0], ent3.0); // item 3

    let timeout_item = timeout_items.unwrap()[0];

    println!("timer item: {}, timeout: {}, curtime: {}", &timeout_item, tss_set3, poll_timeout);
    assert_eq!(tss_set3.get_absolut_timeout().seconds_cmp(&poll_timeout) == Ordering::Equal, true);

    println!("timer queue len: {}", time_list_polled.get_inner().timer_queue_len());

    assert_eq!(time_list_polled.get_inner().timer_queue_len(), 0); // queue should be empty

    return;
}