embedded-time 0.7.0-alpha2

A library for abstracting clocks and handling time(ing) in embedded systems
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

//! Construction of time-based types from integers

use crate::{duration::units::*, frequency::units::*, time_int::TimeInt};

/// Create time-based values from primitive and core numeric types.
///
/// This trait is anonomously re-exported in [`traits`](crate::traits)
///
/// # Examples
/// Basic construction of time-based values.
/// ```rust
/// # use embedded_time::{traits::*, units::*};
/// assert_eq!(5_u32.nanoseconds(), Nanoseconds(5_u32));
/// assert_eq!(5_u32.microseconds(), Microseconds(5_u32));
/// assert_eq!(5_u32.milliseconds(), Milliseconds(5_u32));
/// assert_eq!(5_u32.seconds(), Seconds(5_u32));
/// assert_eq!(5_u32.minutes(), Minutes(5_u32));
/// assert_eq!(5_u32.hours(), Hours(5_u32));
///
/// assert_eq!(5_u32.hertz(), Hertz(5_u32));
/// ```
pub trait NumericConstructor: TimeInt {
    /// Construct the duration implementation
    fn nanoseconds(self) -> Nanoseconds<Self>;
    /// Construct the duration implementation
    fn microseconds(self) -> Microseconds<Self>;
    /// Construct the duration implementation
    fn milliseconds(self) -> Milliseconds<Self>;
    /// Construct the duration implementation
    fn seconds(self) -> Seconds<Self>;
    /// Construct the duration implementation
    fn minutes(self) -> Minutes<Self>;
    /// Construct the duration implementation
    fn hours(self) -> Hours<Self>;

    /// Construct the frequency type
    fn hertz(self) -> Hertz<Self>;
}

macro_rules! impl_numeric_constructors {
        ($($type:ty),* $(,)?) => {
            $(
                impl NumericConstructor for $type {
                    #[inline(always)]
                    fn nanoseconds(self) -> Nanoseconds<$type> {
                        Nanoseconds(self)
                    }

                    #[inline(always)]
                    fn microseconds(self) -> Microseconds<$type> {
                        Microseconds(self)
                    }

                    #[inline(always)]
                    fn milliseconds(self) -> Milliseconds<$type> {
                        Milliseconds(self)
                    }

                    #[inline(always)]
                    fn seconds(self) -> Seconds<$type> {
                        Seconds(self)
                    }

                    #[inline(always)]
                    fn minutes(self) -> Minutes<$type> {
                        Minutes(self)
                    }

                    #[inline(always)]
                    fn hours(self) -> Hours<$type> {
                        Hours(self)
                    }

                    #[inline(always)]
                    fn hertz(self) -> Hertz<$type> {
                        Hertz(self)
                    }
                }
            )*
        };
    }

impl_numeric_constructors![u32, u64];