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
115
116
117

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

use timer_deque_rs::{AbsoluteTime, DequeOnce, OrderTimerDeque, OrderedTimerDequeMode, TimerDequeConsumer, TimerPoll};



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

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, TimerDequeConsumer<Arc<TestItem>, _>>
            ::new("test_label".into(), 4, false, true).unwrap();

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

    let abs_time = AbsoluteTime::now();
    
    let tss_set1 = DequeOnce::new(abs_time.clone().add_sec(3));
    let ent1 = Arc::new(TestItem(1));

    let tss_set2 = DequeOnce::new(abs_time.clone().add_sec(7));
    let ent2 = Arc::new(TestItem(2));

    let tss_set3 = DequeOnce::new(abs_time.clone().add_sec(10));
    let ent3 = Arc::new(TestItem(3));

    time_list_poll.get_inner_mut().add(ent1.clone(), tss_set1).unwrap();
    time_list_poll.get_inner_mut().add(ent2.clone(), tss_set2).unwrap();
    time_list_poll.get_inner_mut().add(ent3.clone(), tss_set3).unwrap();

    // poll timer for events (it can be done in separate thread)
    let res = ev_watch.poll(Option::None).unwrap();

    let poll_timeout = AbsoluteTime::now();

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

    assert_eq!(res.is_none(), false);
    assert_eq!(res.as_ref().unwrap().len(), 1);
    
    // get exact result
    let pet = res.unwrap().pop().unwrap();


    let timeout_items = time_list_poll.get_inner_mut().handle_timer_event(pet).unwrap();

    println!("timer timeout with result: {:?}", timeout_items);

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


    let timeout_item = timeout_items.unwrap().pop().unwrap();

    println!("timer item: {}, timeout: {}, curtime: {}", timeout_item, 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
    let rem = time_list_poll.get_inner_mut().remove_from_queue(&ent2).unwrap();

    println!("item {:?} removed from shed. queue", rem);
    println!("queue len: {}", time_list_poll.get_inner().timer_queue_len());

    assert_eq!(rem.is_some(), true);
    assert_eq!(rem, Some(ent2));
    assert_eq!(time_list_poll.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();

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

    assert_eq!(res.is_none(), false);
    assert_eq!(res.as_ref().unwrap().len(), 1);
    
    // get exact result
    let pet = res.unwrap().pop().unwrap();


    let timeout_items = time_list_poll.get_inner_mut().handle_timer_event(pet).unwrap();

    println!("timer timeout with result: {:?}", timeout_items);

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


    let timeout_item = timeout_items.unwrap().pop().unwrap();

    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_poll.get_inner().timer_queue_len());

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

    return;
}