temporal_rs 0.2.3

Temporal in Rust is an implementation of the TC39 Temporal Builtin Proposal in Rust.
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

use crate::builtins::Now;
use crate::host::HostClock;
use crate::host::HostHooks;
use crate::host::HostTimeZone;
use crate::TemporalResult;

use crate::unix_time::EpochNanoseconds;
use crate::TemporalError;
use crate::TimeZone;
use timezone_provider::provider::TimeZoneProvider;
use web_time::{SystemTime, UNIX_EPOCH};

// TODO: Look into and potentially implement a `SystemTime` struct allows
// providing closures or trait implementations that can then
// be used to construct [`Now`]. Basically `Temporal` but with
// traits or closures.
//
// Temporal could then be something like:
//
// pub struct Temporal(SystemTime<DefaultSystemClock, DefaultSystemTimeZone>)
//

/// The Temporal object for accessing current system time
pub struct Temporal;

impl Temporal {
    /// Get a `Now` object for the default host system.
    #[cfg(feature = "sys-local")]
    #[deprecated(
        since = "0.1.0",
        note = "`now` deprecated was not clear about the host system implementation, please use `local_now`"
    )]
    pub fn now() -> Now<LocalHostSystem> {
        Now::new(LocalHostSystem)
    }

    /// Get a `Now` object with a [`LocalHostSystem`], which
    /// will use the host system's time zone as a fallback.
    #[cfg(feature = "sys-local")]
    pub fn local_now() -> Now<LocalHostSystem> {
        Now::new(LocalHostSystem)
    }

    /// Get a `Now` object with a [`UtcHostSystem`], which
    /// will use a UTC time zone as a fallback.
    #[cfg(feature = "sys")]
    pub fn utc_now() -> Now<UtcHostSystem> {
        Now::new(UtcHostSystem)
    }
}

/// A UTC host system implementation that will return the current time
/// with the a UTC time zone as fallback.
///
/// This implementation is backed by [`std::time::SystemTime`].
#[cfg(feature = "sys")]
pub struct UtcHostSystem;

#[cfg(feature = "sys")]
impl HostHooks for UtcHostSystem {}

#[cfg(feature = "sys")]
impl HostClock for UtcHostSystem {
    fn get_host_epoch_nanoseconds(&self) -> TemporalResult<EpochNanoseconds> {
        get_system_nanoseconds()
    }
}

#[cfg(feature = "sys")]
impl HostTimeZone for UtcHostSystem {
    fn get_host_time_zone(
        &self,
        provider: &(impl TimeZoneProvider + ?Sized),
    ) -> TemporalResult<TimeZone> {
        Ok(TimeZone::utc_with_provider(provider))
    }
}

/// A local host system implementation that will return the current time
/// with the system time zone as a fallback.
///
/// This implementation is backed by [`std::time::SystemTime`] and [`iana_time_zone`]
#[cfg(feature = "sys-local")]
pub struct LocalHostSystem;

#[cfg(feature = "sys-local")]
impl HostHooks for LocalHostSystem {}

#[cfg(feature = "sys-local")]
impl HostClock for LocalHostSystem {
    fn get_host_epoch_nanoseconds(&self) -> TemporalResult<EpochNanoseconds> {
        get_system_nanoseconds()
    }
}

#[cfg(feature = "sys-local")]
impl HostTimeZone for LocalHostSystem {
    fn get_host_time_zone(
        &self,
        provider: &(impl TimeZoneProvider + ?Sized),
    ) -> TemporalResult<TimeZone> {
        get_system_timezone(provider)
    }
}

#[cfg(feature = "sys-local")]
#[inline]
pub(crate) fn get_system_timezone(
    provider: &(impl TimeZoneProvider + ?Sized),
) -> TemporalResult<TimeZone> {
    iana_time_zone::get_timezone()
        .map(|s| TimeZone::try_from_identifier_str_with_provider(&s, provider))
        .map_err(|_| TemporalError::general("Error fetching system time"))?
}

/// Returns the system time in nanoseconds.
pub(crate) fn get_system_nanoseconds() -> TemporalResult<EpochNanoseconds> {
    use crate::unix_time::EpochNanoseconds;

    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|_| TemporalError::general("Error fetching system time"))
        .map(|d| EpochNanoseconds::from(d.as_nanos() as i128))
}