scsys-core 0.3.0

scsys is a collection of primitives and utilities for use throughout the ecosystem.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

/*
    Appellation: time <module>
    Contrib: FL03 <jo3mccain@icloud.com>
*/
//! # Time
//!
//! The `time` module provides a set of utilities for working with time and timestamps.
#[doc(inline)]
#[cfg(feature = "std")]
pub use self::utils::{std_time, systime};
#[doc(inline)]
pub use self::{timestamp::Timestamp, types::prelude::*};
/// this module implements the [`Timestamp`] type
pub mod timestamp;
/// this module contains various implementations used to support `time` related features
pub mod types {
    #[doc(inline)]
    pub use self::prelude::*;

    pub mod datetime;
    pub mod epoch;

    pub(crate) mod prelude {
        #[doc(inline)]
        pub use super::datetime::*;
        #[doc(inline)]
        pub use super::epoch::*;
    }
}

pub(crate) mod prelude {
    #[doc(inline)]
    pub use super::timestamp::*;
    #[doc(inline)]
    pub use super::types::prelude::*;
    #[cfg(feature = "std")]
    pub use super::utils::{std_time, systime};
    #[doc(inline)]
    pub use super::{Now, RawTimestamp};
}

pub(crate) mod utils {
    /// [systime] is a utilitarian function that returns the current system time in milliseconds.
    #[cfg(feature = "std")]
    #[inline]
    pub fn systime() -> core::time::Duration {
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
    }
    /// [systime] is a utilitarian function that returns the current system time in milliseconds.
    #[cfg(feature = "std")]
    #[inline]
    pub fn std_time() -> u128 {
        systime().as_millis()
    }
}

/// The [`Now`] trait provides a common creation routines for all datetime implementations.
pub trait Now {
    type Output;

    fn now() -> Self::Output;
}

/// a private trait used to mark types capable of being uses as a basetype for a [`Timestamp`].
pub trait RawTimestamp {
    private!();
}

/*
 ************* Implementations *************
*/
macro_rules! impl_raw_timestamp {
    ($($t:ty),* $(,)?) => {
        $(
            impl_raw_timestamp!(@impl $t);
        )*
    };
    (@impl $T:ty) => {
        impl RawTimestamp for $T {
            seal!();
        }
    };
}

impl_raw_timestamp! {
    u64,
    u128,
    i64,
}

impl RawTimestamp for str {
    seal!();
}

#[cfg(feature = "alloc")]
impl RawTimestamp for alloc::string::String {
    seal!();
}

#[cfg(feature = "std")]
impl Now for u64 {
    type Output = Timestamp<Self>;

    fn now() -> Self::Output {
        Timestamp::new(utils::systime().as_secs())
    }
}

#[cfg(feature = "std")]
impl Now for u128 {
    type Output = Timestamp<Self>;

    fn now() -> Self::Output {
        Timestamp::new(utils::systime().as_millis())
    }
}

#[cfg(feature = "chrono")]
impl Now for i64 {
    type Output = Timestamp<Self>;

    fn now() -> Self::Output {
        Timestamp::new(chrono::Local::now().timestamp())
    }
}

#[cfg(all(feature = "alloc", feature = "chrono"))]
impl Now for alloc::string::String {
    type Output = Timestamp<Self>;

    fn now() -> Self::Output {
        Timestamp::new(chrono::Local::now().to_rfc3339())
    }
}