tunm_timer 0.1.4

simple timer, 简易定时器
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


use std::time::{SystemTime, UNIX_EPOCH};
extern crate rbtree;
use std::fmt;
mod timer;

pub use timer::Timer;

pub enum RetTimer {
    Ok,
    Continue,
    Over,
}

pub struct Handler<F>
where
    F: Factory,
{
    factory: F,
    time_id: u64,
    tick_ms: u64,
    tick_step: u64,
    is_repeat: bool,
    at_once: bool,
}



impl<F: Factory> fmt::Display for Handler<F> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "key({}, {}), step({}), is_repeat({}), at_once({})", self.tick_ms, self.time_id, self.tick_step, self.is_repeat, self.at_once)
    }
}

impl<F:Factory> Handler<F> {
    pub fn new_step(factory: F, tick_step: u64, is_repeat: bool, at_once: bool) -> Handler<F> {
        debug_assert!(tick_step > 0, "Step Mode Must Big 0s");
        let tick_step = ::std::cmp::max(1, tick_step);
        Handler {
            factory,
            time_id:0,
            tick_ms:0u64,
            tick_step,
            is_repeat,
            at_once,
        }
    }
    
    pub fn new_step_ms(factory: F, tick_step: u64, is_repeat: bool, at_once: bool) -> Handler<F> {
        Self::new_step(factory, tick_step * 1000, is_repeat, at_once)
    }

    pub fn new_at(factory: F, tick_ms: u64) -> Handler<F> {
        Handler {
            factory,
            time_id:0,
            tick_ms:tick_ms,
            tick_step:0,
            is_repeat:false,
            at_once:false,
        }
    }

    pub fn new_at_ms(factory: F, tick_ms: u64) -> Handler<F> {
        Self::new_at(factory, tick_ms * 1000)
    }
}

pub trait Factory : Sized {
    fn on_trigger(&mut self, timer: &mut Timer<Self>, id: u64) -> RetTimer;
}


pub fn now_microsecond() -> u64 {
    let start = SystemTime::now();
    let since_the_epoch = start
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");
    let ms = since_the_epoch.as_secs() as u64 * 1000_000u64 + (since_the_epoch.subsec_nanos() as f64 / 1_000.0) as u64;
    ms
}