tz/datetime/
mod.rs

1//! Types related to a date time.
2
3mod find;
4
5#[doc(inline)]
6#[cfg(feature = "alloc")]
7pub use find::FoundDateTimeList;
8#[doc(inline)]
9pub use find::{FoundDateTimeKind, FoundDateTimeListRefMut};
10
11use crate::constants::*;
12use crate::datetime::find::find_date_time;
13use crate::error::datetime::DateTimeError;
14use crate::error::TzError;
15use crate::timezone::{LocalTimeType, TimeZoneRef};
16use crate::utils::{min, try_into_i32, try_into_i64};
17
18use core::cmp::Ordering;
19use core::fmt;
20
21/// UTC date time expressed in the [proleptic gregorian calendar](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar)
22#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
23pub struct UtcDateTime {
24    /// Year
25    year: i32,
26    /// Month in `[1, 12]`
27    month: u8,
28    /// Day of the month in `[1, 31]`
29    month_day: u8,
30    /// Hours since midnight in `[0, 23]`
31    hour: u8,
32    /// Minutes in `[0, 59]`
33    minute: u8,
34    /// Seconds in `[0, 60]`, with a possible leap second
35    second: u8,
36    /// Nanoseconds in `[0, 999_999_999]`
37    nanoseconds: u32,
38}
39
40impl fmt::Display for UtcDateTime {
41    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
42        format_date_time(f, self.year, self.month, self.month_day, self.hour, self.minute, self.second, self.nanoseconds, 0)
43    }
44}
45
46impl UtcDateTime {
47    /// Minimum allowed Unix time in seconds
48    const MIN_UNIX_TIME: i64 = -67768100567971200;
49    /// Maximum allowed Unix time in seconds
50    const MAX_UNIX_TIME: i64 = 67767976233532799;
51
52    /// Check if the UTC date time associated to a Unix time in seconds is valid
53    const fn check_unix_time(unix_time: i64) -> Result<(), TzError> {
54        if Self::MIN_UNIX_TIME <= unix_time && unix_time <= Self::MAX_UNIX_TIME {
55            Ok(())
56        } else {
57            Err(TzError::OutOfRange)
58        }
59    }
60
61    /// Construct a UTC date time
62    ///
63    /// ## Inputs
64    ///
65    /// * `year`: Year
66    /// * `month`: Month in `[1, 12]`
67    /// * `month_day`: Day of the month in `[1, 31]`
68    /// * `hour`: Hours since midnight in `[0, 23]`
69    /// * `minute`: Minutes in `[0, 59]`
70    /// * `second`: Seconds in `[0, 60]`, with a possible leap second
71    /// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`
72    ///
73    pub const fn new(year: i32, month: u8, month_day: u8, hour: u8, minute: u8, second: u8, nanoseconds: u32) -> Result<Self, TzError> {
74        // Exclude the maximum possible UTC date time with a leap second
75        if year == i32::MAX && month == 12 && month_day == 31 && hour == 23 && minute == 59 && second == 60 {
76            return Err(TzError::OutOfRange);
77        }
78
79        if let Err(error) = check_date_time_inputs(year, month, month_day, hour, minute, second, nanoseconds) {
80            return Err(TzError::DateTime(error));
81        }
82
83        Ok(Self { year, month, month_day, hour, minute, second, nanoseconds })
84    }
85
86    /// Construct a UTC date time from a Unix time in seconds and nanoseconds
87    pub const fn from_timespec(unix_time: i64, nanoseconds: u32) -> Result<Self, TzError> {
88        let seconds = match unix_time.checked_sub(UNIX_OFFSET_SECS) {
89            Some(seconds) => seconds,
90            None => return Err(TzError::OutOfRange),
91        };
92
93        let mut remaining_days = seconds / SECONDS_PER_DAY;
94        let mut remaining_seconds = seconds % SECONDS_PER_DAY;
95        if remaining_seconds < 0 {
96            remaining_seconds += SECONDS_PER_DAY;
97            remaining_days -= 1;
98        }
99
100        let mut cycles_400_years = remaining_days / DAYS_PER_400_YEARS;
101        remaining_days %= DAYS_PER_400_YEARS;
102        if remaining_days < 0 {
103            remaining_days += DAYS_PER_400_YEARS;
104            cycles_400_years -= 1;
105        }
106
107        let cycles_100_years = min(remaining_days / DAYS_PER_100_YEARS, 3);
108        remaining_days -= cycles_100_years * DAYS_PER_100_YEARS;
109
110        let cycles_4_years = min(remaining_days / DAYS_PER_4_YEARS, 24);
111        remaining_days -= cycles_4_years * DAYS_PER_4_YEARS;
112
113        let remaining_years = min(remaining_days / DAYS_PER_NORMAL_YEAR, 3);
114        remaining_days -= remaining_years * DAYS_PER_NORMAL_YEAR;
115
116        let mut year = OFFSET_YEAR + remaining_years + cycles_4_years * 4 + cycles_100_years * 100 + cycles_400_years * 400;
117
118        let mut month = 0;
119        while month < DAY_IN_MONTHS_LEAP_YEAR_FROM_MARCH.len() {
120            let days = DAY_IN_MONTHS_LEAP_YEAR_FROM_MARCH[month];
121            if remaining_days < days {
122                break;
123            }
124            remaining_days -= days;
125            month += 1;
126        }
127        month += 2;
128
129        if month >= MONTHS_PER_YEAR as usize {
130            month -= MONTHS_PER_YEAR as usize;
131            year += 1;
132        }
133        month += 1;
134
135        let month_day = 1 + remaining_days;
136
137        let hour = remaining_seconds / SECONDS_PER_HOUR;
138        let minute = (remaining_seconds / SECONDS_PER_MINUTE) % MINUTES_PER_HOUR;
139        let second = remaining_seconds % SECONDS_PER_MINUTE;
140
141        let year = match try_into_i32(year) {
142            Ok(year) => year,
143            Err(error) => return Err(error),
144        };
145
146        Ok(Self { year, month: month as u8, month_day: month_day as u8, hour: hour as u8, minute: minute as u8, second: second as u8, nanoseconds })
147    }
148
149    /// Construct a UTC date time from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)
150    pub const fn from_total_nanoseconds(total_nanoseconds: i128) -> Result<Self, TzError> {
151        match total_nanoseconds_to_timespec(total_nanoseconds) {
152            Ok((unix_time, nanoseconds)) => Self::from_timespec(unix_time, nanoseconds),
153            Err(error) => Err(error),
154        }
155    }
156
157    /// Returns the Unix time in seconds associated to the UTC date time
158    pub const fn unix_time(&self) -> i64 {
159        unix_time(self.year, self.month, self.month_day, self.hour, self.minute, self.second)
160    }
161
162    /// Project the UTC date time into a time zone.
163    ///
164    /// Leap seconds are not preserved.
165    ///
166    pub const fn project(&self, time_zone_ref: TimeZoneRef<'_>) -> Result<DateTime, TzError> {
167        DateTime::from_timespec(self.unix_time(), self.nanoseconds, time_zone_ref)
168    }
169
170    /// Returns the current UTC date time
171    #[cfg(feature = "std")]
172    pub fn now() -> Result<Self, TzError> {
173        Self::from_total_nanoseconds(crate::utils::current_total_nanoseconds())
174    }
175}
176
177/// Date time associated to a local time type, expressed in the [proleptic gregorian calendar](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar)
178#[derive(Debug, Copy, Clone)]
179pub struct DateTime {
180    /// Year
181    year: i32,
182    /// Month in `[1, 12]`
183    month: u8,
184    /// Day of the month in `[1, 31]`
185    month_day: u8,
186    /// Hours since midnight in `[0, 23]`
187    hour: u8,
188    /// Minutes in `[0, 59]`
189    minute: u8,
190    /// Seconds in `[0, 60]`, with a possible leap second
191    second: u8,
192    /// Local time type
193    local_time_type: LocalTimeType,
194    /// UTC Unix time in seconds
195    unix_time: i64,
196    /// Nanoseconds in `[0, 999_999_999]`
197    nanoseconds: u32,
198}
199
200impl PartialEq for DateTime {
201    fn eq(&self, other: &Self) -> bool {
202        (self.unix_time, self.nanoseconds) == (other.unix_time, other.nanoseconds)
203    }
204}
205
206impl PartialOrd for DateTime {
207    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
208        (self.unix_time, self.nanoseconds).partial_cmp(&(other.unix_time, other.nanoseconds))
209    }
210}
211
212impl fmt::Display for DateTime {
213    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
214        let ut_offset = self.local_time_type().ut_offset();
215        format_date_time(f, self.year, self.month, self.month_day, self.hour, self.minute, self.second, self.nanoseconds, ut_offset)
216    }
217}
218
219impl DateTime {
220    /// Construct a date time
221    ///
222    /// ## Inputs
223    ///
224    /// * `year`: Year
225    /// * `month`: Month in `[1, 12]`
226    /// * `month_day`: Day of the month in `[1, 31]`
227    /// * `hour`: Hours since midnight in `[0, 23]`
228    /// * `minute`: Minutes in `[0, 59]`
229    /// * `second`: Seconds in `[0, 60]`, with a possible leap second
230    /// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`
231    /// * `local_time_type`: Local time type associated to a time zone
232    ///
233    #[allow(clippy::too_many_arguments)]
234    pub const fn new(
235        year: i32,
236        month: u8,
237        month_day: u8,
238        hour: u8,
239        minute: u8,
240        second: u8,
241        nanoseconds: u32,
242        local_time_type: LocalTimeType,
243    ) -> Result<Self, TzError> {
244        if let Err(error) = check_date_time_inputs(year, month, month_day, hour, minute, second, nanoseconds) {
245            return Err(TzError::DateTime(error));
246        }
247
248        // Overflow is not possible
249        let unix_time = unix_time(year, month, month_day, hour, minute, second) - local_time_type.ut_offset() as i64;
250
251        // Check if the associated UTC date time is valid
252        if let Err(error) = UtcDateTime::check_unix_time(unix_time) {
253            return Err(error);
254        }
255
256        Ok(Self { year, month, month_day, hour, minute, second, local_time_type, unix_time, nanoseconds })
257    }
258
259    /// Find the possible date times corresponding to a date, a time and a time zone
260    ///
261    /// ## Inputs
262    ///
263    /// * `year`: Year
264    /// * `month`: Month in `[1, 12]`
265    /// * `month_day`: Day of the month in `[1, 31]`
266    /// * `hour`: Hours since midnight in `[0, 23]`
267    /// * `minute`: Minutes in `[0, 59]`
268    /// * `second`: Seconds in `[0, 60]`, with a possible leap second
269    /// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`
270    /// * `time_zone_ref`: Reference to a time zone
271    ///
272    #[allow(clippy::too_many_arguments)]
273    #[cfg(feature = "alloc")]
274    pub fn find(
275        year: i32,
276        month: u8,
277        month_day: u8,
278        hour: u8,
279        minute: u8,
280        second: u8,
281        nanoseconds: u32,
282        time_zone_ref: TimeZoneRef<'_>,
283    ) -> Result<FoundDateTimeList, TzError> {
284        let mut found_date_time_list = FoundDateTimeList::default();
285        find_date_time(&mut found_date_time_list, year, month, month_day, hour, minute, second, nanoseconds, time_zone_ref)?;
286        Ok(found_date_time_list)
287    }
288
289    /// Find the possible date times corresponding to a date, a time and a time zone.
290    ///
291    /// This method doesn't allocate, and instead takes a preallocated buffer as an input.
292    /// It returns a [`FoundDateTimeListRefMut`] wrapper which has additional methods.
293    ///
294    /// ## Inputs
295    ///
296    /// * `buf`: Preallocated buffer
297    /// * `year`: Year
298    /// * `month`: Month in `[1, 12]`
299    /// * `month_day`: Day of the month in `[1, 31]`
300    /// * `hour`: Hours since midnight in `[0, 23]`
301    /// * `minute`: Minutes in `[0, 59]`
302    /// * `second`: Seconds in `[0, 60]`, with a possible leap second
303    /// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`
304    /// * `time_zone_ref`: Reference to a time zone
305    ///
306    /// ## Usage
307    ///
308    /// ```rust
309    /// # fn main() -> Result<(), tz::TzError> {
310    /// use tz::datetime::{DateTime, FoundDateTimeKind};
311    /// use tz::timezone::{LocalTimeType, TimeZoneRef, Transition};
312    ///
313    /// let transitions = &[Transition::new(3600, 1), Transition::new(86400, 0), Transition::new(i64::MAX, 0)];
314    /// let local_time_types = &[LocalTimeType::new(0, false, Some(b"STD"))?, LocalTimeType::new(3600, true, Some(b"DST"))?];
315    /// let time_zone_ref = TimeZoneRef::new(transitions, local_time_types, &[], &None)?;
316    ///
317    /// // Buffer is too small, so the results are non exhaustive
318    /// let mut small_buf = [None; 1];
319    /// assert!(!DateTime::find_n(&mut small_buf, 1970, 1, 2, 0, 30, 0, 0, time_zone_ref)?.is_exhaustive());
320    ///
321    /// // Fill buffer
322    /// let mut buf = [None; 2];
323    /// let found_date_time_list = DateTime::find_n(&mut buf, 1970, 1, 2, 0, 30, 0, 0, time_zone_ref)?;
324    /// let data = found_date_time_list.data();
325    /// assert!(found_date_time_list.is_exhaustive());
326    /// assert_eq!(found_date_time_list.count(), 2);
327    /// assert!(matches!(data, [Some(FoundDateTimeKind::Normal(..)), Some(FoundDateTimeKind::Normal(..))]));
328    ///
329    /// // We can reuse the buffer
330    /// let found_date_time_list = DateTime::find_n(&mut buf, 1970, 1, 1, 1, 30, 0, 0, time_zone_ref)?;
331    /// let data = found_date_time_list.data();
332    /// assert!(found_date_time_list.is_exhaustive());
333    /// assert_eq!(found_date_time_list.count(), 1);
334    /// assert!(found_date_time_list.unique().is_none()); // FoundDateTimeKind::Skipped
335    /// assert!(matches!(data, &[Some(FoundDateTimeKind::Skipped { .. })]));
336    /// # Ok(())
337    /// # }
338    /// ```
339    ///
340    #[allow(clippy::too_many_arguments)]
341    pub fn find_n<'a>(
342        buf: &'a mut [Option<FoundDateTimeKind>],
343        year: i32,
344        month: u8,
345        month_day: u8,
346        hour: u8,
347        minute: u8,
348        second: u8,
349        nanoseconds: u32,
350        time_zone_ref: TimeZoneRef<'_>,
351    ) -> Result<FoundDateTimeListRefMut<'a>, TzError> {
352        let mut found_date_time_list = FoundDateTimeListRefMut::new(buf);
353        find_date_time(&mut found_date_time_list, year, month, month_day, hour, minute, second, nanoseconds, time_zone_ref)?;
354        Ok(found_date_time_list)
355    }
356
357    /// Construct a date time from a Unix time in seconds with nanoseconds and a local time type
358    pub const fn from_timespec_and_local(unix_time: i64, nanoseconds: u32, local_time_type: LocalTimeType) -> Result<Self, TzError> {
359        let unix_time_with_offset = match unix_time.checked_add(local_time_type.ut_offset() as i64) {
360            Some(unix_time_with_offset) => unix_time_with_offset,
361            None => return Err(TzError::OutOfRange),
362        };
363
364        let utc_date_time_with_offset = match UtcDateTime::from_timespec(unix_time_with_offset, nanoseconds) {
365            Ok(utc_date_time_with_offset) => utc_date_time_with_offset,
366            Err(error) => return Err(error),
367        };
368
369        let UtcDateTime { year, month, month_day, hour, minute, second, nanoseconds } = utc_date_time_with_offset;
370        Ok(Self { year, month, month_day, hour, minute, second, local_time_type, unix_time, nanoseconds })
371    }
372
373    /// Construct a date time from a Unix time in seconds with nanoseconds and a time zone
374    pub const fn from_timespec(unix_time: i64, nanoseconds: u32, time_zone_ref: TimeZoneRef<'_>) -> Result<Self, TzError> {
375        let local_time_type = match time_zone_ref.find_local_time_type(unix_time) {
376            Ok(&local_time_type) => local_time_type,
377            Err(error) => return Err(error),
378        };
379
380        Self::from_timespec_and_local(unix_time, nanoseconds, local_time_type)
381    }
382
383    /// Construct a date time from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`) and a local time type
384    pub const fn from_total_nanoseconds_and_local(total_nanoseconds: i128, local_time_type: LocalTimeType) -> Result<Self, TzError> {
385        match total_nanoseconds_to_timespec(total_nanoseconds) {
386            Ok((unix_time, nanoseconds)) => Self::from_timespec_and_local(unix_time, nanoseconds, local_time_type),
387            Err(error) => Err(error),
388        }
389    }
390
391    /// Construct a date time from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`) and a time zone
392    pub const fn from_total_nanoseconds(total_nanoseconds: i128, time_zone_ref: TimeZoneRef<'_>) -> Result<Self, TzError> {
393        match total_nanoseconds_to_timespec(total_nanoseconds) {
394            Ok((unix_time, nanoseconds)) => Self::from_timespec(unix_time, nanoseconds, time_zone_ref),
395            Err(error) => Err(error),
396        }
397    }
398
399    /// Project the date time into another time zone.
400    ///
401    /// Leap seconds are not preserved.
402    ///
403    pub const fn project(&self, time_zone_ref: TimeZoneRef<'_>) -> Result<Self, TzError> {
404        Self::from_timespec(self.unix_time, self.nanoseconds, time_zone_ref)
405    }
406
407    /// Returns the current date time associated to the specified time zone
408    #[cfg(feature = "std")]
409    pub fn now(time_zone_ref: TimeZoneRef<'_>) -> Result<Self, TzError> {
410        let now = crate::utils::current_total_nanoseconds();
411        Self::from_total_nanoseconds(now, time_zone_ref)
412    }
413}
414
415/// Macro for implementing date time getters
416macro_rules! impl_datetime {
417    () => {
418        /// Returns year
419        #[inline]
420        pub const fn year(&self) -> i32 {
421            self.year
422        }
423
424        /// Returns month in `[1, 12]`
425        #[inline]
426        pub const fn month(&self) -> u8 {
427            self.month
428        }
429
430        /// Returns day of the month in `[1, 31]`
431        #[inline]
432        pub const fn month_day(&self) -> u8 {
433            self.month_day
434        }
435
436        /// Returns hours since midnight in `[0, 23]`
437        #[inline]
438        pub const fn hour(&self) -> u8 {
439            self.hour
440        }
441
442        /// Returns minutes in `[0, 59]`
443        #[inline]
444        pub const fn minute(&self) -> u8 {
445            self.minute
446        }
447
448        /// Returns seconds in `[0, 60]`, with a possible leap second
449        #[inline]
450        pub const fn second(&self) -> u8 {
451            self.second
452        }
453
454        /// Returns nanoseconds in `[0, 999_999_999]`
455        #[inline]
456        pub const fn nanoseconds(&self) -> u32 {
457            self.nanoseconds
458        }
459
460        /// Returns days since Sunday in `[0, 6]`
461        #[inline]
462        pub const fn week_day(&self) -> u8 {
463            week_day(self.year, self.month as usize, self.month_day as i64)
464        }
465
466        /// Returns days since January 1 in `[0, 365]`
467        #[inline]
468        pub const fn year_day(&self) -> u16 {
469            year_day(self.year, self.month as usize, self.month_day as i64)
470        }
471
472        /// Returns total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)
473        #[inline]
474        pub const fn total_nanoseconds(&self) -> i128 {
475            nanoseconds_since_unix_epoch(self.unix_time(), self.nanoseconds)
476        }
477    };
478}
479
480impl UtcDateTime {
481    impl_datetime!();
482}
483
484impl DateTime {
485    impl_datetime!();
486
487    /// Returns local time type
488    #[inline]
489    pub const fn local_time_type(&self) -> &LocalTimeType {
490        &self.local_time_type
491    }
492
493    /// Returns UTC Unix time in seconds
494    #[inline]
495    pub const fn unix_time(&self) -> i64 {
496        self.unix_time
497    }
498}
499
500/// Compute the number of days since Sunday in `[0, 6]`
501///
502/// ## Inputs
503///
504/// * `year`: Year
505/// * `month`: Month in `[1, 12]`
506/// * `month_day`: Day of the month in `[1, 31]`
507///
508#[inline]
509const fn week_day(year: i32, month: usize, month_day: i64) -> u8 {
510    let days_since_unix_epoch = days_since_unix_epoch(year, month, month_day);
511    (4 + days_since_unix_epoch).rem_euclid(DAYS_PER_WEEK) as u8
512}
513
514/// Compute the number of days since January 1 in `[0, 365]`
515///
516/// ## Inputs
517///
518/// * `year`: Year
519/// * `month`: Month in `[1, 12]`
520/// * `month_day`: Day of the month in `[1, 31]`
521///
522#[inline]
523const fn year_day(year: i32, month: usize, month_day: i64) -> u16 {
524    let leap = (month >= 3 && is_leap_year(year)) as i64;
525    (CUMUL_DAYS_IN_MONTHS_NORMAL_YEAR[month - 1] + leap + month_day - 1) as u16
526}
527
528/// Check if a year is a leap year
529#[inline]
530pub(crate) const fn is_leap_year(year: i32) -> bool {
531    year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)
532}
533
534/// Compute the number of days since Unix epoch (`1970-01-01T00:00:00Z`).
535///
536/// The December 32nd date is possible, which corresponds to January 1st of the next year.
537///
538/// ## Inputs
539///
540/// * `year`: Year
541/// * `month`: Month in `[1, 12]`
542/// * `month_day`: Day of the month in `[1, 32]`
543///
544#[inline]
545pub(crate) const fn days_since_unix_epoch(year: i32, month: usize, month_day: i64) -> i64 {
546    let is_leap_year = is_leap_year(year);
547
548    let year = year as i64;
549
550    let mut result = (year - 1970) * 365;
551
552    if year >= 1970 {
553        result += (year - 1968) / 4;
554        result -= (year - 1900) / 100;
555        result += (year - 1600) / 400;
556
557        if is_leap_year && month < 3 {
558            result -= 1;
559        }
560    } else {
561        result += (year - 1972) / 4;
562        result -= (year - 2000) / 100;
563        result += (year - 2000) / 400;
564
565        if is_leap_year && month >= 3 {
566            result += 1;
567        }
568    }
569
570    result += CUMUL_DAYS_IN_MONTHS_NORMAL_YEAR[month - 1] + month_day - 1;
571
572    result
573}
574
575/// Compute Unix time in seconds
576///
577/// ## Inputs
578///
579/// * `year`: Year
580/// * `month`: Month in `[1, 12]`
581/// * `month_day`: Day of the month in `[1, 31]`
582/// * `hour`: Hours since midnight in `[0, 23]`
583/// * `minute`: Minutes in `[0, 59]`
584/// * `second`: Seconds in `[0, 60]`, with a possible leap second
585///
586#[inline]
587const fn unix_time(year: i32, month: u8, month_day: u8, hour: u8, minute: u8, second: u8) -> i64 {
588    let mut result = days_since_unix_epoch(year, month as usize, month_day as i64);
589    result *= HOURS_PER_DAY;
590    result += hour as i64;
591    result *= MINUTES_PER_HOUR;
592    result += minute as i64;
593    result *= SECONDS_PER_MINUTE;
594    result += second as i64;
595
596    result
597}
598
599/// Compute the number of nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)
600#[inline]
601const fn nanoseconds_since_unix_epoch(unix_time: i64, nanoseconds: u32) -> i128 {
602    // Overflow is not possible
603    unix_time as i128 * NANOSECONDS_PER_SECOND as i128 + nanoseconds as i128
604}
605
606/// Compute Unix time in seconds with nanoseconds from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)
607///
608/// ## Outputs
609///
610/// * `unix_time`: Unix time in seconds
611/// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`
612///
613#[inline]
614const fn total_nanoseconds_to_timespec(total_nanoseconds: i128) -> Result<(i64, u32), TzError> {
615    let unix_time = match try_into_i64(total_nanoseconds.div_euclid(NANOSECONDS_PER_SECOND as i128)) {
616        Ok(unix_time) => unix_time,
617        Err(error) => return Err(error),
618    };
619
620    let nanoseconds = total_nanoseconds.rem_euclid(NANOSECONDS_PER_SECOND as i128) as u32;
621
622    Ok((unix_time, nanoseconds))
623}
624
625/// Check date time inputs
626///
627/// ## Inputs
628///
629/// * `year`: Year
630/// * `month`: Month in `[1, 12]`
631/// * `month_day`: Day of the month in `[1, 31]`
632/// * `hour`: Hours since midnight in `[0, 23]`
633/// * `minute`: Minutes in `[0, 59]`
634/// * `second`: Seconds in `[0, 60]`, with a possible leap second
635/// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`
636///
637const fn check_date_time_inputs(year: i32, month: u8, month_day: u8, hour: u8, minute: u8, second: u8, nanoseconds: u32) -> Result<(), DateTimeError> {
638    if !(1 <= month && month <= 12) {
639        return Err(DateTimeError::InvalidMonth);
640    }
641    if !(1 <= month_day && month_day <= 31) {
642        return Err(DateTimeError::InvalidMonthDay);
643    }
644    if hour > 23 {
645        return Err(DateTimeError::InvalidHour);
646    }
647    if minute > 59 {
648        return Err(DateTimeError::InvalidMinute);
649    }
650    if second > 60 {
651        return Err(DateTimeError::InvalidSecond);
652    }
653    if nanoseconds >= NANOSECONDS_PER_SECOND {
654        return Err(DateTimeError::InvalidNanoseconds);
655    }
656
657    let leap = is_leap_year(year) as i64;
658
659    let mut days_in_month = DAYS_IN_MONTHS_NORMAL_YEAR[month as usize - 1];
660    if month == 2 {
661        days_in_month += leap;
662    }
663
664    if month_day as i64 > days_in_month {
665        return Err(DateTimeError::InvalidMonthDay);
666    }
667
668    Ok(())
669}
670
671/// Format a date time
672///
673/// ## Inputs
674///
675/// * `f`: Formatter
676/// * `year`: Year
677/// * `month`: Month in `[1, 12]`
678/// * `month_day`: Day of the month in `[1, 31]`
679/// * `hour`: Hours since midnight in `[0, 23]`
680/// * `minute`: Minutes in `[0, 59]`
681/// * `second`: Seconds in `[0, 60]`, with a possible leap second
682/// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`
683/// * `ut_offset`: Offset from UTC in seconds
684///
685#[allow(clippy::too_many_arguments)]
686fn format_date_time(
687    f: &mut fmt::Formatter,
688    year: i32,
689    month: u8,
690    month_day: u8,
691    hour: u8,
692    minute: u8,
693    second: u8,
694    nanoseconds: u32,
695    ut_offset: i32,
696) -> fmt::Result {
697    write!(f, "{year}-{month:02}-{month_day:02}T{hour:02}:{minute:02}:{second:02}.{nanoseconds:09}")?;
698
699    if ut_offset != 0 {
700        let ut_offset = ut_offset as i64;
701        let ut_offset_abs = ut_offset.abs();
702
703        let sign = if ut_offset < 0 { '-' } else { '+' };
704
705        let offset_hour = ut_offset_abs / SECONDS_PER_HOUR;
706        let offset_minute = (ut_offset_abs / SECONDS_PER_MINUTE) % MINUTES_PER_HOUR;
707        let offset_second = ut_offset_abs % SECONDS_PER_MINUTE;
708
709        write!(f, "{sign}{offset_hour:02}:{offset_minute:02}")?;
710
711        if offset_second != 0 {
712            write!(f, ":{offset_second:02}")?;
713        }
714    } else {
715        write!(f, "Z")?;
716    }
717
718    Ok(())
719}
720
721#[cfg(test)]
722mod tests {
723    use super::*;
724
725    #[cfg(feature = "alloc")]
726    use crate::timezone::TimeZone;
727
728    #[cfg(feature = "alloc")]
729    pub(super) fn check_equal_date_time(x: &DateTime, y: &DateTime) {
730        assert_eq!(x.year(), y.year());
731        assert_eq!(x.month(), y.month());
732        assert_eq!(x.month_day(), y.month_day());
733        assert_eq!(x.hour(), y.hour());
734        assert_eq!(x.minute(), y.minute());
735        assert_eq!(x.second(), y.second());
736        assert_eq!(x.local_time_type(), y.local_time_type());
737        assert_eq!(x.unix_time(), y.unix_time());
738        assert_eq!(x.nanoseconds(), y.nanoseconds());
739    }
740
741    #[cfg(feature = "alloc")]
742    #[test]
743    fn test_date_time() -> Result<(), TzError> {
744        let time_zone_utc = TimeZone::utc();
745        let utc = LocalTimeType::utc();
746
747        let time_zone_cet = TimeZone::fixed(3600)?;
748        let cet = LocalTimeType::with_ut_offset(3600)?;
749
750        let time_zone_eet = TimeZone::fixed(7200)?;
751        let eet = LocalTimeType::with_ut_offset(7200)?;
752
753        #[cfg(feature = "std")]
754        {
755            assert_eq!(DateTime::now(time_zone_utc.as_ref())?.local_time_type().ut_offset(), 0);
756            assert_eq!(DateTime::now(time_zone_cet.as_ref())?.local_time_type().ut_offset(), 3600);
757            assert_eq!(DateTime::now(time_zone_eet.as_ref())?.local_time_type().ut_offset(), 7200);
758        }
759
760        let unix_times = &[
761            -93750523134,
762            -11670955134,
763            -11670868734,
764            -8515195134,
765            -8483659134,
766            -8389051134,
767            -8388964734,
768            951825666,
769            951912066,
770            983448066,
771            1078056066,
772            1078142466,
773            4107585666,
774            32540356866,
775        ];
776
777        let nanoseconds_list = &[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23];
778
779        #[rustfmt::skip]
780        let date_times_utc = &[
781            DateTime { year: -1001, month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: -93750523134, nanoseconds: 10 },
782            DateTime { year: 1600,  month: 2, month_day: 29, hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: -11670955134, nanoseconds: 11 },
783            DateTime { year: 1600,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: -11670868734, nanoseconds: 12 },
784            DateTime { year: 1700,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: -8515195134,  nanoseconds: 13 },
785            DateTime { year: 1701,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: -8483659134,  nanoseconds: 14 },
786            DateTime { year: 1704,  month: 2, month_day: 29, hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: -8389051134,  nanoseconds: 15 },
787            DateTime { year: 1704,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: -8388964734,  nanoseconds: 16 },
788            DateTime { year: 2000,  month: 2, month_day: 29, hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: 951825666,    nanoseconds: 17 },
789            DateTime { year: 2000,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: 951912066,    nanoseconds: 18 },
790            DateTime { year: 2001,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: 983448066,    nanoseconds: 19 },
791            DateTime { year: 2004,  month: 2, month_day: 29, hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: 1078056066,   nanoseconds: 20 },
792            DateTime { year: 2004,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: 1078142466,   nanoseconds: 21 },
793            DateTime { year: 2100,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: 4107585666,   nanoseconds: 22 },
794            DateTime { year: 3001,  month: 3, month_day: 1,  hour: 12, minute: 1, second: 6, local_time_type: utc, unix_time: 32540356866,  nanoseconds: 23 },
795        ];
796
797        #[rustfmt::skip]
798         let date_times_cet = &[
799            DateTime { year: -1001, month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: -93750523134, nanoseconds: 10 },
800            DateTime { year: 1600,  month: 2, month_day: 29, hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: -11670955134, nanoseconds: 11 },
801            DateTime { year: 1600,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: -11670868734, nanoseconds: 12 },
802            DateTime { year: 1700,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: -8515195134,  nanoseconds: 13 },
803            DateTime { year: 1701,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: -8483659134,  nanoseconds: 14 },
804            DateTime { year: 1704,  month: 2, month_day: 29, hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: -8389051134,  nanoseconds: 15 },
805            DateTime { year: 1704,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: -8388964734,  nanoseconds: 16 },
806            DateTime { year: 2000,  month: 2, month_day: 29, hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: 951825666,    nanoseconds: 17 },
807            DateTime { year: 2000,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: 951912066,    nanoseconds: 18 },
808            DateTime { year: 2001,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: 983448066,    nanoseconds: 19 },
809            DateTime { year: 2004,  month: 2, month_day: 29, hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: 1078056066,   nanoseconds: 20 },
810            DateTime { year: 2004,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: 1078142466,   nanoseconds: 21 },
811            DateTime { year: 2100,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: 4107585666,   nanoseconds: 22 },
812            DateTime { year: 3001,  month: 3, month_day: 1,  hour: 13, minute: 1, second: 6, local_time_type: cet, unix_time: 32540356866,  nanoseconds: 23 },
813        ];
814
815        #[rustfmt::skip]
816         let date_times_eet = &[
817            DateTime { year: -1001, month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: -93750523134, nanoseconds: 10 },
818            DateTime { year: 1600,  month: 2, month_day: 29, hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: -11670955134, nanoseconds: 11 },
819            DateTime { year: 1600,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: -11670868734, nanoseconds: 12 },
820            DateTime { year: 1700,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: -8515195134,  nanoseconds: 13 },
821            DateTime { year: 1701,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: -8483659134,  nanoseconds: 14 },
822            DateTime { year: 1704,  month: 2, month_day: 29, hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: -8389051134,  nanoseconds: 15 },
823            DateTime { year: 1704,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: -8388964734,  nanoseconds: 16 },
824            DateTime { year: 2000,  month: 2, month_day: 29, hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: 951825666,    nanoseconds: 17 },
825            DateTime { year: 2000,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: 951912066,    nanoseconds: 18 },
826            DateTime { year: 2001,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: 983448066,    nanoseconds: 19 },
827            DateTime { year: 2004,  month: 2, month_day: 29, hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: 1078056066,   nanoseconds: 20 },
828            DateTime { year: 2004,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: 1078142466,   nanoseconds: 21 },
829            DateTime { year: 2100,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: 4107585666,   nanoseconds: 22 },
830            DateTime { year: 3001,  month: 3, month_day: 1,  hour: 14, minute: 1, second: 6, local_time_type: eet, unix_time: 32540356866,  nanoseconds: 23 },
831        ];
832
833        for ((((&unix_time, &nanoseconds), date_time_utc), date_time_cet), date_time_eet) in
834            unix_times.iter().zip(nanoseconds_list).zip(date_times_utc).zip(date_times_cet).zip(date_times_eet)
835        {
836            let utc_date_time = UtcDateTime::from_timespec(unix_time, nanoseconds)?;
837
838            assert_eq!(UtcDateTime::from_timespec(utc_date_time.unix_time(), nanoseconds)?, utc_date_time);
839
840            assert_eq!(utc_date_time.year(), date_time_utc.year());
841            assert_eq!(utc_date_time.month(), date_time_utc.month());
842            assert_eq!(utc_date_time.month_day(), date_time_utc.month_day());
843            assert_eq!(utc_date_time.hour(), date_time_utc.hour());
844            assert_eq!(utc_date_time.minute(), date_time_utc.minute());
845            assert_eq!(utc_date_time.second(), date_time_utc.second());
846            assert_eq!(utc_date_time.nanoseconds(), date_time_utc.nanoseconds());
847
848            assert_eq!(utc_date_time.unix_time(), unix_time);
849            assert_eq!(date_time_utc.unix_time(), unix_time);
850            assert_eq!(date_time_cet.unix_time(), unix_time);
851            assert_eq!(date_time_eet.unix_time(), unix_time);
852
853            assert_eq!(date_time_utc, date_time_cet);
854            assert_eq!(date_time_utc, date_time_eet);
855
856            check_equal_date_time(&utc_date_time.project(time_zone_utc.as_ref())?, date_time_utc);
857            check_equal_date_time(&utc_date_time.project(time_zone_cet.as_ref())?, date_time_cet);
858            check_equal_date_time(&utc_date_time.project(time_zone_eet.as_ref())?, date_time_eet);
859
860            check_equal_date_time(&date_time_utc.project(time_zone_utc.as_ref())?, date_time_utc);
861            check_equal_date_time(&date_time_cet.project(time_zone_utc.as_ref())?, date_time_utc);
862            check_equal_date_time(&date_time_eet.project(time_zone_utc.as_ref())?, date_time_utc);
863
864            check_equal_date_time(&date_time_utc.project(time_zone_cet.as_ref())?, date_time_cet);
865            check_equal_date_time(&date_time_cet.project(time_zone_cet.as_ref())?, date_time_cet);
866            check_equal_date_time(&date_time_eet.project(time_zone_cet.as_ref())?, date_time_cet);
867
868            check_equal_date_time(&date_time_utc.project(time_zone_eet.as_ref())?, date_time_eet);
869            check_equal_date_time(&date_time_cet.project(time_zone_eet.as_ref())?, date_time_eet);
870            check_equal_date_time(&date_time_eet.project(time_zone_eet.as_ref())?, date_time_eet);
871        }
872
873        Ok(())
874    }
875
876    #[cfg(feature = "alloc")]
877    #[test]
878    fn test_date_time_leap_seconds() -> Result<(), TzError> {
879        let utc_date_time = UtcDateTime::new(1972, 6, 30, 23, 59, 60, 1000)?;
880
881        assert_eq!(UtcDateTime::from_timespec(utc_date_time.unix_time(), 1000)?, UtcDateTime::new(1972, 7, 1, 0, 0, 0, 1000)?);
882
883        let date_time = utc_date_time.project(TimeZone::fixed(-3600)?.as_ref())?;
884
885        let date_time_result = DateTime {
886            year: 1972,
887            month: 6,
888            month_day: 30,
889            hour: 23,
890            minute: 00,
891            second: 00,
892            local_time_type: LocalTimeType::with_ut_offset(-3600)?,
893            unix_time: 78796800,
894            nanoseconds: 1000,
895        };
896
897        check_equal_date_time(&date_time, &date_time_result);
898
899        Ok(())
900    }
901
902    #[cfg(feature = "alloc")]
903    #[test]
904    fn test_date_time_partial_eq_partial_ord() -> Result<(), TzError> {
905        let time_zone_utc = TimeZone::utc();
906        let time_zone_cet = TimeZone::fixed(3600)?;
907        let time_zone_eet = TimeZone::fixed(7200)?;
908
909        let utc_date_time_1 = UtcDateTime::from_timespec(1, 1)?;
910        let utc_date_time_2 = UtcDateTime::from_timespec(2, 1)?;
911        let utc_date_time_3 = UtcDateTime::from_timespec(3, 1)?;
912        let utc_date_time_4 = UtcDateTime::from_timespec(3, 1000)?;
913
914        let date_time_utc_1 = utc_date_time_1.project(time_zone_utc.as_ref())?;
915        let date_time_utc_2 = utc_date_time_2.project(time_zone_utc.as_ref())?;
916        let date_time_utc_3 = utc_date_time_3.project(time_zone_utc.as_ref())?;
917        let date_time_utc_4 = utc_date_time_4.project(time_zone_utc.as_ref())?;
918
919        let date_time_cet_1 = utc_date_time_1.project(time_zone_cet.as_ref())?;
920        let date_time_cet_2 = utc_date_time_2.project(time_zone_cet.as_ref())?;
921        let date_time_cet_3 = utc_date_time_3.project(time_zone_cet.as_ref())?;
922        let date_time_cet_4 = utc_date_time_4.project(time_zone_cet.as_ref())?;
923
924        let date_time_eet_1 = utc_date_time_1.project(time_zone_eet.as_ref())?;
925        let date_time_eet_2 = utc_date_time_2.project(time_zone_eet.as_ref())?;
926        let date_time_eet_3 = utc_date_time_3.project(time_zone_eet.as_ref())?;
927        let date_time_eet_4 = utc_date_time_4.project(time_zone_eet.as_ref())?;
928
929        assert_eq!(date_time_utc_1, date_time_cet_1);
930        assert_eq!(date_time_utc_1, date_time_eet_1);
931
932        assert_eq!(date_time_utc_2, date_time_cet_2);
933        assert_eq!(date_time_utc_2, date_time_eet_2);
934
935        assert_eq!(date_time_utc_3, date_time_cet_3);
936        assert_eq!(date_time_utc_3, date_time_eet_3);
937
938        assert_eq!(date_time_utc_4, date_time_cet_4);
939        assert_eq!(date_time_utc_4, date_time_eet_4);
940
941        assert_ne!(date_time_utc_1, date_time_utc_2);
942        assert_ne!(date_time_utc_1, date_time_utc_3);
943        assert_ne!(date_time_utc_1, date_time_utc_4);
944
945        assert_eq!(date_time_utc_1.partial_cmp(&date_time_cet_1), Some(Ordering::Equal));
946        assert_eq!(date_time_utc_1.partial_cmp(&date_time_eet_1), Some(Ordering::Equal));
947
948        assert_eq!(date_time_utc_2.partial_cmp(&date_time_cet_2), Some(Ordering::Equal));
949        assert_eq!(date_time_utc_2.partial_cmp(&date_time_eet_2), Some(Ordering::Equal));
950
951        assert_eq!(date_time_utc_3.partial_cmp(&date_time_cet_3), Some(Ordering::Equal));
952        assert_eq!(date_time_utc_3.partial_cmp(&date_time_eet_3), Some(Ordering::Equal));
953
954        assert_eq!(date_time_utc_4.partial_cmp(&date_time_cet_4), Some(Ordering::Equal));
955        assert_eq!(date_time_utc_4.partial_cmp(&date_time_eet_4), Some(Ordering::Equal));
956
957        assert_eq!(date_time_utc_1.partial_cmp(&date_time_utc_2), Some(Ordering::Less));
958        assert_eq!(date_time_utc_2.partial_cmp(&date_time_utc_3), Some(Ordering::Less));
959        assert_eq!(date_time_utc_3.partial_cmp(&date_time_utc_4), Some(Ordering::Less));
960
961        Ok(())
962    }
963
964    #[test]
965    fn test_date_time_sync_and_send() {
966        trait _AssertSyncSendStatic: Sync + Send + 'static {}
967        impl _AssertSyncSendStatic for DateTime {}
968    }
969
970    #[test]
971    fn test_utc_date_time_ord() -> Result<(), TzError> {
972        let utc_date_time_1 = UtcDateTime::new(1972, 6, 30, 23, 59, 59, 1000)?;
973        let utc_date_time_2 = UtcDateTime::new(1972, 6, 30, 23, 59, 60, 1000)?;
974        let utc_date_time_3 = UtcDateTime::new(1972, 7, 1, 0, 0, 0, 1000)?;
975        let utc_date_time_4 = UtcDateTime::new(1972, 7, 1, 0, 0, 0, 1001)?;
976
977        assert_eq!(utc_date_time_1.cmp(&utc_date_time_1), Ordering::Equal);
978        assert_eq!(utc_date_time_1.cmp(&utc_date_time_2), Ordering::Less);
979        assert_eq!(utc_date_time_1.cmp(&utc_date_time_3), Ordering::Less);
980        assert_eq!(utc_date_time_1.cmp(&utc_date_time_4), Ordering::Less);
981
982        assert_eq!(utc_date_time_2.cmp(&utc_date_time_1), Ordering::Greater);
983        assert_eq!(utc_date_time_2.cmp(&utc_date_time_2), Ordering::Equal);
984        assert_eq!(utc_date_time_2.cmp(&utc_date_time_3), Ordering::Less);
985        assert_eq!(utc_date_time_2.cmp(&utc_date_time_4), Ordering::Less);
986
987        assert_eq!(utc_date_time_3.cmp(&utc_date_time_1), Ordering::Greater);
988        assert_eq!(utc_date_time_3.cmp(&utc_date_time_2), Ordering::Greater);
989        assert_eq!(utc_date_time_3.cmp(&utc_date_time_3), Ordering::Equal);
990        assert_eq!(utc_date_time_3.cmp(&utc_date_time_4), Ordering::Less);
991
992        assert_eq!(utc_date_time_4.cmp(&utc_date_time_1), Ordering::Greater);
993        assert_eq!(utc_date_time_4.cmp(&utc_date_time_2), Ordering::Greater);
994        assert_eq!(utc_date_time_4.cmp(&utc_date_time_3), Ordering::Greater);
995        assert_eq!(utc_date_time_4.cmp(&utc_date_time_4), Ordering::Equal);
996
997        assert_eq!(utc_date_time_1.cmp(&utc_date_time_1), utc_date_time_1.unix_time().cmp(&utc_date_time_1.unix_time()));
998        assert_eq!(utc_date_time_1.cmp(&utc_date_time_2), utc_date_time_1.unix_time().cmp(&utc_date_time_2.unix_time()));
999        assert_eq!(utc_date_time_1.cmp(&utc_date_time_3), utc_date_time_1.unix_time().cmp(&utc_date_time_3.unix_time()));
1000        assert_eq!(utc_date_time_1.cmp(&utc_date_time_4), utc_date_time_1.unix_time().cmp(&utc_date_time_4.unix_time()));
1001
1002        assert_eq!(utc_date_time_2.cmp(&utc_date_time_1), utc_date_time_2.unix_time().cmp(&utc_date_time_1.unix_time()));
1003        assert_eq!(utc_date_time_2.cmp(&utc_date_time_2), utc_date_time_2.unix_time().cmp(&utc_date_time_2.unix_time()));
1004
1005        assert_eq!(utc_date_time_3.cmp(&utc_date_time_1), utc_date_time_3.unix_time().cmp(&utc_date_time_1.unix_time()));
1006        assert_eq!(utc_date_time_3.cmp(&utc_date_time_3), utc_date_time_3.unix_time().cmp(&utc_date_time_3.unix_time()));
1007
1008        assert_eq!(utc_date_time_4.cmp(&utc_date_time_1), utc_date_time_4.unix_time().cmp(&utc_date_time_1.unix_time()));
1009        assert_eq!(utc_date_time_4.cmp(&utc_date_time_4), utc_date_time_4.unix_time().cmp(&utc_date_time_4.unix_time()));
1010
1011        Ok(())
1012    }
1013
1014    #[cfg(feature = "alloc")]
1015    #[test]
1016    fn test_date_time_format() -> Result<(), TzError> {
1017        use alloc::string::ToString;
1018
1019        let time_zones = [
1020            TimeZone::fixed(-49550)?,
1021            TimeZone::fixed(-5400)?,
1022            TimeZone::fixed(-3600)?,
1023            TimeZone::fixed(-1800)?,
1024            TimeZone::fixed(0)?,
1025            TimeZone::fixed(1800)?,
1026            TimeZone::fixed(3600)?,
1027            TimeZone::fixed(5400)?,
1028            TimeZone::fixed(49550)?,
1029        ];
1030
1031        let utc_date_times = &[UtcDateTime::new(2000, 1, 2, 3, 4, 5, 0)?, UtcDateTime::new(2000, 1, 2, 3, 4, 5, 123_456_789)?];
1032
1033        let utc_date_time_strings = &["2000-01-02T03:04:05.000000000Z", "2000-01-02T03:04:05.123456789Z"];
1034
1035        let date_time_strings_list = &[
1036            &[
1037                "2000-01-01T13:18:15.000000000-13:45:50",
1038                "2000-01-02T01:34:05.000000000-01:30",
1039                "2000-01-02T02:04:05.000000000-01:00",
1040                "2000-01-02T02:34:05.000000000-00:30",
1041                "2000-01-02T03:04:05.000000000Z",
1042                "2000-01-02T03:34:05.000000000+00:30",
1043                "2000-01-02T04:04:05.000000000+01:00",
1044                "2000-01-02T04:34:05.000000000+01:30",
1045                "2000-01-02T16:49:55.000000000+13:45:50",
1046            ],
1047            &[
1048                "2000-01-01T13:18:15.123456789-13:45:50",
1049                "2000-01-02T01:34:05.123456789-01:30",
1050                "2000-01-02T02:04:05.123456789-01:00",
1051                "2000-01-02T02:34:05.123456789-00:30",
1052                "2000-01-02T03:04:05.123456789Z",
1053                "2000-01-02T03:34:05.123456789+00:30",
1054                "2000-01-02T04:04:05.123456789+01:00",
1055                "2000-01-02T04:34:05.123456789+01:30",
1056                "2000-01-02T16:49:55.123456789+13:45:50",
1057            ],
1058        ];
1059
1060        for ((utc_date_time, &utc_date_time_string), &date_time_strings) in utc_date_times.iter().zip(utc_date_time_strings).zip(date_time_strings_list) {
1061            for (time_zone, &date_time_string) in time_zones.iter().zip(date_time_strings) {
1062                assert_eq!(utc_date_time.to_string(), utc_date_time_string);
1063                assert_eq!(utc_date_time.project(time_zone.as_ref())?.to_string(), date_time_string);
1064            }
1065        }
1066
1067        Ok(())
1068    }
1069
1070    #[cfg(feature = "alloc")]
1071    #[test]
1072    fn test_date_time_overflow() -> Result<(), TzError> {
1073        assert!(UtcDateTime::new(i32::MIN, 1, 1, 0, 0, 0, 0).is_ok());
1074        assert!(UtcDateTime::new(i32::MAX, 12, 31, 23, 59, 59, 0).is_ok());
1075
1076        assert!(DateTime::new(i32::MIN, 1, 1, 0, 0, 0, 0, LocalTimeType::utc()).is_ok());
1077        assert!(DateTime::new(i32::MAX, 12, 31, 23, 59, 59, 0, LocalTimeType::utc()).is_ok());
1078
1079        assert!(matches!(DateTime::new(i32::MIN, 1, 1, 0, 0, 0, 0, LocalTimeType::with_ut_offset(1)?), Err(TzError::OutOfRange)));
1080        assert!(matches!(DateTime::new(i32::MAX, 12, 31, 23, 59, 59, 0, LocalTimeType::with_ut_offset(-1)?), Err(TzError::OutOfRange)));
1081
1082        assert!(matches!(UtcDateTime::new(i32::MAX, 12, 31, 23, 59, 60, 0), Err(TzError::OutOfRange)));
1083        assert!(matches!(DateTime::new(i32::MAX, 12, 31, 23, 59, 60, 0, LocalTimeType::utc()), Err(TzError::OutOfRange)));
1084        assert!(DateTime::new(i32::MAX, 12, 31, 23, 59, 60, 0, LocalTimeType::with_ut_offset(1)?).is_ok());
1085
1086        assert!(UtcDateTime::from_timespec(UtcDateTime::MIN_UNIX_TIME, 0).is_ok());
1087        assert!(UtcDateTime::from_timespec(UtcDateTime::MAX_UNIX_TIME, 0).is_ok());
1088
1089        assert!(matches!(UtcDateTime::from_timespec(UtcDateTime::MIN_UNIX_TIME - 1, 0), Err(TzError::OutOfRange)));
1090        assert!(matches!(UtcDateTime::from_timespec(UtcDateTime::MAX_UNIX_TIME + 1, 0), Err(TzError::OutOfRange)));
1091
1092        assert!(matches!(UtcDateTime::from_timespec(UtcDateTime::MIN_UNIX_TIME, 0)?.project(TimeZone::fixed(-1)?.as_ref()), Err(TzError::OutOfRange)));
1093        assert!(matches!(UtcDateTime::from_timespec(UtcDateTime::MAX_UNIX_TIME, 0)?.project(TimeZone::fixed(1)?.as_ref()), Err(TzError::OutOfRange)));
1094
1095        assert!(matches!(UtcDateTime::from_timespec(i64::MIN, 0), Err(TzError::OutOfRange)));
1096        assert!(matches!(UtcDateTime::from_timespec(i64::MAX, 0), Err(TzError::OutOfRange)));
1097
1098        assert!(DateTime::from_timespec(UtcDateTime::MIN_UNIX_TIME, 0, TimeZone::fixed(0)?.as_ref()).is_ok());
1099        assert!(DateTime::from_timespec(UtcDateTime::MAX_UNIX_TIME, 0, TimeZone::fixed(0)?.as_ref()).is_ok());
1100
1101        assert!(matches!(DateTime::from_timespec(i64::MIN, 0, TimeZone::fixed(-1)?.as_ref()), Err(TzError::OutOfRange)));
1102        assert!(matches!(DateTime::from_timespec(i64::MAX, 0, TimeZone::fixed(1)?.as_ref()), Err(TzError::OutOfRange)));
1103
1104        Ok(())
1105    }
1106
1107    #[test]
1108    fn test_week_day() {
1109        assert_eq!(week_day(1970, 1, 1), 4);
1110
1111        assert_eq!(week_day(2000, 1, 1), 6);
1112        assert_eq!(week_day(2000, 2, 28), 1);
1113        assert_eq!(week_day(2000, 2, 29), 2);
1114        assert_eq!(week_day(2000, 3, 1), 3);
1115        assert_eq!(week_day(2000, 12, 31), 0);
1116
1117        assert_eq!(week_day(2001, 1, 1), 1);
1118        assert_eq!(week_day(2001, 2, 28), 3);
1119        assert_eq!(week_day(2001, 3, 1), 4);
1120        assert_eq!(week_day(2001, 12, 31), 1);
1121    }
1122
1123    #[test]
1124    fn test_year_day() {
1125        assert_eq!(year_day(2000, 1, 1), 0);
1126        assert_eq!(year_day(2000, 2, 28), 58);
1127        assert_eq!(year_day(2000, 2, 29), 59);
1128        assert_eq!(year_day(2000, 3, 1), 60);
1129        assert_eq!(year_day(2000, 12, 31), 365);
1130
1131        assert_eq!(year_day(2001, 1, 1), 0);
1132        assert_eq!(year_day(2001, 2, 28), 58);
1133        assert_eq!(year_day(2001, 3, 1), 59);
1134        assert_eq!(year_day(2001, 12, 31), 364);
1135    }
1136
1137    #[test]
1138    fn test_is_leap_year() {
1139        assert!(is_leap_year(2000));
1140        assert!(!is_leap_year(2001));
1141        assert!(is_leap_year(2004));
1142        assert!(!is_leap_year(2100));
1143        assert!(!is_leap_year(2200));
1144        assert!(!is_leap_year(2300));
1145        assert!(is_leap_year(2400));
1146    }
1147
1148    #[test]
1149    fn test_days_since_unix_epoch() {
1150        assert_eq!(days_since_unix_epoch(-1001, 3, 1), -1085076);
1151        assert_eq!(days_since_unix_epoch(1600, 2, 29), -135081);
1152        assert_eq!(days_since_unix_epoch(1600, 3, 1), -135080);
1153        assert_eq!(days_since_unix_epoch(1700, 3, 1), -98556);
1154        assert_eq!(days_since_unix_epoch(1701, 3, 1), -98191);
1155        assert_eq!(days_since_unix_epoch(1704, 2, 29), -97096);
1156        assert_eq!(days_since_unix_epoch(2000, 2, 29), 11016);
1157        assert_eq!(days_since_unix_epoch(2000, 3, 1), 11017);
1158        assert_eq!(days_since_unix_epoch(2001, 3, 1), 11382);
1159        assert_eq!(days_since_unix_epoch(2004, 2, 29), 12477);
1160        assert_eq!(days_since_unix_epoch(2100, 3, 1), 47541);
1161        assert_eq!(days_since_unix_epoch(3001, 3, 1), 376624);
1162    }
1163
1164    #[test]
1165    fn test_nanoseconds_since_unix_epoch() {
1166        assert_eq!(nanoseconds_since_unix_epoch(1, 1000), 1_000_001_000);
1167        assert_eq!(nanoseconds_since_unix_epoch(0, 1000), 1000);
1168        assert_eq!(nanoseconds_since_unix_epoch(-1, 1000), -999_999_000);
1169        assert_eq!(nanoseconds_since_unix_epoch(-2, 1000), -1_999_999_000);
1170    }
1171
1172    #[test]
1173    fn test_total_nanoseconds_to_timespec() -> Result<(), TzError> {
1174        assert!(matches!(total_nanoseconds_to_timespec(1_000_001_000), Ok((1, 1000))));
1175        assert!(matches!(total_nanoseconds_to_timespec(1000), Ok((0, 1000))));
1176        assert!(matches!(total_nanoseconds_to_timespec(-999_999_000), Ok((-1, 1000))));
1177        assert!(matches!(total_nanoseconds_to_timespec(-1_999_999_000), Ok((-2, 1000))));
1178
1179        assert!(matches!(total_nanoseconds_to_timespec(i128::MAX), Err(TzError::OutOfRange)));
1180        assert!(matches!(total_nanoseconds_to_timespec(i128::MIN), Err(TzError::OutOfRange)));
1181
1182        let min_total_nanoseconds = -9223372036854775808000000000;
1183        let max_total_nanoseconds = 9223372036854775807999999999;
1184
1185        assert!(matches!(total_nanoseconds_to_timespec(min_total_nanoseconds), Ok((i64::MIN, 0))));
1186        assert!(matches!(total_nanoseconds_to_timespec(max_total_nanoseconds), Ok((i64::MAX, 999999999))));
1187
1188        assert!(matches!(total_nanoseconds_to_timespec(min_total_nanoseconds - 1), Err(TzError::OutOfRange)));
1189        assert!(matches!(total_nanoseconds_to_timespec(max_total_nanoseconds + 1), Err(TzError::OutOfRange)));
1190
1191        Ok(())
1192    }
1193
1194    #[test]
1195    fn test_const() -> Result<(), TzError> {
1196        use crate::timezone::{AlternateTime, LeapSecond, MonthWeekDay, RuleDay, Transition, TransitionRule};
1197
1198        macro_rules! unwrap {
1199            ($x:expr) => {
1200                match $x {
1201                    Ok(x) => x,
1202                    Err(_) => panic!(),
1203                }
1204            };
1205        }
1206
1207        const TIME_ZONE_REF: TimeZoneRef<'static> = unwrap!(TimeZoneRef::new(
1208            &[
1209                Transition::new(-2334101314, 1),
1210                Transition::new(-1157283000, 2),
1211                Transition::new(-1155436200, 1),
1212                Transition::new(-880198200, 3),
1213                Transition::new(-769395600, 4),
1214                Transition::new(-765376200, 1),
1215                Transition::new(-712150200, 5),
1216            ],
1217            const {
1218                &[
1219                    unwrap!(LocalTimeType::new(-37886, false, Some(b"LMT"))),
1220                    unwrap!(LocalTimeType::new(-37800, false, Some(b"HST"))),
1221                    unwrap!(LocalTimeType::new(-34200, true, Some(b"HDT"))),
1222                    unwrap!(LocalTimeType::new(-34200, true, Some(b"HWT"))),
1223                    unwrap!(LocalTimeType::new(-34200, true, Some(b"HPT"))),
1224                    unwrap!(LocalTimeType::new(-36000, false, Some(b"HST"))),
1225                ]
1226            },
1227            &[
1228                LeapSecond::new(78796800, 1),
1229                LeapSecond::new(94694401, 2),
1230                LeapSecond::new(126230402, 3),
1231                LeapSecond::new(157766403, 4),
1232                LeapSecond::new(189302404, 5),
1233                LeapSecond::new(220924805, 6),
1234            ],
1235            const {
1236                &Some(TransitionRule::Alternate(unwrap!(AlternateTime::new(
1237                    unwrap!(LocalTimeType::new(-36000, false, Some(b"HST"))),
1238                    unwrap!(LocalTimeType::new(-34200, true, Some(b"HPT"))),
1239                    RuleDay::MonthWeekDay(unwrap!(MonthWeekDay::new(10, 5, 0))),
1240                    93600,
1241                    RuleDay::MonthWeekDay(unwrap!(MonthWeekDay::new(3, 4, 4))),
1242                    7200,
1243                ))))
1244            },
1245        ));
1246
1247        const UTC: TimeZoneRef<'static> = TimeZoneRef::utc();
1248
1249        const UNIX_EPOCH: UtcDateTime = unwrap!(UtcDateTime::from_timespec(0, 0));
1250        const UTC_DATE_TIME: UtcDateTime = unwrap!(UtcDateTime::new(2000, 1, 1, 0, 0, 0, 1000));
1251
1252        const DATE_TIME: DateTime = unwrap!(DateTime::new(2000, 1, 1, 1, 0, 0, 1000, unwrap!(LocalTimeType::with_ut_offset(3600))));
1253
1254        const DATE_TIME_1: DateTime = unwrap!(UTC_DATE_TIME.project(TIME_ZONE_REF));
1255        const DATE_TIME_2: DateTime = unwrap!(DATE_TIME_1.project(UTC));
1256
1257        const LOCAL_TIME_TYPE_1: &LocalTimeType = DATE_TIME_1.local_time_type();
1258        const LOCAL_TIME_TYPE_2: &LocalTimeType = DATE_TIME_2.local_time_type();
1259
1260        assert_eq!(UNIX_EPOCH.unix_time(), 0);
1261        assert_eq!(DATE_TIME.unix_time(), UTC_DATE_TIME.unix_time());
1262        assert_eq!(DATE_TIME_2.unix_time(), UTC_DATE_TIME.unix_time());
1263        assert_eq!(DATE_TIME_2.nanoseconds(), UTC_DATE_TIME.nanoseconds());
1264
1265        let date_time = UTC_DATE_TIME.project(TIME_ZONE_REF)?;
1266        assert_eq!(date_time.local_time_type().time_zone_designation(), LOCAL_TIME_TYPE_1.time_zone_designation());
1267
1268        let date_time_1 = DateTime::from_timespec(UTC_DATE_TIME.unix_time(), 1000, TIME_ZONE_REF)?;
1269        let date_time_2 = date_time_1.project(UTC)?;
1270
1271        assert_eq!(date_time, DATE_TIME_1);
1272        assert_eq!(date_time_1, DATE_TIME_1);
1273        assert_eq!(date_time_2, DATE_TIME_2);
1274
1275        let local_time_type_1 = date_time_1.local_time_type();
1276        let local_time_type_2 = date_time_2.local_time_type();
1277
1278        assert_eq!(local_time_type_1.ut_offset(), LOCAL_TIME_TYPE_1.ut_offset());
1279        assert_eq!(local_time_type_1.is_dst(), LOCAL_TIME_TYPE_1.is_dst());
1280        assert_eq!(local_time_type_1.time_zone_designation(), LOCAL_TIME_TYPE_1.time_zone_designation());
1281
1282        assert_eq!(local_time_type_2.ut_offset(), LOCAL_TIME_TYPE_2.ut_offset());
1283        assert_eq!(local_time_type_2.is_dst(), LOCAL_TIME_TYPE_2.is_dst());
1284        assert_eq!(local_time_type_2.time_zone_designation(), LOCAL_TIME_TYPE_2.time_zone_designation());
1285
1286        Ok(())
1287    }
1288}
tz/datetime/mod.rs

tz/datetime/
mod.rs
