From 4d87d7f1f844023ef80dcd305690175d4654bf1a Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Wed, 21 Apr 2021 19:08:21 +0200 Subject: [PATCH 01/29] Add elapsed_years() to Date --- src/date.rs | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/src/date.rs b/src/date.rs index a12f383a18..4ec69afe05 100644 --- a/src/date.rs +++ b/src/date.rs @@ -9,6 +9,7 @@ use core::cmp::Ordering; use core::ops::{Add, Sub}; use core::{fmt, hash}; use oldtime::Duration as OldDuration; +use std::convert::TryFrom; #[cfg(feature = "unstable-locales")] use format::Locale; @@ -271,6 +272,19 @@ impl Date { pub fn naive_local(&self) -> NaiveDate { self.date } + + /// Retrieve the elapsed years from now to the given Date + pub fn elapsed_years(&self) -> u32 { + let now = Utc::today(); + + let years = if (now.month(), now.day()) < (self.month(), self.day()) { + now.year() - self.year() - 1 + } else { + now.year() - self.year() + }; + + u32::try_from(years).unwrap_or(0) + } } /// Maps the local date to other date with given conversion function. @@ -494,3 +508,28 @@ where write!(f, "{}{}", self.naive_local(), self.offset) } } + +#[cfg(test)] +mod tests { + use offset::TimeZone; + use offset::Utc; + use std::convert::TryFrom; + use Datelike; + + #[test] + fn test_years_elapsed() { + assert_eq!( + Utc.ymd(2011, 5, 15).elapsed_years(), + u32::try_from(Utc.ymd(2021, 4, 21).year() - 2012).unwrap() + ); + assert_eq!( + Utc.ymd(2021, 4, 21).elapsed_years(), + u32::try_from(Utc.ymd(2021, 4, 21).year() - 2021).unwrap() + ); + assert_eq!( + Utc.ymd(2015, 3, 15).elapsed_years(), + u32::try_from(Utc.ymd(2021, 4, 21).year() - 2015).unwrap() + ); + assert_eq!(Utc.ymd(2034, 5, 15).elapsed_years(), 0); + } +} From b3ee27805b499ce0558083066c428a7c6152b544 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Wed, 21 Apr 2021 19:20:47 +0200 Subject: [PATCH 02/29] Add elapsed_years() to DateTime --- src/datetime.rs | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/src/datetime.rs b/src/datetime.rs index 1b8ccbb426..c93752a634 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -7,6 +7,7 @@ use core::cmp::Ordering; use core::ops::{Add, Sub}; use core::{fmt, hash, str}; use oldtime::Duration as OldDuration; +use std::convert::TryFrom; #[cfg(any(feature = "std", test))] use std::time::{SystemTime, UNIX_EPOCH}; @@ -308,6 +309,21 @@ impl DateTime { pub fn naive_local(&self) -> NaiveDateTime { self.datetime + self.offset.fix() } + + /// Retrieve the elapsed years from now to the given DateTime + pub fn elapsed_years(&self) -> u32 { + let now = Utc::now(); + + let years = if (now.month(), now.day(), now.hour(), now.minute(), now.second()) + < (self.month(), self.day(), self.hour(), self.minute(), self.second()) + { + now.year() - self.year() - 1 + } else { + now.year() - self.year() + }; + + u32::try_from(years).unwrap_or(0) + } } impl Default for DateTime { @@ -2431,6 +2447,7 @@ mod tests { use offset::Local; use offset::{FixedOffset, TimeZone, Utc}; use oldtime::Duration; + use std::convert::TryFrom; use std::time::{SystemTime, UNIX_EPOCH}; #[cfg(feature = "clock")] use Datelike; @@ -2842,4 +2859,21 @@ mod tests { assert_eq!(format!("{} ", ymd_formatted), format!("{:<17}", ymd)); assert_eq!(format!(" {} ", ymd_formatted), format!("{:^17}", ymd)); } + + #[test] + fn test_years_elapsed() { + assert_eq!( + Utc.ymd(2011, 5, 15).and_hms(6, 34, 0).elapsed_years(), + u32::try_from(Utc.ymd(2021, 4, 21).and_hms(23, 17, 0).year() - 2012).unwrap() + ); + assert_eq!( + Utc.ymd(2021, 4, 21).and_hms(3, 24, 0).elapsed_years(), + u32::try_from(Utc.ymd(2021, 4, 21).and_hms(11, 12, 0).year() - 2021).unwrap() + ); + assert_eq!( + Utc.ymd(2015, 3, 15).and_hms(16, 48, 0).elapsed_years(), + u32::try_from(Utc.ymd(2021, 4, 21).and_hms(9, 7, 0).year() - 2015).unwrap() + ); + assert_eq!(Utc.ymd(2034, 5, 15).and_hms(0, 34, 0).elapsed_years(), 0); + } } From a493f262db190899cdeaeb4b36fa3e9e0974e074 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Wed, 21 Apr 2021 19:38:07 +0200 Subject: [PATCH 03/29] Add elapsed_years() to NaiveDateTime --- src/naive/date.rs | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/src/naive/date.rs b/src/naive/date.rs index 989254ae5f..3aa0989daa 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -8,7 +8,9 @@ use core::borrow::Borrow; use core::ops::{Add, AddAssign, Sub, SubAssign}; use core::{fmt, str}; use num_traits::ToPrimitive; +use offset::Utc; use oldtime::Duration as OldDuration; +use std::convert::TryFrom; use div::div_mod_floor; #[cfg(any(feature = "alloc", feature = "std", test))] @@ -1097,6 +1099,19 @@ impl NaiveDate { pub fn iter_weeks(&self) -> NaiveDateWeeksIterator { NaiveDateWeeksIterator { value: *self } } + + /// Retrieve the elapsed years from now to the given DateTime + pub fn elapsed_years(&self) -> u32 { + let now = Utc::now().naive_utc().date(); + + let years = if (now.month(), now.day()) < (self.month(), self.day()) { + now.year() - self.year() - 1 + } else { + now.year() - self.year() + }; + + u32::try_from(years).unwrap_or(0) + } } impl Datelike for NaiveDate { @@ -1906,7 +1921,9 @@ mod tests { use super::NaiveDate; use super::{MAX_DATE, MAX_DAYS_FROM_YEAR_0, MAX_YEAR}; use super::{MIN_DATE, MIN_DAYS_FROM_YEAR_0, MIN_YEAR}; + use offset::Utc; use oldtime::Duration; + use std::convert::TryFrom; use std::{i32, u32}; use {Datelike, Weekday}; @@ -2405,4 +2422,21 @@ mod tests { 2 ); } + + #[test] + fn test_years_elapsed() { + assert_eq!( + NaiveDate::from_ymd(2011, 5, 15).elapsed_years(), + u32::try_from(NaiveDate::from_ymd(2021, 4, 21).year() - 2012).unwrap() + ); + assert_eq!( + NaiveDate::from_ymd(2021, 4, 21).elapsed_years(), + u32::try_from(NaiveDate::from_ymd(2021, 4, 21).year() - 2021).unwrap() + ); + assert_eq!( + NaiveDate::from_ymd(2015, 3, 15).elapsed_years(), + u32::try_from(NaiveDate::from_ymd(2021, 4, 21).year() - 2015).unwrap() + ); + assert_eq!(NaiveDate::from_ymd(2034, 5, 15).elapsed_years(), 0); + } } From 54274a2cfa832edd307195766393cc92222e90fb Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Wed, 21 Apr 2021 19:42:05 +0200 Subject: [PATCH 04/29] Oops --- src/naive/date.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/naive/date.rs b/src/naive/date.rs index 3aa0989daa..ac7254f82b 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -1100,7 +1100,7 @@ impl NaiveDate { NaiveDateWeeksIterator { value: *self } } - /// Retrieve the elapsed years from now to the given DateTime + /// Retrieve the elapsed years from now to the given NaiveDate pub fn elapsed_years(&self) -> u32 { let now = Utc::now().naive_utc().date(); From fb25a77929e496238d1dfdde8d8f2c63604443b4 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Wed, 21 Apr 2021 19:51:59 +0200 Subject: [PATCH 05/29] Add elapsed_years() to NaiveDateTime --- src/naive/datetime.rs | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index db23f54037..46b0653873 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -8,7 +8,9 @@ use core::borrow::Borrow; use core::ops::{Add, AddAssign, Sub, SubAssign}; use core::{fmt, hash, str}; use num_traits::ToPrimitive; +use offset::Utc; use oldtime::Duration as OldDuration; +use std::convert::TryFrom; use div::div_mod_floor; #[cfg(any(feature = "alloc", feature = "std", test))] @@ -724,6 +726,21 @@ impl NaiveDateTime { pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat> { self.format_with_items(StrftimeItems::new(fmt)) } + + /// Retrieve the elapsed years from now to the given NaiveDateTime + pub fn elapsed_years(&self) -> u32 { + let now = Utc::now().naive_utc(); + + let years = if (now.month(), now.day(), now.hour(), now.minute(), now.second()) + < (self.month(), self.day(), self.hour(), self.minute(), self.second()) + { + now.year() - self.year() - 1 + } else { + now.year() - self.year() + }; + + u32::try_from(years).unwrap_or(0) + } } impl Datelike for NaiveDateTime { @@ -2279,6 +2296,7 @@ mod tests { use super::NaiveDateTime; use naive::{NaiveDate, MAX_DATE, MIN_DATE}; use oldtime::Duration; + use std::convert::TryFrom; use std::i64; use Datelike; @@ -2535,4 +2553,23 @@ mod tests { NaiveDateTime::from_timestamp(nanos / A_BILLION, (nanos % A_BILLION) as u32) ); } + + #[test] + fn test_years_elapsed() { + assert_eq!( + NaiveDate::from_ymd(2011, 5, 15).and_hms(6, 34, 0).elapsed_years(), + u32::try_from(NaiveDate::from_ymd(2021, 4, 21).and_hms(23, 17, 0).year() - 2012) + .unwrap() + ); + assert_eq!( + NaiveDate::from_ymd(2021, 4, 21).and_hms(3, 24, 0).elapsed_years(), + u32::try_from(NaiveDate::from_ymd(2021, 4, 21).and_hms(11, 12, 0).year() - 2021) + .unwrap() + ); + assert_eq!( + NaiveDate::from_ymd(2015, 3, 15).and_hms(16, 48, 0).elapsed_years(), + u32::try_from(NaiveDate::from_ymd(2021, 4, 21).and_hms(9, 7, 0).year() - 2015).unwrap() + ); + assert_eq!(NaiveDate::from_ymd(2034, 5, 15).and_hms(0, 34, 0).elapsed_years(), 0); + } } From f059cb370216ed4bdab01f04b83c888619c2b1c3 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Sun, 25 Apr 2021 14:18:11 +0200 Subject: [PATCH 06/29] WIP --- src/datetime.rs | 13 ++++++------- src/naive/date.rs | 1 - src/naive/datetime.rs | 13 ++++++------- 3 files changed, 12 insertions(+), 15 deletions(-) diff --git a/src/datetime.rs b/src/datetime.rs index c93752a634..01dfc1a841 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -314,13 +314,12 @@ impl DateTime { pub fn elapsed_years(&self) -> u32 { let now = Utc::now(); - let years = if (now.month(), now.day(), now.hour(), now.minute(), now.second()) - < (self.month(), self.day(), self.hour(), self.minute(), self.second()) - { - now.year() - self.year() - 1 - } else { - now.year() - self.year() - }; + let years = + if (now.month(), now.day(), now.time()) < (self.month(), self.day(), self.time()) { + now.year() - self.year() - 1 + } else { + now.year() - self.year() + }; u32::try_from(years).unwrap_or(0) } diff --git a/src/naive/date.rs b/src/naive/date.rs index ac7254f82b..fe72a1b9ea 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -1921,7 +1921,6 @@ mod tests { use super::NaiveDate; use super::{MAX_DATE, MAX_DAYS_FROM_YEAR_0, MAX_YEAR}; use super::{MIN_DATE, MIN_DAYS_FROM_YEAR_0, MIN_YEAR}; - use offset::Utc; use oldtime::Duration; use std::convert::TryFrom; use std::{i32, u32}; diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index 46b0653873..490baa4dbf 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -731,13 +731,12 @@ impl NaiveDateTime { pub fn elapsed_years(&self) -> u32 { let now = Utc::now().naive_utc(); - let years = if (now.month(), now.day(), now.hour(), now.minute(), now.second()) - < (self.month(), self.day(), self.hour(), self.minute(), self.second()) - { - now.year() - self.year() - 1 - } else { - now.year() - self.year() - }; + let years = + if (now.month(), now.day(), now.time()) < (self.month(), self.day(), self.time()) { + now.year() - self.year() - 1 + } else { + now.year() - self.year() + }; u32::try_from(years).unwrap_or(0) } From a5ce0b96a4838116766d54716c2565b0d1f2ff30 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Mon, 26 Apr 2021 16:14:29 +0200 Subject: [PATCH 07/29] Remove elapsed_years from naive Date and DateTime --- src/naive/date.rs | 30 ------------------------------ src/naive/datetime.rs | 33 --------------------------------- 2 files changed, 63 deletions(-) diff --git a/src/naive/date.rs b/src/naive/date.rs index fe72a1b9ea..fca907f95e 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -1099,19 +1099,6 @@ impl NaiveDate { pub fn iter_weeks(&self) -> NaiveDateWeeksIterator { NaiveDateWeeksIterator { value: *self } } - - /// Retrieve the elapsed years from now to the given NaiveDate - pub fn elapsed_years(&self) -> u32 { - let now = Utc::now().naive_utc().date(); - - let years = if (now.month(), now.day()) < (self.month(), self.day()) { - now.year() - self.year() - 1 - } else { - now.year() - self.year() - }; - - u32::try_from(years).unwrap_or(0) - } } impl Datelike for NaiveDate { @@ -2421,21 +2408,4 @@ mod tests { 2 ); } - - #[test] - fn test_years_elapsed() { - assert_eq!( - NaiveDate::from_ymd(2011, 5, 15).elapsed_years(), - u32::try_from(NaiveDate::from_ymd(2021, 4, 21).year() - 2012).unwrap() - ); - assert_eq!( - NaiveDate::from_ymd(2021, 4, 21).elapsed_years(), - u32::try_from(NaiveDate::from_ymd(2021, 4, 21).year() - 2021).unwrap() - ); - assert_eq!( - NaiveDate::from_ymd(2015, 3, 15).elapsed_years(), - u32::try_from(NaiveDate::from_ymd(2021, 4, 21).year() - 2015).unwrap() - ); - assert_eq!(NaiveDate::from_ymd(2034, 5, 15).elapsed_years(), 0); - } } diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index 490baa4dbf..5aa4b39de8 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -726,20 +726,6 @@ impl NaiveDateTime { pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat> { self.format_with_items(StrftimeItems::new(fmt)) } - - /// Retrieve the elapsed years from now to the given NaiveDateTime - pub fn elapsed_years(&self) -> u32 { - let now = Utc::now().naive_utc(); - - let years = - if (now.month(), now.day(), now.time()) < (self.month(), self.day(), self.time()) { - now.year() - self.year() - 1 - } else { - now.year() - self.year() - }; - - u32::try_from(years).unwrap_or(0) - } } impl Datelike for NaiveDateTime { @@ -2552,23 +2538,4 @@ mod tests { NaiveDateTime::from_timestamp(nanos / A_BILLION, (nanos % A_BILLION) as u32) ); } - - #[test] - fn test_years_elapsed() { - assert_eq!( - NaiveDate::from_ymd(2011, 5, 15).and_hms(6, 34, 0).elapsed_years(), - u32::try_from(NaiveDate::from_ymd(2021, 4, 21).and_hms(23, 17, 0).year() - 2012) - .unwrap() - ); - assert_eq!( - NaiveDate::from_ymd(2021, 4, 21).and_hms(3, 24, 0).elapsed_years(), - u32::try_from(NaiveDate::from_ymd(2021, 4, 21).and_hms(11, 12, 0).year() - 2021) - .unwrap() - ); - assert_eq!( - NaiveDate::from_ymd(2015, 3, 15).and_hms(16, 48, 0).elapsed_years(), - u32::try_from(NaiveDate::from_ymd(2021, 4, 21).and_hms(9, 7, 0).year() - 2015).unwrap() - ); - assert_eq!(NaiveDate::from_ymd(2034, 5, 15).and_hms(0, 34, 0).elapsed_years(), 0); - } } From 73eac80dda6c27802a065738ed5734e29a24e3ba Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 13:09:33 +0200 Subject: [PATCH 08/29] Add a consts module with WEEK_PER_YEAR --- src/lib.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/lib.rs b/src/lib.rs index a645639eeb..bcd89139f8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -594,6 +594,20 @@ mod datetime; pub mod format; mod round; +/// Constants that can be used by all components. +pub mod consts { + /// Constants of type `f32`. + pub mod f32 { + /// Number of weeks in a year. + pub const WEEK_PER_YEAR: f32 = 52.1775; + } + /// Constants of type `f64`. + pub mod f64 { + /// Number of weeks in a year. + pub const WEEK_PER_YEAR: f64 = 52.1775; + } +} + #[cfg(feature = "__internal_bench")] #[doc(hidden)] pub use naive::__BenchYearFlags; From 351c1cf918cd8fdb192e991f8eadde55645bbefa Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 13:48:37 +0200 Subject: [PATCH 09/29] Add better tests --- src/date.rs | 26 ++++++++++---------------- src/datetime.rs | 25 +++++++++++-------------- 2 files changed, 21 insertions(+), 30 deletions(-) diff --git a/src/date.rs b/src/date.rs index 4ec69afe05..aaaacd26ed 100644 --- a/src/date.rs +++ b/src/date.rs @@ -511,25 +511,19 @@ where #[cfg(test)] mod tests { - use offset::TimeZone; + use consts::f64; use offset::Utc; - use std::convert::TryFrom; - use Datelike; + use oldtime::Duration; #[test] fn test_years_elapsed() { - assert_eq!( - Utc.ymd(2011, 5, 15).elapsed_years(), - u32::try_from(Utc.ymd(2021, 4, 21).year() - 2012).unwrap() - ); - assert_eq!( - Utc.ymd(2021, 4, 21).elapsed_years(), - u32::try_from(Utc.ymd(2021, 4, 21).year() - 2021).unwrap() - ); - assert_eq!( - Utc.ymd(2015, 3, 15).elapsed_years(), - u32::try_from(Utc.ymd(2021, 4, 21).year() - 2015).unwrap() - ); - assert_eq!(Utc.ymd(2034, 5, 15).elapsed_years(), 0); + // This is always at least one year because 1 year = 52.1775 weeks + let one_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); + // A bit more than 2 years + let two_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); + assert_eq!(one_year.elapsed_years(), 1); + assert_eq!(two_year.elapsed_years(), 2); + // if the date is later than now, the function will always return 0 + assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); } } diff --git a/src/datetime.rs b/src/datetime.rs index 01dfc1a841..35c5c3527b 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -2441,12 +2441,12 @@ pub mod serde { #[cfg(test)] mod tests { use super::DateTime; + use consts::f64; use naive::{NaiveDate, NaiveTime}; #[cfg(feature = "clock")] use offset::Local; use offset::{FixedOffset, TimeZone, Utc}; use oldtime::Duration; - use std::convert::TryFrom; use std::time::{SystemTime, UNIX_EPOCH}; #[cfg(feature = "clock")] use Datelike; @@ -2861,18 +2861,15 @@ mod tests { #[test] fn test_years_elapsed() { - assert_eq!( - Utc.ymd(2011, 5, 15).and_hms(6, 34, 0).elapsed_years(), - u32::try_from(Utc.ymd(2021, 4, 21).and_hms(23, 17, 0).year() - 2012).unwrap() - ); - assert_eq!( - Utc.ymd(2021, 4, 21).and_hms(3, 24, 0).elapsed_years(), - u32::try_from(Utc.ymd(2021, 4, 21).and_hms(11, 12, 0).year() - 2021).unwrap() - ); - assert_eq!( - Utc.ymd(2015, 3, 15).and_hms(16, 48, 0).elapsed_years(), - u32::try_from(Utc.ymd(2021, 4, 21).and_hms(9, 7, 0).year() - 2015).unwrap() - ); - assert_eq!(Utc.ymd(2034, 5, 15).and_hms(0, 34, 0).elapsed_years(), 0); + // This is always at least one year because 1 year = 52.1775 weeks + let one_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); + // A bit more than 2 years + let two_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); + + assert_eq!(one_year.elapsed_years(), 1); + assert_eq!(two_year.elapsed_years(), 2); + + // if the date is later than now, the function will always return 0 + assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); } } From 767f87a6d60d02d4b25d1ac863d29ae8550878ba Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 13:57:20 +0200 Subject: [PATCH 10/29] Change variable name --- src/date.rs | 9 +++++---- src/datetime.rs | 8 ++++---- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/src/date.rs b/src/date.rs index aaaacd26ed..77a6099585 100644 --- a/src/date.rs +++ b/src/date.rs @@ -518,11 +518,12 @@ mod tests { #[test] fn test_years_elapsed() { // This is always at least one year because 1 year = 52.1775 weeks - let one_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); + let one_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); // A bit more than 2 years - let two_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); - assert_eq!(one_year.elapsed_years(), 1); - assert_eq!(two_year.elapsed_years(), 2); + let two_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); + + assert_eq!(one_year_ago.elapsed_years(), 1); + assert_eq!(two_year_ago.elapsed_years(), 2); // if the date is later than now, the function will always return 0 assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); } diff --git a/src/datetime.rs b/src/datetime.rs index 35c5c3527b..f97c73b28d 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -2862,12 +2862,12 @@ mod tests { #[test] fn test_years_elapsed() { // This is always at least one year because 1 year = 52.1775 weeks - let one_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); + let one_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); // A bit more than 2 years - let two_year = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); + let two_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); - assert_eq!(one_year.elapsed_years(), 1); - assert_eq!(two_year.elapsed_years(), 2); + assert_eq!(one_year_ago.elapsed_years(), 1); + assert_eq!(two_year_ago.elapsed_years(), 2); // if the date is later than now, the function will always return 0 assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); From 6d569fbe874b457b73c7cdeefb2b761284a5d838 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 14:16:11 +0200 Subject: [PATCH 11/29] Clean up --- src/date.rs | 8 ++++---- src/datetime.rs | 8 ++++---- src/naive/date.rs | 2 -- src/naive/datetime.rs | 2 -- 4 files changed, 8 insertions(+), 12 deletions(-) diff --git a/src/date.rs b/src/date.rs index 77a6099585..f289ad28a9 100644 --- a/src/date.rs +++ b/src/date.rs @@ -273,7 +273,7 @@ impl Date { self.date } - /// Retrieve the elapsed years from now to the given Date + /// Retrieve the elapsed years from now to the given [`Date`]. pub fn elapsed_years(&self) -> u32 { let now = Utc::today(); @@ -517,14 +517,14 @@ mod tests { #[test] fn test_years_elapsed() { - // This is always at least one year because 1 year = 52.1775 weeks + // This is always at least one year because 1 year = 52.1775 weeks. let one_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); - // A bit more than 2 years + // A bit more than 2 years. let two_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); assert_eq!(one_year_ago.elapsed_years(), 1); assert_eq!(two_year_ago.elapsed_years(), 2); - // if the date is later than now, the function will always return 0 + // if the given Date is later than now, the function will always return 0. assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); } } diff --git a/src/datetime.rs b/src/datetime.rs index f97c73b28d..06ac3dfa27 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -310,7 +310,7 @@ impl DateTime { self.datetime + self.offset.fix() } - /// Retrieve the elapsed years from now to the given DateTime + /// Retrieve the elapsed years from now to the given [`DateTime`] pub fn elapsed_years(&self) -> u32 { let now = Utc::now(); @@ -2861,15 +2861,15 @@ mod tests { #[test] fn test_years_elapsed() { - // This is always at least one year because 1 year = 52.1775 weeks + // This is always at least one year because 1 year = 52.1775 weeks. let one_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); - // A bit more than 2 years + // A bit more than 2 years. let two_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); assert_eq!(one_year_ago.elapsed_years(), 1); assert_eq!(two_year_ago.elapsed_years(), 2); - // if the date is later than now, the function will always return 0 + // if the given DateTime is later than now, the function will always return 0. assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); } } diff --git a/src/naive/date.rs b/src/naive/date.rs index fca907f95e..9ab80e910f 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -8,9 +8,7 @@ use core::borrow::Borrow; use core::ops::{Add, AddAssign, Sub, SubAssign}; use core::{fmt, str}; use num_traits::ToPrimitive; -use offset::Utc; use oldtime::Duration as OldDuration; -use std::convert::TryFrom; use div::div_mod_floor; #[cfg(any(feature = "alloc", feature = "std", test))] diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index 5aa4b39de8..261e41bd4d 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -8,9 +8,7 @@ use core::borrow::Borrow; use core::ops::{Add, AddAssign, Sub, SubAssign}; use core::{fmt, hash, str}; use num_traits::ToPrimitive; -use offset::Utc; use oldtime::Duration as OldDuration; -use std::convert::TryFrom; use div::div_mod_floor; #[cfg(any(feature = "alloc", feature = "std", test))] From 6ab485a5e2cfdfe1aab54ea501bac896bd783a09 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 14:21:57 +0200 Subject: [PATCH 12/29] Clean up --- src/datetime.rs | 2 +- src/naive/date.rs | 1 - src/naive/datetime.rs | 1 - 3 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/datetime.rs b/src/datetime.rs index 06ac3dfa27..0709cea7e1 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -310,7 +310,7 @@ impl DateTime { self.datetime + self.offset.fix() } - /// Retrieve the elapsed years from now to the given [`DateTime`] + /// Retrieve the elapsed years from now to the given [`DateTime`]. pub fn elapsed_years(&self) -> u32 { let now = Utc::now(); diff --git a/src/naive/date.rs b/src/naive/date.rs index 9ab80e910f..989254ae5f 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -1907,7 +1907,6 @@ mod tests { use super::{MAX_DATE, MAX_DAYS_FROM_YEAR_0, MAX_YEAR}; use super::{MIN_DATE, MIN_DAYS_FROM_YEAR_0, MIN_YEAR}; use oldtime::Duration; - use std::convert::TryFrom; use std::{i32, u32}; use {Datelike, Weekday}; diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index 261e41bd4d..db23f54037 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -2279,7 +2279,6 @@ mod tests { use super::NaiveDateTime; use naive::{NaiveDate, MAX_DATE, MIN_DATE}; use oldtime::Duration; - use std::convert::TryFrom; use std::i64; use Datelike; From 5d1af6007d1d71bb13e789643200be48c28fbdbb Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 14:32:05 +0200 Subject: [PATCH 13/29] Update changelog and authors --- AUTHORS.txt | 1 + CHANGELOG.md | 1 + 2 files changed, 2 insertions(+) diff --git a/AUTHORS.txt b/AUTHORS.txt index 9501a9d059..e4d7d2ad1d 100644 --- a/AUTHORS.txt +++ b/AUTHORS.txt @@ -39,3 +39,4 @@ Steve Klabnik Tom Gallacher klutzy kud1ing +Yohan Boogaert diff --git a/CHANGELOG.md b/CHANGELOG.md index 16a9063b60..9fa571760f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,7 @@ Versions with only mechanical changes will be omitted from the following list. * Add support for microseconds timestamps serde serialization/deserialization (#304) * Fix `DurationRound` is not TZ aware (#495) * Implement `DurationRound` for `NaiveDateTime` +* Add a function that calculate the years elapsed between `Utc::today` and a given `Date` or `Utc::now()` and a given `DateTime` ## 0.4.19 From cab008d6cdbbebb65341905d257fcd40efd8262d Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 15:38:34 +0200 Subject: [PATCH 14/29] Replace the Utc use by the timezone of the Date --- src/date.rs | 4 ++-- src/datetime.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/date.rs b/src/date.rs index f289ad28a9..53cb202c65 100644 --- a/src/date.rs +++ b/src/date.rs @@ -16,7 +16,7 @@ use format::Locale; #[cfg(any(feature = "alloc", feature = "std", test))] use format::{DelayedFormat, Item, StrftimeItems}; use naive::{self, IsoWeek, NaiveDate, NaiveTime}; -use offset::{TimeZone, Utc}; +use offset::{Local, TimeZone, Utc}; use DateTime; use {Datelike, Weekday}; @@ -275,7 +275,7 @@ impl Date { /// Retrieve the elapsed years from now to the given [`Date`]. pub fn elapsed_years(&self) -> u32 { - let now = Utc::today(); + let now = Utc::today().with_timezone(&self.timezone()); let years = if (now.month(), now.day()) < (self.month(), self.day()) { now.year() - self.year() - 1 diff --git a/src/datetime.rs b/src/datetime.rs index 0709cea7e1..49246145d0 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -312,7 +312,7 @@ impl DateTime { /// Retrieve the elapsed years from now to the given [`DateTime`]. pub fn elapsed_years(&self) -> u32 { - let now = Utc::now(); + let now = Utc::now().with_timezone(&self.timezone()); let years = if (now.month(), now.day(), now.time()) < (self.month(), self.day(), self.time()) { From f676c1f62034ee1883d1f45521536be25d1e75c1 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 15:46:21 +0200 Subject: [PATCH 15/29] Clean up --- src/date.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/date.rs b/src/date.rs index 53cb202c65..2d3a7a2445 100644 --- a/src/date.rs +++ b/src/date.rs @@ -16,7 +16,7 @@ use format::Locale; #[cfg(any(feature = "alloc", feature = "std", test))] use format::{DelayedFormat, Item, StrftimeItems}; use naive::{self, IsoWeek, NaiveDate, NaiveTime}; -use offset::{Local, TimeZone, Utc}; +use offset::{TimeZone, Utc}; use DateTime; use {Datelike, Weekday}; From 4c52ec7c413369cc2dc65d90b5dd34ed532374e3 Mon Sep 17 00:00:00 2001 From: Yozhgoor Date: Tue, 27 Apr 2021 15:48:57 +0200 Subject: [PATCH 16/29] Adapt changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9fa571760f..5f2c1ae62d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ Versions with only mechanical changes will be omitted from the following list. * Add support for microseconds timestamps serde serialization/deserialization (#304) * Fix `DurationRound` is not TZ aware (#495) * Implement `DurationRound` for `NaiveDateTime` -* Add a function that calculate the years elapsed between `Utc::today` and a given `Date` or `Utc::now()` and a given `DateTime` +* Add a function that calculate the years elapsed between now and a given `Date` or `DateTime` ## 0.4.19 From 5e3eba3daa14db65dc669e05da05e909cff17e4b Mon Sep 17 00:00:00 2001 From: Yohan Boogaert Date: Sun, 13 Jun 2021 19:20:26 +0200 Subject: [PATCH 17/29] Update src/lib.rs Co-authored-by: Cecile Tonglet --- src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index bcd89139f8..6f79440a22 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -599,7 +599,7 @@ pub mod consts { /// Constants of type `f32`. pub mod f32 { /// Number of weeks in a year. - pub const WEEK_PER_YEAR: f32 = 52.1775; + pub const WEEKS_PER_YEAR: f32 = 52.1775; } /// Constants of type `f64`. pub mod f64 { From bd6a7a7aa5bec6e22f1d99821d61ade0c57a75cc Mon Sep 17 00:00:00 2001 From: Yohan Boogaert Date: Sun, 13 Jun 2021 19:20:32 +0200 Subject: [PATCH 18/29] Update src/lib.rs Co-authored-by: Cecile Tonglet --- src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index 6f79440a22..9a52c28115 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -604,7 +604,7 @@ pub mod consts { /// Constants of type `f64`. pub mod f64 { /// Number of weeks in a year. - pub const WEEK_PER_YEAR: f64 = 52.1775; + pub const WEEKS_PER_YEAR: f64 = 52.1775; } } From 30063035d6c6f0d1977ead4181d48f02848578fe Mon Sep 17 00:00:00 2001 From: Yohan Boogaert Date: Sun, 13 Jun 2021 19:20:40 +0200 Subject: [PATCH 19/29] Update CHANGELOG.md Co-authored-by: Cecile Tonglet --- CHANGELOG.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5f2c1ae62d..4ac443d9ca 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ Versions with only mechanical changes will be omitted from the following list. * Add support for microseconds timestamps serde serialization/deserialization (#304) * Fix `DurationRound` is not TZ aware (#495) * Implement `DurationRound` for `NaiveDateTime` -* Add a function that calculate the years elapsed between now and a given `Date` or `DateTime` +* Add a function that calculates the number of years elapsed between now and a given `Date` or `DateTime` (#557) ## 0.4.19 @@ -743,4 +743,3 @@ and replaced by 0.2.25 very shortly. Duh.) ## 0.1.0 (2014-11-20) The initial version that was available to `crates.io`. - From 3fa7eaa109cfdc78f8289c3a14af94ec3c3d6055 Mon Sep 17 00:00:00 2001 From: Milo <50248166+Milo123459@users.noreply.github.com> Date: Wed, 27 Oct 2021 22:06:23 +0100 Subject: [PATCH 20/29] Update CHANGELOG.md Co-authored-by: Cecile Tonglet --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4a45d6663d..1e9d6d723b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ Versions with only mechanical changes will be omitted from the following list. * Add support for microseconds timestamps serde serialization/deserialization (#304) * Fix `DurationRound` is not TZ aware (#495) * Implement `DurationRound` for `NaiveDateTime` -* Add a function that calculates the number of years elapsed between now and a given `Date` or `DateTime` (#557) +* Add `DateTime::from_local()` to construct from given local date and time (#572) * Add a function that calculates the number of years elapsed between now and a given `Date` or `DateTime` (#557) ## 0.4.19 From a069d563972d47670c23b410d237a22c152a83e9 Mon Sep 17 00:00:00 2001 From: Milo <50248166+Milo123459@users.noreply.github.com> Date: Wed, 27 Oct 2021 22:06:58 +0100 Subject: [PATCH 21/29] Update src/datetime.rs Co-authored-by: Cecile Tonglet --- src/datetime.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/datetime.rs b/src/datetime.rs index 803fe5aa9e..85a1cf5826 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -3059,6 +3059,9 @@ mod tests { // if the given DateTime is later than now, the function will always return 0. assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); + } + + #[test] fn test_datetime_from_local() { // 2000-01-12T02:00:00Z let naivedatetime_utc = NaiveDate::from_ymd(2000, 1, 12).and_hms(2, 0, 0); From a4a026ad6556d72a14c6affe3fd2b052151a4909 Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Thu, 28 Oct 2021 13:06:03 +0200 Subject: [PATCH 22/29] Update --- src/date.rs | 8 +++++--- src/datetime.rs | 8 +++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/src/date.rs b/src/date.rs index 2d3a7a2445..9045fe0dbe 100644 --- a/src/date.rs +++ b/src/date.rs @@ -6,10 +6,10 @@ #[cfg(any(feature = "alloc", feature = "std", test))] use core::borrow::Borrow; use core::cmp::Ordering; +use core::convert::TryFrom; use core::ops::{Add, Sub}; use core::{fmt, hash}; use oldtime::Duration as OldDuration; -use std::convert::TryFrom; #[cfg(feature = "unstable-locales")] use format::Locale; @@ -518,9 +518,11 @@ mod tests { #[test] fn test_years_elapsed() { // This is always at least one year because 1 year = 52.1775 weeks. - let one_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); + let one_year_ago = + Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 1.5).ceil() as i64); // A bit more than 2 years. - let two_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); + let two_year_ago = + Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 2.5).ceil() as i64); assert_eq!(one_year_ago.elapsed_years(), 1); assert_eq!(two_year_ago.elapsed_years(), 2); diff --git a/src/datetime.rs b/src/datetime.rs index 85a1cf5826..fc2d25ff1a 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -4,10 +4,10 @@ //! ISO 8601 date and time with time zone. use core::cmp::Ordering; +use core::convert::TryFrom; use core::ops::{Add, Sub}; use core::{fmt, hash, str}; use oldtime::Duration as OldDuration; -use std::convert::TryFrom; #[cfg(any(feature = "std", test))] use std::time::{SystemTime, UNIX_EPOCH}; @@ -3050,9 +3050,11 @@ mod tests { #[test] fn test_years_elapsed() { // This is always at least one year because 1 year = 52.1775 weeks. - let one_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 1.5).ceil() as i64); + let one_year_ago = + Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 1.5).ceil() as i64); // A bit more than 2 years. - let two_year_ago = Utc::today() - Duration::weeks((f64::WEEK_PER_YEAR * 2.5).ceil() as i64); + let two_year_ago = + Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 2.5).ceil() as i64); assert_eq!(one_year_ago.elapsed_years(), 1); assert_eq!(two_year_ago.elapsed_years(), 2); From d82afcf1b67df33bc1138401f767e4b45e852f0e Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Fri, 12 Nov 2021 11:27:38 +0100 Subject: [PATCH 23/29] Use the clock feature when using `Utc::now` and `Utc::today` --- src/date.rs | 2 ++ src/datetime.rs | 3 +++ 2 files changed, 5 insertions(+) diff --git a/src/date.rs b/src/date.rs index 9045fe0dbe..641ceb50e9 100644 --- a/src/date.rs +++ b/src/date.rs @@ -274,6 +274,7 @@ impl Date { } /// Retrieve the elapsed years from now to the given [`Date`]. + #[cfg(feature = "clock")] pub fn elapsed_years(&self) -> u32 { let now = Utc::today().with_timezone(&self.timezone()); @@ -516,6 +517,7 @@ mod tests { use oldtime::Duration; #[test] + #[cfg(feature = "clock")] fn test_years_elapsed() { // This is always at least one year because 1 year = 52.1775 weeks. let one_year_ago = diff --git a/src/datetime.rs b/src/datetime.rs index fc2d25ff1a..a69a7f3f98 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -342,6 +342,7 @@ impl DateTime { } /// Retrieve the elapsed years from now to the given [`DateTime`]. + #[cfg(feature = "clock")] pub fn elapsed_years(&self) -> u32 { let now = Utc::now().with_timezone(&self.timezone()); @@ -3018,6 +3019,7 @@ mod tests { } #[test] + #[cfg(feature = "clock")] fn test_datetime_format_alignment() { let datetime = Utc.ymd(2007, 01, 02); @@ -3048,6 +3050,7 @@ mod tests { } #[test] + #[cfg(feature = "clock")] fn test_years_elapsed() { // This is always at least one year because 1 year = 52.1775 weeks. let one_year_ago = From 7816be19f9cd5a884993653695d441ef32dc3155 Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Mon, 10 Jan 2022 20:48:28 +0100 Subject: [PATCH 24/29] New blank line at EOF --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1e9d6d723b..80f2d5b6d8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -744,3 +744,4 @@ and replaced by 0.2.25 very shortly. Duh.) ## 0.1.0 (2014-11-20) The initial version that was available to `crates.io`. + From 81fabab2aa8c13ec76d3ea4206d19203b1c4367d Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Fri, 27 May 2022 14:33:22 +0200 Subject: [PATCH 25/29] Move the code from `datetime.rs` to `datetime/mod.rs` and delete `datetime.rs` --- src/datetime.rs | 3088 ----------------------------------------- src/datetime/mod.rs | 15 + src/datetime/tests.rs | 15 + 3 files changed, 30 insertions(+), 3088 deletions(-) delete mode 100644 src/datetime.rs diff --git a/src/datetime.rs b/src/datetime.rs deleted file mode 100644 index 8299ff1b5e..0000000000 --- a/src/datetime.rs +++ /dev/null @@ -1,3088 +0,0 @@ -// This is a part of Chrono. -// See README.md and LICENSE.txt for details. - -//! ISO 8601 date and time with time zone. - -use core::cmp::Ordering; -use core::convert::TryFrom; -use core::ops::{Add, Sub}; -use core::{fmt, hash, str}; -use oldtime::Duration as OldDuration; -#[cfg(any(feature = "std", test))] -use std::time::{SystemTime, UNIX_EPOCH}; - -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use alloc::string::{String, ToString}; -#[cfg(feature = "std")] -use std::string::ToString; - -#[cfg(any(feature = "alloc", feature = "std", test))] -use core::borrow::Borrow; -#[cfg(any(feature = "alloc", feature = "std", test))] -use format::DelayedFormat; -#[cfg(feature = "unstable-locales")] -use format::Locale; -use format::{parse, ParseError, ParseResult, Parsed, StrftimeItems}; -use format::{Fixed, Item}; -use naive::{self, IsoWeek, NaiveDate, NaiveDateTime, NaiveTime}; -#[cfg(feature = "clock")] -use offset::Local; -use offset::{FixedOffset, Offset, TimeZone, Utc}; -use Date; -use {Datelike, Timelike, Weekday}; - -/// Specific formatting options for seconds. This may be extended in the -/// future, so exhaustive matching in external code is not recommended. -/// -/// See the `TimeZone::to_rfc3339_opts` function for usage. -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub enum SecondsFormat { - /// Format whole seconds only, with no decimal point nor subseconds. - Secs, - - /// Use fixed 3 subsecond digits. This corresponds to - /// [Fixed::Nanosecond3](format/enum.Fixed.html#variant.Nanosecond3). - Millis, - - /// Use fixed 6 subsecond digits. This corresponds to - /// [Fixed::Nanosecond6](format/enum.Fixed.html#variant.Nanosecond6). - Micros, - - /// Use fixed 9 subsecond digits. This corresponds to - /// [Fixed::Nanosecond9](format/enum.Fixed.html#variant.Nanosecond9). - Nanos, - - /// Automatically select one of `Secs`, `Millis`, `Micros`, or `Nanos` to - /// display all available non-zero sub-second digits. This corresponds to - /// [Fixed::Nanosecond](format/enum.Fixed.html#variant.Nanosecond). - AutoSi, - - // Do not match against this. - #[doc(hidden)] - __NonExhaustive, -} - -/// ISO 8601 combined date and time with time zone. -/// -/// There are some constructors implemented here (the `from_*` methods), but -/// the general-purpose constructors are all via the methods on the -/// [`TimeZone`](./offset/trait.TimeZone.html) implementations. -#[derive(Clone)] -pub struct DateTime { - datetime: NaiveDateTime, - offset: Tz::Offset, -} - -/// The minimum possible `DateTime`. -pub const MIN_DATETIME: DateTime = DateTime { datetime: naive::MIN_DATETIME, offset: Utc }; -/// The maximum possible `DateTime`. -pub const MAX_DATETIME: DateTime = DateTime { datetime: naive::MAX_DATETIME, offset: Utc }; - -impl DateTime { - /// Makes a new `DateTime` with given *UTC* datetime and offset. - /// The local datetime should be constructed via the `TimeZone` trait. - /// - /// # Example - /// - /// ``` - /// use chrono::{DateTime, TimeZone, NaiveDateTime, Utc}; - /// - /// let dt = DateTime::::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc); - /// assert_eq!(Utc.timestamp(61, 0), dt); - /// ``` - // - // note: this constructor is purposely not named to `new` to discourage the direct usage. - #[inline] - pub fn from_utc(datetime: NaiveDateTime, offset: Tz::Offset) -> DateTime { - DateTime { datetime: datetime, offset: offset } - } - - /// Makes a new `DateTime` with given **local** datetime and offset that - /// presents local timezone. - /// - /// # Example - /// - /// ``` - /// use chrono::DateTime; - /// use chrono::naive::NaiveDate; - /// use chrono::offset::{Utc, FixedOffset}; - /// - /// let naivedatetime_utc = NaiveDate::from_ymd(2000, 1, 12).and_hms(2, 0, 0); - /// let datetime_utc = DateTime::::from_utc(naivedatetime_utc, Utc); - /// - /// let timezone_east = FixedOffset::east(8 * 60 * 60); - /// let naivedatetime_east = NaiveDate::from_ymd(2000, 1, 12).and_hms(10, 0, 0); - /// let datetime_east = DateTime::::from_local(naivedatetime_east, timezone_east); - /// - /// let timezone_west = FixedOffset::west(7 * 60 * 60); - /// let naivedatetime_west = NaiveDate::from_ymd(2000, 1, 11).and_hms(19, 0, 0); - /// let datetime_west = DateTime::::from_local(naivedatetime_west, timezone_west); - - /// assert_eq!(datetime_east, datetime_utc.with_timezone(&timezone_east)); - /// assert_eq!(datetime_west, datetime_utc.with_timezone(&timezone_west)); - /// ``` - #[inline] - pub fn from_local(datetime: NaiveDateTime, offset: Tz::Offset) -> DateTime { - let datetime_utc = datetime - offset.fix(); - - DateTime { datetime: datetime_utc, offset: offset } - } - - /// Retrieves a date component - /// - /// Unless you are immediately planning on turning this into a `DateTime` - /// with the same Timezone you should use the - /// [`date_naive`](DateTime::date_naive) method. - /// - /// ``` - /// use chrono::prelude::*; - /// - /// let date: Date = Utc.ymd(2020, 1, 1); - /// let dt: DateTime = date.and_hms(0, 0, 0); - /// - /// assert_eq!(dt.date(), date); - /// - /// assert_eq!(dt.date().and_hms(1, 1, 1), date.and_hms(1, 1, 1)); - /// ``` - #[inline] - pub fn date(&self) -> Date { - Date::from_utc(self.naive_local().date(), self.offset.clone()) - } - - /// Retrieves the Date without an associated timezone - /// - /// [`NaiveDate`] is a more well-defined type, and has more traits implemented on it, - /// so should be preferred to [`Date`] any time you truly want to operate on Dates. - /// - /// ``` - /// use chrono::prelude::*; - /// - /// let date: DateTime = Utc.ymd(2020, 1, 1).and_hms(0, 0, 0); - /// let other: DateTime = FixedOffset::east(23).ymd(2020, 1, 1).and_hms(0, 0, 0); - /// assert_eq!(date.date_naive(), other.date_naive()); - /// ``` - #[inline] - pub fn date_naive(&self) -> NaiveDate { - let local = self.naive_local(); - NaiveDate::from_ymd(local.year(), local.month(), local.day()) - } - - /// Retrieves a time component. - /// Unlike `date`, this is not associated to the time zone. - #[inline] - pub fn time(&self) -> NaiveTime { - self.datetime.time() + self.offset.fix() - } - - /// Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC - /// (aka "UNIX timestamp"). - #[inline] - pub fn timestamp(&self) -> i64 { - self.datetime.timestamp() - } - - /// Returns the number of non-leap-milliseconds since January 1, 1970 UTC - /// - /// Note that this does reduce the number of years that can be represented - /// from ~584 Billion to ~584 Million. (If this is a problem, please file - /// an issue to let me know what domain needs millisecond precision over - /// billions of years, I'm curious.) - /// - /// # Example - /// - /// ``` - /// use chrono::Utc; - /// use chrono::TimeZone; - /// - /// let dt = Utc.ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 444); - /// assert_eq!(dt.timestamp_millis(), 1_444); - /// - /// let dt = Utc.ymd(2001, 9, 9).and_hms_milli(1, 46, 40, 555); - /// assert_eq!(dt.timestamp_millis(), 1_000_000_000_555); - /// ``` - #[inline] - pub fn timestamp_millis(&self) -> i64 { - self.datetime.timestamp_millis() - } - - /// Returns the number of non-leap-microseconds since January 1, 1970 UTC - /// - /// Note that this does reduce the number of years that can be represented - /// from ~584 Billion to ~584 Thousand. (If this is a problem, please file - /// an issue to let me know what domain needs microsecond precision over - /// millenia, I'm curious.) - /// - /// # Example - /// - /// ``` - /// use chrono::Utc; - /// use chrono::TimeZone; - /// - /// let dt = Utc.ymd(1970, 1, 1).and_hms_micro(0, 0, 1, 444); - /// assert_eq!(dt.timestamp_micros(), 1_000_444); - /// - /// let dt = Utc.ymd(2001, 9, 9).and_hms_micro(1, 46, 40, 555); - /// assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555); - /// ``` - #[inline] - pub fn timestamp_micros(&self) -> i64 { - self.datetime.timestamp_micros() - } - - /// Returns the number of non-leap-nanoseconds since January 1, 1970 UTC - /// - /// Note that this does reduce the number of years that can be represented - /// from ~584 Billion to ~584. (If this is a problem, please file - /// an issue to let me know what domain needs nanosecond precision over - /// millennia, I'm curious.) - /// - /// # Example - /// - /// ``` - /// use chrono::Utc; - /// use chrono::TimeZone; - /// - /// let dt = Utc.ymd(1970, 1, 1).and_hms_nano(0, 0, 1, 444); - /// assert_eq!(dt.timestamp_nanos(), 1_000_000_444); - /// - /// let dt = Utc.ymd(2001, 9, 9).and_hms_nano(1, 46, 40, 555); - /// assert_eq!(dt.timestamp_nanos(), 1_000_000_000_000_000_555); - /// ``` - #[inline] - pub fn timestamp_nanos(&self) -> i64 { - self.datetime.timestamp_nanos() - } - - /// Returns the number of milliseconds since the last second boundary - /// - /// warning: in event of a leap second, this may exceed 999 - /// - /// note: this is not the number of milliseconds since January 1, 1970 0:00:00 UTC - #[inline] - pub fn timestamp_subsec_millis(&self) -> u32 { - self.datetime.timestamp_subsec_millis() - } - - /// Returns the number of microseconds since the last second boundary - /// - /// warning: in event of a leap second, this may exceed 999_999 - /// - /// note: this is not the number of microseconds since January 1, 1970 0:00:00 UTC - #[inline] - pub fn timestamp_subsec_micros(&self) -> u32 { - self.datetime.timestamp_subsec_micros() - } - - /// Returns the number of nanoseconds since the last second boundary - /// - /// warning: in event of a leap second, this may exceed 999_999_999 - /// - /// note: this is not the number of nanoseconds since January 1, 1970 0:00:00 UTC - #[inline] - pub fn timestamp_subsec_nanos(&self) -> u32 { - self.datetime.timestamp_subsec_nanos() - } - - /// Retrieves an associated offset from UTC. - #[inline] - pub fn offset(&self) -> &Tz::Offset { - &self.offset - } - - /// Retrieves an associated time zone. - #[inline] - pub fn timezone(&self) -> Tz { - TimeZone::from_offset(&self.offset) - } - - /// Changes the associated time zone. - /// This does not change the actual `DateTime` (but will change the string representation). - #[inline] - pub fn with_timezone(&self, tz: &Tz2) -> DateTime { - tz.from_utc_datetime(&self.datetime) - } - - /// Adds given `Duration` to the current date and time. - /// - /// Returns `None` when it will result in overflow. - #[inline] - pub fn checked_add_signed(self, rhs: OldDuration) -> Option> { - let datetime = try_opt!(self.datetime.checked_add_signed(rhs)); - let tz = self.timezone(); - Some(tz.from_utc_datetime(&datetime)) - } - - /// Subtracts given `Duration` from the current date and time. - /// - /// Returns `None` when it will result in overflow. - #[inline] - pub fn checked_sub_signed(self, rhs: OldDuration) -> Option> { - let datetime = try_opt!(self.datetime.checked_sub_signed(rhs)); - let tz = self.timezone(); - Some(tz.from_utc_datetime(&datetime)) - } - - /// Subtracts another `DateTime` from the current date and time. - /// This does not overflow or underflow at all. - #[inline] - pub fn signed_duration_since(self, rhs: DateTime) -> OldDuration { - self.datetime.signed_duration_since(rhs.datetime) - } - - /// Returns a view to the naive UTC datetime. - #[inline] - pub fn naive_utc(&self) -> NaiveDateTime { - self.datetime - } - - /// Returns a view to the naive local datetime. - #[inline] - pub fn naive_local(&self) -> NaiveDateTime { - self.datetime + self.offset.fix() - } - - /// Retrieve the elapsed years from now to the given [`DateTime`]. - #[cfg(feature = "clock")] - pub fn elapsed_years(&self) -> u32 { - let now = Utc::now().with_timezone(&self.timezone()); - - let years = - if (now.month(), now.day(), now.time()) < (self.month(), self.day(), self.time()) { - now.year() - self.year() - 1 - } else { - now.year() - self.year() - }; - - u32::try_from(years).unwrap_or(0) - } -} - -impl Default for DateTime { - fn default() -> Self { - Utc.from_utc_datetime(&NaiveDateTime::default()) - } -} - -#[cfg(feature = "clock")] -impl Default for DateTime { - fn default() -> Self { - Local.from_utc_datetime(&NaiveDateTime::default()) - } -} - -impl Default for DateTime { - fn default() -> Self { - FixedOffset::west(0).from_utc_datetime(&NaiveDateTime::default()) - } -} - -/// Convert a `DateTime` instance into a `DateTime` instance. -impl From> for DateTime { - /// Convert this `DateTime` instance into a `DateTime` instance. - /// - /// Conversion is done via [`DateTime::with_timezone`]. Note that the converted value returned by - /// this will be created with a fixed timezone offset of 0. - fn from(src: DateTime) -> Self { - src.with_timezone(&FixedOffset::east(0)) - } -} - -/// Convert a `DateTime` instance into a `DateTime` instance. -#[cfg(feature = "clock")] -impl From> for DateTime { - /// Convert this `DateTime` instance into a `DateTime` instance. - /// - /// Conversion is performed via [`DateTime::with_timezone`], accounting for the difference in timezones. - fn from(src: DateTime) -> Self { - src.with_timezone(&Local) - } -} - -/// Convert a `DateTime` instance into a `DateTime` instance. -impl From> for DateTime { - /// Convert this `DateTime` instance into a `DateTime` instance. - /// - /// Conversion is performed via [`DateTime::with_timezone`], accounting for the timezone - /// difference. - fn from(src: DateTime) -> Self { - src.with_timezone(&Utc) - } -} - -/// Convert a `DateTime` instance into a `DateTime` instance. -#[cfg(feature = "clock")] -impl From> for DateTime { - /// Convert this `DateTime` instance into a `DateTime` instance. - /// - /// Conversion is performed via [`DateTime::with_timezone`]. Returns the equivalent value in local - /// time. - fn from(src: DateTime) -> Self { - src.with_timezone(&Local) - } -} - -/// Convert a `DateTime` instance into a `DateTime` instance. -#[cfg(feature = "clock")] -impl From> for DateTime { - /// Convert this `DateTime` instance into a `DateTime` instance. - /// - /// Conversion is performed via [`DateTime::with_timezone`], accounting for the difference in - /// timezones. - fn from(src: DateTime) -> Self { - src.with_timezone(&Utc) - } -} - -/// Convert a `DateTime` instance into a `DateTime` instance. -#[cfg(feature = "clock")] -impl From> for DateTime { - /// Convert this `DateTime` instance into a `DateTime` instance. - /// - /// Conversion is performed via [`DateTime::with_timezone`]. Note that the converted value returned - /// by this will be created with a fixed timezone offset of 0. - fn from(src: DateTime) -> Self { - src.with_timezone(&FixedOffset::east(0)) - } -} - -/// Maps the local datetime to other datetime with given conversion function. -fn map_local(dt: &DateTime, mut f: F) -> Option> -where - F: FnMut(NaiveDateTime) -> Option, -{ - f(dt.naive_local()).and_then(|datetime| dt.timezone().from_local_datetime(&datetime).single()) -} - -impl DateTime { - /// Parses an RFC 2822 date and time string such as `Tue, 1 Jul 2003 10:52:37 +0200`, - /// then returns a new [`DateTime`] with a parsed [`FixedOffset`]. - /// - /// RFC 2822 is the internet message standard that specifices the - /// representation of times in HTTP and email headers. - /// - /// ``` - /// # use chrono::{DateTime, FixedOffset, TimeZone}; - /// assert_eq!( - /// DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:16:09 GMT").unwrap(), - /// FixedOffset::east(0).ymd(2015, 2, 18).and_hms(23, 16, 9) - /// ); - /// ``` - pub fn parse_from_rfc2822(s: &str) -> ParseResult> { - const ITEMS: &'static [Item<'static>] = &[Item::Fixed(Fixed::RFC2822)]; - let mut parsed = Parsed::new(); - parse(&mut parsed, s, ITEMS.iter())?; - parsed.to_datetime() - } - - /// Parses an RFC 3339 and ISO 8601 date and time string such as `1996-12-19T16:39:57-08:00`, - /// then returns a new [`DateTime`] with a parsed [`FixedOffset`]. - /// - /// Why isn't this named `parse_from_iso8601`? That's because ISO 8601 allows some freedom - /// over the syntax and RFC 3339 exercises that freedom to rigidly define a fixed format. - pub fn parse_from_rfc3339(s: &str) -> ParseResult> { - const ITEMS: &'static [Item<'static>] = &[Item::Fixed(Fixed::RFC3339)]; - let mut parsed = Parsed::new(); - parse(&mut parsed, s, ITEMS.iter())?; - parsed.to_datetime() - } - - /// Parses a string with the specified format string and returns a new - /// [`DateTime`] with a parsed [`FixedOffset`]. - /// - /// See the [`::format::strftime`] module on the supported escape - /// sequences. - /// - /// See also [`TimeZone::datetime_from_str`] which gives a local - /// [`DateTime`] on specific time zone. - /// - /// Note that this method *requires a timezone* in the string. See - /// [`NaiveDateTime::parse_from_str`] - /// for a version that does not require a timezone in the to-be-parsed str. - /// - /// # Example - /// - /// ```rust - /// use chrono::{DateTime, FixedOffset, TimeZone}; - /// - /// let dt = DateTime::parse_from_str( - /// "1983 Apr 13 12:09:14.274 +0000", "%Y %b %d %H:%M:%S%.3f %z"); - /// assert_eq!(dt, Ok(FixedOffset::east(0).ymd(1983, 4, 13).and_hms_milli(12, 9, 14, 274))); - /// ``` - pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult> { - let mut parsed = Parsed::new(); - parse(&mut parsed, s, StrftimeItems::new(fmt))?; - parsed.to_datetime() - } -} - -impl DateTime -where - Tz::Offset: fmt::Display, -{ - /// Returns an RFC 2822 date and time string such as `Tue, 1 Jul 2003 10:52:37 +0200`. - #[cfg(any(feature = "alloc", feature = "std", test))] - pub fn to_rfc2822(&self) -> String { - const ITEMS: &'static [Item<'static>] = &[Item::Fixed(Fixed::RFC2822)]; - self.format_with_items(ITEMS.iter()).to_string() - } - - /// Returns an RFC 3339 and ISO 8601 date and time string such as `1996-12-19T16:39:57-08:00`. - #[cfg(any(feature = "alloc", feature = "std", test))] - pub fn to_rfc3339(&self) -> String { - const ITEMS: &'static [Item<'static>] = &[Item::Fixed(Fixed::RFC3339)]; - self.format_with_items(ITEMS.iter()).to_string() - } - - /// Return an RFC 3339 and ISO 8601 date and time string with subseconds - /// formatted as per a `SecondsFormat`. - /// - /// If passed `use_z` true and the timezone is UTC (offset 0), use 'Z', as - /// per [`Fixed::TimezoneOffsetColonZ`] If passed `use_z` false, use - /// [`Fixed::TimezoneOffsetColon`] - /// - /// # Examples - /// - /// ```rust - /// # use chrono::{DateTime, FixedOffset, SecondsFormat, TimeZone, Utc}; - /// let dt = Utc.ymd(2018, 1, 26).and_hms_micro(18, 30, 9, 453_829); - /// assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, false), - /// "2018-01-26T18:30:09.453+00:00"); - /// assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, true), - /// "2018-01-26T18:30:09.453Z"); - /// assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), - /// "2018-01-26T18:30:09Z"); - /// - /// let pst = FixedOffset::east(8 * 60 * 60); - /// let dt = pst.ymd(2018, 1, 26).and_hms_micro(10, 30, 9, 453_829); - /// assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), - /// "2018-01-26T10:30:09+08:00"); - /// ``` - #[cfg(any(feature = "alloc", feature = "std", test))] - pub fn to_rfc3339_opts(&self, secform: SecondsFormat, use_z: bool) -> String { - use format::Numeric::*; - use format::Pad::Zero; - use SecondsFormat::*; - - debug_assert!(secform != __NonExhaustive, "Do not use __NonExhaustive!"); - - const PREFIX: &'static [Item<'static>] = &[ - Item::Numeric(Year, Zero), - Item::Literal("-"), - Item::Numeric(Month, Zero), - Item::Literal("-"), - Item::Numeric(Day, Zero), - Item::Literal("T"), - Item::Numeric(Hour, Zero), - Item::Literal(":"), - Item::Numeric(Minute, Zero), - Item::Literal(":"), - Item::Numeric(Second, Zero), - ]; - - let ssitem = match secform { - Secs => None, - Millis => Some(Item::Fixed(Fixed::Nanosecond3)), - Micros => Some(Item::Fixed(Fixed::Nanosecond6)), - Nanos => Some(Item::Fixed(Fixed::Nanosecond9)), - AutoSi => Some(Item::Fixed(Fixed::Nanosecond)), - __NonExhaustive => unreachable!(), - }; - - let tzitem = Item::Fixed(if use_z { - Fixed::TimezoneOffsetColonZ - } else { - Fixed::TimezoneOffsetColon - }); - - match ssitem { - None => self.format_with_items(PREFIX.iter().chain([tzitem].iter())).to_string(), - Some(s) => self.format_with_items(PREFIX.iter().chain([s, tzitem].iter())).to_string(), - } - } - - /// Formats the combined date and time with the specified formatting items. - #[cfg(any(feature = "alloc", feature = "std", test))] - #[inline] - pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat - where - I: Iterator + Clone, - B: Borrow>, - { - let local = self.naive_local(); - DelayedFormat::new_with_offset(Some(local.date()), Some(local.time()), &self.offset, items) - } - - /// Formats the combined date and time with the specified format string. - /// See the [`::format::strftime`] module - /// on the supported escape sequences. - /// - /// # Example - /// ```rust - /// use chrono::prelude::*; - /// - /// let date_time: DateTime = Utc.ymd(2017, 04, 02).and_hms(12, 50, 32); - /// let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M")); - /// assert_eq!(formatted, "02/04/2017 12:50"); - /// ``` - #[cfg(any(feature = "alloc", feature = "std", test))] - #[inline] - pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat> { - self.format_with_items(StrftimeItems::new(fmt)) - } - - /// Formats the combined date and time with the specified formatting items and locale. - #[cfg(feature = "unstable-locales")] - #[inline] - pub fn format_localized_with_items<'a, I, B>( - &self, - items: I, - locale: Locale, - ) -> DelayedFormat - where - I: Iterator + Clone, - B: Borrow>, - { - let local = self.naive_local(); - DelayedFormat::new_with_offset_and_locale( - Some(local.date()), - Some(local.time()), - &self.offset, - items, - locale, - ) - } - - /// Formats the combined date and time with the specified format string and - /// locale. - /// - /// See the [`::format::strftime`] module on the supported escape - /// sequences. - #[cfg(feature = "unstable-locales")] - #[inline] - pub fn format_localized<'a>( - &self, - fmt: &'a str, - locale: Locale, - ) -> DelayedFormat> { - self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale), locale) - } -} - -impl Datelike for DateTime { - #[inline] - fn year(&self) -> i32 { - self.naive_local().year() - } - #[inline] - fn month(&self) -> u32 { - self.naive_local().month() - } - #[inline] - fn month0(&self) -> u32 { - self.naive_local().month0() - } - #[inline] - fn day(&self) -> u32 { - self.naive_local().day() - } - #[inline] - fn day0(&self) -> u32 { - self.naive_local().day0() - } - #[inline] - fn ordinal(&self) -> u32 { - self.naive_local().ordinal() - } - #[inline] - fn ordinal0(&self) -> u32 { - self.naive_local().ordinal0() - } - #[inline] - fn weekday(&self) -> Weekday { - self.naive_local().weekday() - } - #[inline] - fn iso_week(&self) -> IsoWeek { - self.naive_local().iso_week() - } - - #[inline] - fn with_year(&self, year: i32) -> Option> { - map_local(self, |datetime| datetime.with_year(year)) - } - - #[inline] - fn with_month(&self, month: u32) -> Option> { - map_local(self, |datetime| datetime.with_month(month)) - } - - #[inline] - fn with_month0(&self, month0: u32) -> Option> { - map_local(self, |datetime| datetime.with_month0(month0)) - } - - #[inline] - fn with_day(&self, day: u32) -> Option> { - map_local(self, |datetime| datetime.with_day(day)) - } - - #[inline] - fn with_day0(&self, day0: u32) -> Option> { - map_local(self, |datetime| datetime.with_day0(day0)) - } - - #[inline] - fn with_ordinal(&self, ordinal: u32) -> Option> { - map_local(self, |datetime| datetime.with_ordinal(ordinal)) - } - - #[inline] - fn with_ordinal0(&self, ordinal0: u32) -> Option> { - map_local(self, |datetime| datetime.with_ordinal0(ordinal0)) - } -} - -impl Timelike for DateTime { - #[inline] - fn hour(&self) -> u32 { - self.naive_local().hour() - } - #[inline] - fn minute(&self) -> u32 { - self.naive_local().minute() - } - #[inline] - fn second(&self) -> u32 { - self.naive_local().second() - } - #[inline] - fn nanosecond(&self) -> u32 { - self.naive_local().nanosecond() - } - - #[inline] - fn with_hour(&self, hour: u32) -> Option> { - map_local(self, |datetime| datetime.with_hour(hour)) - } - - #[inline] - fn with_minute(&self, min: u32) -> Option> { - map_local(self, |datetime| datetime.with_minute(min)) - } - - #[inline] - fn with_second(&self, sec: u32) -> Option> { - map_local(self, |datetime| datetime.with_second(sec)) - } - - #[inline] - fn with_nanosecond(&self, nano: u32) -> Option> { - map_local(self, |datetime| datetime.with_nanosecond(nano)) - } -} - -// we need them as automatic impls cannot handle associated types -impl Copy for DateTime where ::Offset: Copy {} -unsafe impl Send for DateTime where ::Offset: Send {} - -impl PartialEq> for DateTime { - fn eq(&self, other: &DateTime) -> bool { - self.datetime == other.datetime - } -} - -impl Eq for DateTime {} - -impl PartialOrd> for DateTime { - /// Compare two DateTimes based on their true time, ignoring time zones - /// - /// # Example - /// - /// ``` - /// use chrono::prelude::*; - /// - /// let earlier = Utc.ymd(2015, 5, 15).and_hms(2, 0, 0).with_timezone(&FixedOffset::west(1 * 3600)); - /// let later = Utc.ymd(2015, 5, 15).and_hms(3, 0, 0).with_timezone(&FixedOffset::west(5 * 3600)); - /// - /// assert_eq!(earlier.to_string(), "2015-05-15 01:00:00 -01:00"); - /// assert_eq!(later.to_string(), "2015-05-14 22:00:00 -05:00"); - /// - /// assert!(later > earlier); - /// ``` - fn partial_cmp(&self, other: &DateTime) -> Option { - self.datetime.partial_cmp(&other.datetime) - } -} - -impl Ord for DateTime { - fn cmp(&self, other: &DateTime) -> Ordering { - self.datetime.cmp(&other.datetime) - } -} - -impl hash::Hash for DateTime { - fn hash(&self, state: &mut H) { - self.datetime.hash(state) - } -} - -impl Add for DateTime { - type Output = DateTime; - - #[inline] - fn add(self, rhs: OldDuration) -> DateTime { - self.checked_add_signed(rhs).expect("`DateTime + Duration` overflowed") - } -} - -impl Sub for DateTime { - type Output = DateTime; - - #[inline] - fn sub(self, rhs: OldDuration) -> DateTime { - self.checked_sub_signed(rhs).expect("`DateTime - Duration` overflowed") - } -} - -impl Sub> for DateTime { - type Output = OldDuration; - - #[inline] - fn sub(self, rhs: DateTime) -> OldDuration { - self.signed_duration_since(rhs) - } -} - -impl fmt::Debug for DateTime { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{:?}{:?}", self.naive_local(), self.offset) - } -} - -impl fmt::Display for DateTime -where - Tz::Offset: fmt::Display, -{ - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{} {}", self.naive_local(), self.offset) - } -} - -/// Accepts a relaxed form of RFC3339. -/// A space or a 'T' are acepted as the separator between the date and time -/// parts. Additional spaces are allowed between each component. -/// -/// All of these examples are equivalent: -/// ``` -/// # use chrono::{DateTime, Utc}; -/// "2012-12-12T12:12:12Z".parse::>(); -/// "2012-12-12 12:12:12Z".parse::>(); -/// "2012- 12-12T12: 12:12Z".parse::>(); -/// ``` -impl str::FromStr for DateTime { - type Err = ParseError; - - fn from_str(s: &str) -> ParseResult> { - s.parse::>().map(|dt| dt.with_timezone(&Utc)) - } -} - -/// Accepts a relaxed form of RFC3339. -/// A space or a 'T' are acepted as the separator between the date and time -/// parts. Additional spaces are allowed between each component. -/// -/// All of these examples are equivalent: -/// ``` -/// # use chrono::{DateTime, Local}; -/// "2012-12-12T12:12:12Z".parse::>(); -/// "2012-12-12 12:12:12Z".parse::>(); -/// "2012- 12-12T12: 12:12Z".parse::>(); -/// ``` -#[cfg(feature = "clock")] -impl str::FromStr for DateTime { - type Err = ParseError; - - fn from_str(s: &str) -> ParseResult> { - s.parse::>().map(|dt| dt.with_timezone(&Local)) - } -} - -#[cfg(any(feature = "std", test))] -impl From for DateTime { - fn from(t: SystemTime) -> DateTime { - let (sec, nsec) = match t.duration_since(UNIX_EPOCH) { - Ok(dur) => (dur.as_secs() as i64, dur.subsec_nanos()), - Err(e) => { - // unlikely but should be handled - let dur = e.duration(); - let (sec, nsec) = (dur.as_secs() as i64, dur.subsec_nanos()); - if nsec == 0 { - (-sec, 0) - } else { - (-sec - 1, 1_000_000_000 - nsec) - } - } - }; - Utc.timestamp(sec, nsec) - } -} - -#[cfg(feature = "clock")] -impl From for DateTime { - fn from(t: SystemTime) -> DateTime { - DateTime::::from(t).with_timezone(&Local) - } -} - -#[cfg(any(feature = "std", test))] -impl From> for SystemTime { - fn from(dt: DateTime) -> SystemTime { - use std::time::Duration; - - let sec = dt.timestamp(); - let nsec = dt.timestamp_subsec_nanos(); - if sec < 0 { - // unlikely but should be handled - UNIX_EPOCH - Duration::new(-sec as u64, 0) + Duration::new(0, nsec) - } else { - UNIX_EPOCH + Duration::new(sec as u64, nsec) - } - } -} - -#[cfg(all(target_arch = "wasm32", not(target_os = "wasi"), feature = "wasmbind"))] -impl From for DateTime { - fn from(date: js_sys::Date) -> DateTime { - DateTime::::from(&date) - } -} - -#[cfg(all(target_arch = "wasm32", not(target_os = "wasi"), feature = "wasmbind"))] -impl From<&js_sys::Date> for DateTime { - fn from(date: &js_sys::Date) -> DateTime { - Utc.timestamp_millis(date.get_time() as i64) - } -} - -#[cfg(all(target_arch = "wasm32", not(target_os = "wasi"), feature = "wasmbind"))] -impl From> for js_sys::Date { - /// Converts a `DateTime` to a JS `Date`. The resulting value may be lossy, - /// any values that have a millisecond timestamp value greater/less than ±8,640,000,000,000,000 - /// (April 20, 271821 BCE ~ September 13, 275760 CE) will become invalid dates in JS. - fn from(date: DateTime) -> js_sys::Date { - let js_millis = wasm_bindgen::JsValue::from_f64(date.timestamp_millis() as f64); - js_sys::Date::new(&js_millis) - } -} - -#[test] -fn test_auto_conversion() { - let utc_dt = Utc.ymd(2018, 9, 5).and_hms(23, 58, 0); - let cdt_dt = FixedOffset::west(5 * 60 * 60).ymd(2018, 9, 5).and_hms(18, 58, 0); - let utc_dt2: DateTime = cdt_dt.into(); - assert_eq!(utc_dt, utc_dt2); -} - -#[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))] -fn test_encodable_json(to_string_utc: FUtc, to_string_fixed: FFixed) -where - FUtc: Fn(&DateTime) -> Result, - FFixed: Fn(&DateTime) -> Result, - E: ::core::fmt::Debug, -{ - assert_eq!( - to_string_utc(&Utc.ymd(2014, 7, 24).and_hms(12, 34, 6)).ok(), - Some(r#""2014-07-24T12:34:06Z""#.into()) - ); - - assert_eq!( - to_string_fixed(&FixedOffset::east(3660).ymd(2014, 7, 24).and_hms(12, 34, 6)).ok(), - Some(r#""2014-07-24T12:34:06+01:01""#.into()) - ); - assert_eq!( - to_string_fixed(&FixedOffset::east(3650).ymd(2014, 7, 24).and_hms(12, 34, 6)).ok(), - Some(r#""2014-07-24T12:34:06+01:00:50""#.into()) - ); -} - -#[cfg(all(test, feature = "clock", any(feature = "rustc-serialize", feature = "serde")))] -fn test_decodable_json( - utc_from_str: FUtc, - fixed_from_str: FFixed, - local_from_str: FLocal, -) where - FUtc: Fn(&str) -> Result, E>, - FFixed: Fn(&str) -> Result, E>, - FLocal: Fn(&str) -> Result, E>, - E: ::core::fmt::Debug, -{ - // should check against the offset as well (the normal DateTime comparison will ignore them) - fn norm(dt: &Option>) -> Option<(&DateTime, &Tz::Offset)> { - dt.as_ref().map(|dt| (dt, dt.offset())) - } - - assert_eq!( - norm(&utc_from_str(r#""2014-07-24T12:34:06Z""#).ok()), - norm(&Some(Utc.ymd(2014, 7, 24).and_hms(12, 34, 6))) - ); - assert_eq!( - norm(&utc_from_str(r#""2014-07-24T13:57:06+01:23""#).ok()), - norm(&Some(Utc.ymd(2014, 7, 24).and_hms(12, 34, 6))) - ); - - assert_eq!( - norm(&fixed_from_str(r#""2014-07-24T12:34:06Z""#).ok()), - norm(&Some(FixedOffset::east(0).ymd(2014, 7, 24).and_hms(12, 34, 6))) - ); - assert_eq!( - norm(&fixed_from_str(r#""2014-07-24T13:57:06+01:23""#).ok()), - norm(&Some(FixedOffset::east(60 * 60 + 23 * 60).ymd(2014, 7, 24).and_hms(13, 57, 6))) - ); - - // we don't know the exact local offset but we can check that - // the conversion didn't change the instant itself - assert_eq!( - local_from_str(r#""2014-07-24T12:34:06Z""#).expect("local shouuld parse"), - Utc.ymd(2014, 7, 24).and_hms(12, 34, 6) - ); - assert_eq!( - local_from_str(r#""2014-07-24T13:57:06+01:23""#).expect("local should parse with offset"), - Utc.ymd(2014, 7, 24).and_hms(12, 34, 6) - ); - - assert!(utc_from_str(r#""2014-07-32T12:34:06Z""#).is_err()); - assert!(fixed_from_str(r#""2014-07-32T12:34:06Z""#).is_err()); -} - -#[cfg(all(test, feature = "clock", feature = "rustc-serialize"))] -fn test_decodable_json_timestamps( - utc_from_str: FUtc, - fixed_from_str: FFixed, - local_from_str: FLocal, -) where - FUtc: Fn(&str) -> Result, E>, - FFixed: Fn(&str) -> Result, E>, - FLocal: Fn(&str) -> Result, E>, - E: ::core::fmt::Debug, -{ - fn norm(dt: &Option>) -> Option<(&DateTime, &Tz::Offset)> { - dt.as_ref().map(|dt| (dt, dt.offset())) - } - - assert_eq!( - norm(&utc_from_str("0").ok().map(DateTime::from)), - norm(&Some(Utc.ymd(1970, 1, 1).and_hms(0, 0, 0))) - ); - assert_eq!( - norm(&utc_from_str("-1").ok().map(DateTime::from)), - norm(&Some(Utc.ymd(1969, 12, 31).and_hms(23, 59, 59))) - ); - - assert_eq!( - norm(&fixed_from_str("0").ok().map(DateTime::from)), - norm(&Some(FixedOffset::east(0).ymd(1970, 1, 1).and_hms(0, 0, 0))) - ); - assert_eq!( - norm(&fixed_from_str("-1").ok().map(DateTime::from)), - norm(&Some(FixedOffset::east(0).ymd(1969, 12, 31).and_hms(23, 59, 59))) - ); - - assert_eq!( - *fixed_from_str("0").expect("0 timestamp should parse"), - Utc.ymd(1970, 1, 1).and_hms(0, 0, 0) - ); - assert_eq!( - *local_from_str("-1").expect("-1 timestamp should parse"), - Utc.ymd(1969, 12, 31).and_hms(23, 59, 59) - ); -} - -#[cfg(feature = "rustc-serialize")] -pub mod rustc_serialize { - use super::DateTime; - use core::fmt; - use core::ops::Deref; - #[cfg(feature = "clock")] - use offset::Local; - use offset::{FixedOffset, LocalResult, TimeZone, Utc}; - use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; - - impl Encodable for DateTime { - fn encode(&self, s: &mut S) -> Result<(), S::Error> { - format!("{:?}", self).encode(s) - } - } - - // lik? function to convert a LocalResult into a serde-ish Result - fn from(me: LocalResult, d: &mut D) -> Result - where - D: Decoder, - T: fmt::Display, - { - match me { - LocalResult::None => Err(d.error("value is not a legal timestamp")), - LocalResult::Ambiguous(..) => Err(d.error("value is an ambiguous timestamp")), - LocalResult::Single(val) => Ok(val), - } - } - - impl Decodable for DateTime { - fn decode(d: &mut D) -> Result, D::Error> { - d.read_str()? - .parse::>() - .map_err(|_| d.error("invalid date and time")) - } - } - - #[allow(deprecated)] - impl Decodable for TsSeconds { - #[allow(deprecated)] - fn decode(d: &mut D) -> Result, D::Error> { - from(FixedOffset::east(0).timestamp_opt(d.read_i64()?, 0), d).map(TsSeconds) - } - } - - impl Decodable for DateTime { - fn decode(d: &mut D) -> Result, D::Error> { - d.read_str()? - .parse::>() - .map(|dt| dt.with_timezone(&Utc)) - .map_err(|_| d.error("invalid date and time")) - } - } - - /// A [`DateTime`] that can be deserialized from a timestamp - /// - /// A timestamp here is seconds since the epoch - #[derive(Debug)] - pub struct TsSeconds(DateTime); - - #[allow(deprecated)] - impl From> for DateTime { - /// Pull the inner DateTime out - #[allow(deprecated)] - fn from(obj: TsSeconds) -> DateTime { - obj.0 - } - } - - #[allow(deprecated)] - impl Deref for TsSeconds { - type Target = DateTime; - - fn deref(&self) -> &Self::Target { - &self.0 - } - } - - #[allow(deprecated)] - impl Decodable for TsSeconds { - fn decode(d: &mut D) -> Result, D::Error> { - from(Utc.timestamp_opt(d.read_i64()?, 0), d).map(TsSeconds) - } - } - - #[cfg(feature = "clock")] - impl Decodable for DateTime { - fn decode(d: &mut D) -> Result, D::Error> { - match d.read_str()?.parse::>() { - Ok(dt) => Ok(dt.with_timezone(&Local)), - Err(_) => Err(d.error("invalid date and time")), - } - } - } - - #[cfg(feature = "clock")] - #[allow(deprecated)] - impl Decodable for TsSeconds { - #[allow(deprecated)] - fn decode(d: &mut D) -> Result, D::Error> { - from(Utc.timestamp_opt(d.read_i64()?, 0), d) - .map(|dt| TsSeconds(dt.with_timezone(&Local))) - } - } - - #[cfg(test)] - use rustc_serialize::json; - - #[test] - fn test_encodable() { - super::test_encodable_json(json::encode, json::encode); - } - - #[cfg(feature = "clock")] - #[test] - fn test_decodable() { - super::test_decodable_json(json::decode, json::decode, json::decode); - } - - #[cfg(feature = "clock")] - #[test] - fn test_decodable_timestamps() { - super::test_decodable_json_timestamps(json::decode, json::decode, json::decode); - } -} - -/// documented at re-export site -#[cfg(feature = "serde")] -pub mod serde { - use super::DateTime; - use core::fmt; - #[cfg(feature = "clock")] - use offset::Local; - use offset::{FixedOffset, LocalResult, TimeZone, Utc}; - use serdelib::{de, ser}; - use {ne_timestamp, SerdeError}; - - #[doc(hidden)] - #[derive(Debug)] - pub struct SecondsTimestampVisitor; - - #[doc(hidden)] - #[derive(Debug)] - pub struct NanoSecondsTimestampVisitor; - - #[doc(hidden)] - #[derive(Debug)] - pub struct MicroSecondsTimestampVisitor; - - #[doc(hidden)] - #[derive(Debug)] - pub struct MilliSecondsTimestampVisitor; - - // lik? function to convert a LocalResult into a serde-ish Result - fn serde_from(me: LocalResult, ts: &V) -> Result - where - E: de::Error, - V: fmt::Display, - T: fmt::Display, - { - match me { - LocalResult::None => Err(E::custom(ne_timestamp(ts))), - LocalResult::Ambiguous(min, max) => { - Err(E::custom(SerdeError::Ambiguous { timestamp: ts, min: min, max: max })) - } - LocalResult::Single(val) => Ok(val), - } - } - - /// Serialize into a rfc3339 time string - /// - /// See [the `serde` module](./serde/index.html) for alternate - /// serializations. - impl ser::Serialize for DateTime { - fn serialize(&self, serializer: S) -> Result - where - S: ser::Serializer, - { - struct FormatWrapped<'a, D: 'a> { - inner: &'a D, - } - - impl<'a, D: fmt::Debug> fmt::Display for FormatWrapped<'a, D> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.inner.fmt(f) - } - } - - // Debug formatting is correct RFC3339, and it allows Zulu. - serializer.collect_str(&FormatWrapped { inner: &self }) - } - } - - struct DateTimeVisitor; - - impl<'de> de::Visitor<'de> for DateTimeVisitor { - type Value = DateTime; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a formatted date and time string or a unix timestamp") - } - - fn visit_str(self, value: &str) -> Result - where - E: de::Error, - { - value.parse().map_err(E::custom) - } - } - - /// Deserialize a value that optionally includes a timezone offset in its - /// string representation - /// - /// The value to be deserialized must be an rfc3339 string. - /// - /// See [the `serde` module](./serde/index.html) for alternate - /// deserialization formats. - impl<'de> de::Deserialize<'de> for DateTime { - fn deserialize(deserializer: D) -> Result - where - D: de::Deserializer<'de>, - { - deserializer.deserialize_str(DateTimeVisitor) - } - } - - /// Deserialize into a UTC value - /// - /// The value to be deserialized must be an rfc3339 string. - /// - /// See [the `serde` module](./serde/index.html) for alternate - /// deserialization formats. - impl<'de> de::Deserialize<'de> for DateTime { - fn deserialize(deserializer: D) -> Result - where - D: de::Deserializer<'de>, - { - deserializer.deserialize_str(DateTimeVisitor).map(|dt| dt.with_timezone(&Utc)) - } - } - - /// Deserialize a value that includes no timezone in its string - /// representation - /// - /// The value to be deserialized must be an rfc3339 string. - /// - /// See [the `serde` module](./serde/index.html) for alternate - /// serialization formats. - #[cfg(feature = "clock")] - impl<'de> de::Deserialize<'de> for DateTime { - fn deserialize(deserializer: D) -> Result - where - D: de::Deserializer<'de>, - { - deserializer.deserialize_str(DateTimeVisitor).map(|dt| dt.with_timezone(&Local)) - } - } - - /// Ser/de to/from timestamps in nanoseconds - /// - /// Intended for use with `serde`'s `with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_nanoseconds; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_nanoseconds")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let time = Utc.ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355733}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_nanoseconds { - use core::fmt; - use serdelib::{de, ser}; - - use offset::TimeZone; - use {DateTime, Utc}; - - use super::{serde_from, NanoSecondsTimestampVisitor}; - - /// Serialize a UTC datetime into an integer number of nanoseconds since the epoch - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_nanoseconds::serialize as to_nano_ts; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_nano_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Utc.ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355733}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(dt: &DateTime, serializer: S) -> Result - where - S: ser::Serializer, - { - serializer.serialize_i64(dt.timestamp_nanos()) - } - - /// Deserialize a [`DateTime`] from a nanosecond timestamp - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{DateTime, Utc}; - /// use chrono::serde::ts_nanoseconds::deserialize as from_nano_ts; - /// #[derive(Deserialize)] - /// struct S { - /// #[serde(deserialize_with = "from_nano_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355733 }"#)?; - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(NanoSecondsTimestampVisitor) - } - - impl<'de> de::Visitor<'de> for NanoSecondsTimestampVisitor { - type Value = DateTime; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in nanoseconds") - } - - /// Deserialize a timestamp in nanoseconds since the epoch - fn visit_i64(self, value: i64) -> Result - where - E: de::Error, - { - serde_from( - Utc.timestamp_opt(value / 1_000_000_000, (value % 1_000_000_000) as u32), - &value, - ) - } - - /// Deserialize a timestamp in nanoseconds since the epoch - fn visit_u64(self, value: u64) -> Result - where - E: de::Error, - { - serde_from( - Utc.timestamp_opt( - (value / 1_000_000_000) as i64, - (value % 1_000_000_000) as u32, - ), - &value, - ) - } - } - } - - /// Ser/de to/from timestamps in nanoseconds - /// - /// Intended for use with `serde`'s `with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_nanoseconds_option; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_nanoseconds_option")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let time = Some(Utc.ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733)); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355733}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_nanoseconds_option { - use core::fmt; - use serdelib::{de, ser}; - - use {DateTime, Utc}; - - use super::NanoSecondsTimestampVisitor; - - /// Serialize a UTC datetime into an integer number of nanoseconds since the epoch or none - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_nanoseconds_option::serialize as to_nano_tsopt; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_nano_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Some(Utc.ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733)), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355733}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(opt: &Option>, serializer: S) -> Result - where - S: ser::Serializer, - { - match *opt { - Some(ref dt) => serializer.serialize_some(&dt.timestamp_nanos()), - None => serializer.serialize_none(), - } - } - - /// Deserialize a `DateTime` from a nanosecond timestamp or none - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{DateTime, Utc}; - /// use chrono::serde::ts_nanoseconds_option::deserialize as from_nano_tsopt; - /// #[derive(Deserialize)] - /// struct S { - /// #[serde(deserialize_with = "from_nano_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355733 }"#)?; - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result>, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_option(OptionNanoSecondsTimestampVisitor) - } - - struct OptionNanoSecondsTimestampVisitor; - - impl<'de> de::Visitor<'de> for OptionNanoSecondsTimestampVisitor { - type Value = Option>; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in nanoseconds or none") - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_some(self, d: D) -> Result - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(NanoSecondsTimestampVisitor).map(Some) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_none(self) -> Result - where - E: de::Error, - { - Ok(None) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_unit(self) -> Result - where - E: de::Error, - { - Ok(None) - } - } - } - - /// Ser/de to/from timestamps in microseconds - /// - /// Intended for use with `serde`'s `with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_microseconds; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_microseconds")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let time = Utc.ymd(2018, 5, 17).and_hms_micro(02, 04, 59, 918355); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_microseconds { - use core::fmt; - - use serdelib::{de, ser}; - - use offset::TimeZone; - use {DateTime, Utc}; - - use super::{serde_from, MicroSecondsTimestampVisitor}; - - /// Serialize a UTC datetime into an integer number of microseconds since the epoch - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_microseconds::serialize as to_micro_ts; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_micro_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Utc.ymd(2018, 5, 17).and_hms_micro(02, 04, 59, 918355), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(dt: &DateTime, serializer: S) -> Result - where - S: ser::Serializer, - { - serializer.serialize_i64(dt.timestamp_micros()) - } - - /// Deserialize a `DateTime` from a microsecond timestamp - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{DateTime, Utc}; - /// use chrono::serde::ts_microseconds::deserialize as from_micro_ts; - /// #[derive(Deserialize)] - /// struct S { - /// #[serde(deserialize_with = "from_micro_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355 }"#)?; - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(MicroSecondsTimestampVisitor) - } - - impl<'de> de::Visitor<'de> for MicroSecondsTimestampVisitor { - type Value = DateTime; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in microseconds") - } - - /// Deserialize a timestamp in milliseconds since the epoch - fn visit_i64(self, value: i64) -> Result - where - E: de::Error, - { - serde_from( - Utc.timestamp_opt(value / 1_000_000, ((value % 1_000_000) * 1_000) as u32), - &value, - ) - } - - /// Deserialize a timestamp in milliseconds since the epoch - fn visit_u64(self, value: u64) -> Result - where - E: de::Error, - { - serde_from( - Utc.timestamp_opt( - (value / 1_000_000) as i64, - ((value % 1_000_000) * 1_000) as u32, - ), - &value, - ) - } - } - } - - /// Ser/de to/from optional timestamps in microseconds - /// - /// Intended for use with `serde`'s `with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_microseconds_option; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_microseconds_option")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let time = Some(Utc.ymd(2018, 5, 17).and_hms_micro(02, 04, 59, 918355)); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_microseconds_option { - use core::fmt; - use serdelib::{de, ser}; - - use {DateTime, Utc}; - - use super::MicroSecondsTimestampVisitor; - - /// Serialize a UTC datetime into an integer number of microseconds since the epoch or none - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_microseconds_option::serialize as to_micro_tsopt; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_micro_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Some(Utc.ymd(2018, 5, 17).and_hms_micro(02, 04, 59, 918355)), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918355}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(opt: &Option>, serializer: S) -> Result - where - S: ser::Serializer, - { - match *opt { - Some(ref dt) => serializer.serialize_some(&dt.timestamp_micros()), - None => serializer.serialize_none(), - } - } - - /// Deserialize a `DateTime` from a microsecond timestamp or none - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{DateTime, Utc}; - /// use chrono::serde::ts_microseconds_option::deserialize as from_micro_tsopt; - /// #[derive(Deserialize)] - /// struct S { - /// #[serde(deserialize_with = "from_micro_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355 }"#)?; - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result>, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_option(OptionMicroSecondsTimestampVisitor) - } - - struct OptionMicroSecondsTimestampVisitor; - - impl<'de> de::Visitor<'de> for OptionMicroSecondsTimestampVisitor { - type Value = Option>; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in microseconds or none") - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_some(self, d: D) -> Result - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(MicroSecondsTimestampVisitor).map(Some) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_none(self) -> Result - where - E: de::Error, - { - Ok(None) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_unit(self) -> Result - where - E: de::Error, - { - Ok(None) - } - } - } - - /// Ser/de to/from timestamps in milliseconds - /// - /// Intended for use with `serde`s `with` attribute. - /// - /// # Example - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_milliseconds; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_milliseconds")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let time = Utc.ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_milliseconds { - use core::fmt; - use serdelib::{de, ser}; - - use offset::TimeZone; - use {DateTime, Utc}; - - use super::{serde_from, MilliSecondsTimestampVisitor}; - - /// Serialize a UTC datetime into an integer number of milliseconds since the epoch - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_milliseconds::serialize as to_milli_ts; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_milli_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Utc.ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(dt: &DateTime, serializer: S) -> Result - where - S: ser::Serializer, - { - serializer.serialize_i64(dt.timestamp_millis()) - } - - /// Deserialize a `DateTime` from a millisecond timestamp - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{DateTime, Utc}; - /// use chrono::serde::ts_milliseconds::deserialize as from_milli_ts; - /// #[derive(Deserialize)] - /// struct S { - /// #[serde(deserialize_with = "from_milli_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918 }"#)?; - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(MilliSecondsTimestampVisitor).map(|dt| dt.with_timezone(&Utc)) - } - - impl<'de> de::Visitor<'de> for MilliSecondsTimestampVisitor { - type Value = DateTime; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in milliseconds") - } - - /// Deserialize a timestamp in milliseconds since the epoch - fn visit_i64(self, value: i64) -> Result - where - E: de::Error, - { - serde_from( - Utc.timestamp_opt(value / 1000, ((value % 1000) * 1_000_000) as u32), - &value, - ) - } - - /// Deserialize a timestamp in milliseconds since the epoch - fn visit_u64(self, value: u64) -> Result - where - E: de::Error, - { - serde_from( - Utc.timestamp_opt((value / 1000) as i64, ((value % 1000) * 1_000_000) as u32), - &value, - ) - } - } - } - - /// Ser/de to/from optional timestamps in milliseconds - /// - /// Intended for use with `serde`s `with` attribute. - /// - /// # Example - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_milliseconds_option; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_milliseconds_option")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let time = Some(Utc.ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918)); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_milliseconds_option { - use core::fmt; - use serdelib::{de, ser}; - - use {DateTime, Utc}; - - use super::MilliSecondsTimestampVisitor; - - /// Serialize a UTC datetime into an integer number of milliseconds since the epoch or none - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_milliseconds_option::serialize as to_milli_tsopt; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_milli_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Some(Utc.ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918)), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1526522699918}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(opt: &Option>, serializer: S) -> Result - where - S: ser::Serializer, - { - match *opt { - Some(ref dt) => serializer.serialize_some(&dt.timestamp_millis()), - None => serializer.serialize_none(), - } - } - - /// Deserialize a `DateTime` from a millisecond timestamp or none - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::prelude::*; - /// use chrono::serde::ts_milliseconds_option::deserialize as from_milli_tsopt; - /// - /// #[derive(Deserialize, PartialEq, Debug)] - /// #[serde(untagged)] - /// enum E { - /// V(T), - /// } - /// - /// #[derive(Deserialize, PartialEq, Debug)] - /// struct S { - /// #[serde(default, deserialize_with = "from_milli_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result<(), serde_json::Error> { - /// let my_s: E = serde_json::from_str(r#"{ "time": 1526522699918 }"#)?; - /// assert_eq!(my_s, E::V(S { time: Some(Utc.timestamp(1526522699, 918000000)) })); - /// let s: E = serde_json::from_str(r#"{ "time": null }"#)?; - /// assert_eq!(s, E::V(S { time: None })); - /// let t: E = serde_json::from_str(r#"{}"#)?; - /// assert_eq!(t, E::V(S { time: None })); - /// # Ok(()) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result>, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_option(OptionMilliSecondsTimestampVisitor) - .map(|opt| opt.map(|dt| dt.with_timezone(&Utc))) - } - - struct OptionMilliSecondsTimestampVisitor; - - impl<'de> de::Visitor<'de> for OptionMilliSecondsTimestampVisitor { - type Value = Option>; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in milliseconds or none") - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_some(self, d: D) -> Result - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(MilliSecondsTimestampVisitor).map(Some) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_none(self) -> Result - where - E: de::Error, - { - Ok(None) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_unit(self) -> Result - where - E: de::Error, - { - Ok(None) - } - } - } - - /// Ser/de to/from timestamps in seconds - /// - /// Intended for use with `serde`'s `with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_seconds; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_seconds")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let time = Utc.ymd(2015, 5, 15).and_hms(10, 0, 0); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1431684000}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_seconds { - use core::fmt; - use serdelib::{de, ser}; - - use offset::TimeZone; - use {DateTime, Utc}; - - use super::{serde_from, SecondsTimestampVisitor}; - - /// Serialize a UTC datetime into an integer number of seconds since the epoch - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_seconds::serialize as to_ts; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Utc.ymd(2015, 5, 15).and_hms(10, 0, 0), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1431684000}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(dt: &DateTime, serializer: S) -> Result - where - S: ser::Serializer, - { - serializer.serialize_i64(dt.timestamp()) - } - - /// Deserialize a `DateTime` from a seconds timestamp - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{DateTime, Utc}; - /// use chrono::serde::ts_seconds::deserialize as from_ts; - /// #[derive(Deserialize)] - /// struct S { - /// #[serde(deserialize_with = "from_ts")] - /// time: DateTime - /// } - /// - /// # fn example() -> Result { - /// let my_s: S = serde_json::from_str(r#"{ "time": 1431684000 }"#)?; - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(SecondsTimestampVisitor) - } - - impl<'de> de::Visitor<'de> for SecondsTimestampVisitor { - type Value = DateTime; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in seconds") - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_i64(self, value: i64) -> Result - where - E: de::Error, - { - serde_from(Utc.timestamp_opt(value, 0), &value) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_u64(self, value: u64) -> Result - where - E: de::Error, - { - serde_from(Utc.timestamp_opt(value as i64, 0), &value) - } - } - } - - /// Ser/de to/from optional timestamps in seconds - /// - /// Intended for use with `serde`'s `with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_seconds_option; - /// #[derive(Deserialize, Serialize)] - /// struct S { - /// #[serde(with = "ts_seconds_option")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let time = Some(Utc.ymd(2015, 5, 15).and_hms(10, 0, 0)); - /// let my_s = S { - /// time: time.clone(), - /// }; - /// - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1431684000}"#); - /// let my_s: S = serde_json::from_str(&as_string)?; - /// assert_eq!(my_s.time, time); - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub mod ts_seconds_option { - use core::fmt; - use serdelib::{de, ser}; - - use {DateTime, Utc}; - - use super::SecondsTimestampVisitor; - - /// Serialize a UTC datetime into an integer number of seconds since the epoch or none - /// - /// Intended for use with `serde`s `serialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{TimeZone, DateTime, Utc}; - /// use chrono::serde::ts_seconds_option::serialize as to_tsopt; - /// #[derive(Serialize)] - /// struct S { - /// #[serde(serialize_with = "to_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let my_s = S { - /// time: Some(Utc.ymd(2015, 5, 15).and_hms(10, 0, 0)), - /// }; - /// let as_string = serde_json::to_string(&my_s)?; - /// assert_eq!(as_string, r#"{"time":1431684000}"#); - /// # Ok(as_string) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn serialize(opt: &Option>, serializer: S) -> Result - where - S: ser::Serializer, - { - match *opt { - Some(ref dt) => serializer.serialize_some(&dt.timestamp()), - None => serializer.serialize_none(), - } - } - - /// Deserialize a `DateTime` from a seconds timestamp or none - /// - /// Intended for use with `serde`s `deserialize_with` attribute. - /// - /// # Example: - /// - /// ```rust - /// # // We mark this ignored so that we can test on 1.13 (which does not - /// # // support custom derive), and run tests with --ignored on beta and - /// # // nightly to actually trigger these. - /// # - /// # #[macro_use] extern crate serde_derive; - /// # #[macro_use] extern crate serde_json; - /// # extern crate chrono; - /// # use chrono::{DateTime, Utc}; - /// use chrono::serde::ts_seconds_option::deserialize as from_tsopt; - /// #[derive(Deserialize)] - /// struct S { - /// #[serde(deserialize_with = "from_tsopt")] - /// time: Option> - /// } - /// - /// # fn example() -> Result { - /// let my_s: S = serde_json::from_str(r#"{ "time": 1431684000 }"#)?; - /// # Ok(my_s) - /// # } - /// # fn main() { example().unwrap(); } - /// ``` - pub fn deserialize<'de, D>(d: D) -> Result>, D::Error> - where - D: de::Deserializer<'de>, - { - d.deserialize_option(OptionSecondsTimestampVisitor) - } - - struct OptionSecondsTimestampVisitor; - - impl<'de> de::Visitor<'de> for OptionSecondsTimestampVisitor { - type Value = Option>; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a unix timestamp in seconds or none") - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_some(self, d: D) -> Result - where - D: de::Deserializer<'de>, - { - d.deserialize_i64(SecondsTimestampVisitor).map(Some) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_none(self) -> Result - where - E: de::Error, - { - Ok(None) - } - - /// Deserialize a timestamp in seconds since the epoch - fn visit_unit(self) -> Result - where - E: de::Error, - { - Ok(None) - } - } - } - - #[cfg(test)] - extern crate bincode; - #[cfg(test)] - extern crate serde_json; - - #[test] - fn test_serde_serialize() { - super::test_encodable_json(self::serde_json::to_string, self::serde_json::to_string); - } - - #[cfg(feature = "clock")] - #[test] - fn test_serde_deserialize() { - super::test_decodable_json( - |input| self::serde_json::from_str(&input), - |input| self::serde_json::from_str(&input), - |input| self::serde_json::from_str(&input), - ); - } - - #[test] - fn test_serde_bincode() { - // Bincode is relevant to test separately from JSON because - // it is not self-describing. - use self::bincode::{deserialize, serialize, Infinite}; - - let dt = Utc.ymd(2014, 7, 24).and_hms(12, 34, 6); - let encoded = serialize(&dt, Infinite).unwrap(); - let decoded: DateTime = deserialize(&encoded).unwrap(); - assert_eq!(dt, decoded); - assert_eq!(dt.offset(), decoded.offset()); - } -} - -#[cfg(test)] -mod tests { - use super::DateTime; - use consts::f64; - use naive::{NaiveDate, NaiveTime}; - #[cfg(feature = "clock")] - use offset::Local; - use offset::{FixedOffset, TimeZone, Utc}; - use oldtime::Duration; - use std::time::{SystemTime, UNIX_EPOCH}; - #[cfg(feature = "clock")] - use Datelike; - - #[test] - #[allow(non_snake_case)] - fn test_datetime_offset() { - let Est = FixedOffset::west(5 * 60 * 60); - let Edt = FixedOffset::west(4 * 60 * 60); - let Kst = FixedOffset::east(9 * 60 * 60); - - assert_eq!(format!("{}", Utc.ymd(2014, 5, 6).and_hms(7, 8, 9)), "2014-05-06 07:08:09 UTC"); - assert_eq!( - format!("{}", Edt.ymd(2014, 5, 6).and_hms(7, 8, 9)), - "2014-05-06 07:08:09 -04:00" - ); - assert_eq!( - format!("{}", Kst.ymd(2014, 5, 6).and_hms(7, 8, 9)), - "2014-05-06 07:08:09 +09:00" - ); - assert_eq!(format!("{:?}", Utc.ymd(2014, 5, 6).and_hms(7, 8, 9)), "2014-05-06T07:08:09Z"); - assert_eq!( - format!("{:?}", Edt.ymd(2014, 5, 6).and_hms(7, 8, 9)), - "2014-05-06T07:08:09-04:00" - ); - assert_eq!( - format!("{:?}", Kst.ymd(2014, 5, 6).and_hms(7, 8, 9)), - "2014-05-06T07:08:09+09:00" - ); - - // edge cases - assert_eq!(format!("{:?}", Utc.ymd(2014, 5, 6).and_hms(0, 0, 0)), "2014-05-06T00:00:00Z"); - assert_eq!( - format!("{:?}", Edt.ymd(2014, 5, 6).and_hms(0, 0, 0)), - "2014-05-06T00:00:00-04:00" - ); - assert_eq!( - format!("{:?}", Kst.ymd(2014, 5, 6).and_hms(0, 0, 0)), - "2014-05-06T00:00:00+09:00" - ); - assert_eq!( - format!("{:?}", Utc.ymd(2014, 5, 6).and_hms(23, 59, 59)), - "2014-05-06T23:59:59Z" - ); - assert_eq!( - format!("{:?}", Edt.ymd(2014, 5, 6).and_hms(23, 59, 59)), - "2014-05-06T23:59:59-04:00" - ); - assert_eq!( - format!("{:?}", Kst.ymd(2014, 5, 6).and_hms(23, 59, 59)), - "2014-05-06T23:59:59+09:00" - ); - - let dt = Utc.ymd(2014, 5, 6).and_hms(7, 8, 9); - assert_eq!(dt, Edt.ymd(2014, 5, 6).and_hms(3, 8, 9)); - assert_eq!(dt + Duration::seconds(3600 + 60 + 1), Utc.ymd(2014, 5, 6).and_hms(8, 9, 10)); - assert_eq!( - dt.signed_duration_since(Edt.ymd(2014, 5, 6).and_hms(10, 11, 12)), - Duration::seconds(-7 * 3600 - 3 * 60 - 3) - ); - - assert_eq!(*Utc.ymd(2014, 5, 6).and_hms(7, 8, 9).offset(), Utc); - assert_eq!(*Edt.ymd(2014, 5, 6).and_hms(7, 8, 9).offset(), Edt); - assert!(*Edt.ymd(2014, 5, 6).and_hms(7, 8, 9).offset() != Est); - } - - #[test] - fn test_datetime_date_and_time() { - let tz = FixedOffset::east(5 * 60 * 60); - let d = tz.ymd(2014, 5, 6).and_hms(7, 8, 9); - assert_eq!(d.time(), NaiveTime::from_hms(7, 8, 9)); - assert_eq!(d.date(), tz.ymd(2014, 5, 6)); - assert_eq!(d.date().naive_local(), NaiveDate::from_ymd(2014, 5, 6)); - assert_eq!(d.date().and_time(d.time()), Some(d)); - - let tz = FixedOffset::east(4 * 60 * 60); - let d = tz.ymd(2016, 5, 4).and_hms(3, 2, 1); - assert_eq!(d.time(), NaiveTime::from_hms(3, 2, 1)); - assert_eq!(d.date(), tz.ymd(2016, 5, 4)); - assert_eq!(d.date().naive_local(), NaiveDate::from_ymd(2016, 5, 4)); - assert_eq!(d.date().and_time(d.time()), Some(d)); - - let tz = FixedOffset::west(13 * 60 * 60); - let d = tz.ymd(2017, 8, 9).and_hms(12, 34, 56); - assert_eq!(d.time(), NaiveTime::from_hms(12, 34, 56)); - assert_eq!(d.date(), tz.ymd(2017, 8, 9)); - assert_eq!(d.date().naive_local(), NaiveDate::from_ymd(2017, 8, 9)); - assert_eq!(d.date().and_time(d.time()), Some(d)); - - let utc_d = Utc.ymd(2017, 8, 9).and_hms(12, 34, 56); - assert!(utc_d < d); - } - - #[test] - #[cfg(feature = "clock")] - fn test_datetime_with_timezone() { - let local_now = Local::now(); - let utc_now = local_now.with_timezone(&Utc); - let local_now2 = utc_now.with_timezone(&Local); - assert_eq!(local_now, local_now2); - } - - #[test] - #[allow(non_snake_case)] - fn test_datetime_rfc2822_and_rfc3339() { - let EDT = FixedOffset::east(5 * 60 * 60); - assert_eq!( - Utc.ymd(2015, 2, 18).and_hms(23, 16, 9).to_rfc2822(), - "Wed, 18 Feb 2015 23:16:09 +0000" - ); - assert_eq!( - Utc.ymd(2015, 2, 18).and_hms(23, 16, 9).to_rfc3339(), - "2015-02-18T23:16:09+00:00" - ); - assert_eq!( - EDT.ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150).to_rfc2822(), - "Wed, 18 Feb 2015 23:16:09 +0500" - ); - assert_eq!( - EDT.ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150).to_rfc3339(), - "2015-02-18T23:16:09.150+05:00" - ); - assert_eq!( - EDT.ymd(2015, 2, 18).and_hms_micro(23, 59, 59, 1_234_567).to_rfc2822(), - "Wed, 18 Feb 2015 23:59:60 +0500" - ); - assert_eq!( - EDT.ymd(2015, 2, 18).and_hms_micro(23, 59, 59, 1_234_567).to_rfc3339(), - "2015-02-18T23:59:60.234567+05:00" - ); - - assert_eq!( - DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:16:09 +0000"), - Ok(FixedOffset::east(0).ymd(2015, 2, 18).and_hms(23, 16, 9)) - ); - assert_eq!( - DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:16:09 -0000"), - Ok(FixedOffset::east(0).ymd(2015, 2, 18).and_hms(23, 16, 9)) - ); - assert_eq!( - DateTime::parse_from_rfc3339("2015-02-18T23:16:09Z"), - Ok(FixedOffset::east(0).ymd(2015, 2, 18).and_hms(23, 16, 9)) - ); - assert_eq!( - DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:59:60 +0500"), - Ok(EDT.ymd(2015, 2, 18).and_hms_milli(23, 59, 59, 1_000)) - ); - assert_eq!( - DateTime::parse_from_rfc3339("2015-02-18T23:59:60.234567+05:00"), - Ok(EDT.ymd(2015, 2, 18).and_hms_micro(23, 59, 59, 1_234_567)) - ); - } - - #[test] - fn test_rfc3339_opts() { - use SecondsFormat::*; - let pst = FixedOffset::east(8 * 60 * 60); - let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 084_660_000); - assert_eq!(dt.to_rfc3339_opts(Secs, false), "2018-01-11T10:05:13+08:00"); - assert_eq!(dt.to_rfc3339_opts(Secs, true), "2018-01-11T10:05:13+08:00"); - assert_eq!(dt.to_rfc3339_opts(Millis, false), "2018-01-11T10:05:13.084+08:00"); - assert_eq!(dt.to_rfc3339_opts(Micros, false), "2018-01-11T10:05:13.084660+08:00"); - assert_eq!(dt.to_rfc3339_opts(Nanos, false), "2018-01-11T10:05:13.084660000+08:00"); - assert_eq!(dt.to_rfc3339_opts(AutoSi, false), "2018-01-11T10:05:13.084660+08:00"); - - let ut = DateTime::::from_utc(dt.naive_utc(), Utc); - assert_eq!(ut.to_rfc3339_opts(Secs, false), "2018-01-11T02:05:13+00:00"); - assert_eq!(ut.to_rfc3339_opts(Secs, true), "2018-01-11T02:05:13Z"); - assert_eq!(ut.to_rfc3339_opts(Millis, false), "2018-01-11T02:05:13.084+00:00"); - assert_eq!(ut.to_rfc3339_opts(Millis, true), "2018-01-11T02:05:13.084Z"); - assert_eq!(ut.to_rfc3339_opts(Micros, true), "2018-01-11T02:05:13.084660Z"); - assert_eq!(ut.to_rfc3339_opts(Nanos, true), "2018-01-11T02:05:13.084660000Z"); - assert_eq!(ut.to_rfc3339_opts(AutoSi, true), "2018-01-11T02:05:13.084660Z"); - } - - #[test] - #[should_panic] - fn test_rfc3339_opts_nonexhaustive() { - use SecondsFormat; - let dt = Utc.ymd(1999, 10, 9).and_hms(1, 2, 3); - dt.to_rfc3339_opts(SecondsFormat::__NonExhaustive, true); - } - - #[test] - fn test_datetime_from_str() { - assert_eq!( - "2015-02-18T23:16:9.15Z".parse::>(), - Ok(FixedOffset::east(0).ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150)) - ); - assert_eq!( - "2015-02-18T23:16:9.15Z".parse::>(), - Ok(Utc.ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150)) - ); - assert_eq!( - "2015-02-18T23:16:9.15 UTC".parse::>(), - Ok(Utc.ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150)) - ); - assert_eq!( - "2015-02-18T23:16:9.15UTC".parse::>(), - Ok(Utc.ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150)) - ); - - assert_eq!( - "2015-2-18T23:16:9.15Z".parse::>(), - Ok(FixedOffset::east(0).ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150)) - ); - assert_eq!( - "2015-2-18T13:16:9.15-10:00".parse::>(), - Ok(FixedOffset::west(10 * 3600).ymd(2015, 2, 18).and_hms_milli(13, 16, 9, 150)) - ); - assert!("2015-2-18T23:16:9.15".parse::>().is_err()); - - assert_eq!( - "2015-2-18T23:16:9.15Z".parse::>(), - Ok(Utc.ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150)) - ); - assert_eq!( - "2015-2-18T13:16:9.15-10:00".parse::>(), - Ok(Utc.ymd(2015, 2, 18).and_hms_milli(23, 16, 9, 150)) - ); - assert!("2015-2-18T23:16:9.15".parse::>().is_err()); - - // no test for `DateTime`, we cannot verify that much. - } - - #[test] - fn test_datetime_parse_from_str() { - let ymdhms = |y, m, d, h, n, s, off| FixedOffset::east(off).ymd(y, m, d).and_hms(h, n, s); - assert_eq!( - DateTime::parse_from_str("2014-5-7T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"), - Ok(ymdhms(2014, 5, 7, 12, 34, 56, 570 * 60)) - ); // ignore offset - assert!(DateTime::parse_from_str("20140507000000", "%Y%m%d%H%M%S").is_err()); // no offset - assert!(DateTime::parse_from_str( - "Fri, 09 Aug 2013 23:54:35 GMT", - "%a, %d %b %Y %H:%M:%S GMT" - ) - .is_err()); - assert_eq!( - Utc.datetime_from_str("Fri, 09 Aug 2013 23:54:35 GMT", "%a, %d %b %Y %H:%M:%S GMT"), - Ok(Utc.ymd(2013, 8, 9).and_hms(23, 54, 35)) - ); - } - - #[test] - fn test_to_string_round_trip() { - let dt = Utc.ymd(2000, 1, 1).and_hms(0, 0, 0); - let _dt: DateTime = dt.to_string().parse().unwrap(); - - let ndt_fixed = dt.with_timezone(&FixedOffset::east(3600)); - let _dt: DateTime = ndt_fixed.to_string().parse().unwrap(); - - let ndt_fixed = dt.with_timezone(&FixedOffset::east(0)); - let _dt: DateTime = ndt_fixed.to_string().parse().unwrap(); - } - - #[test] - #[cfg(feature = "clock")] - fn test_to_string_round_trip_with_local() { - let ndt = Local::now(); - let _dt: DateTime = ndt.to_string().parse().unwrap(); - } - - #[test] - #[cfg(feature = "clock")] - fn test_datetime_format_with_local() { - // if we are not around the year boundary, local and UTC date should have the same year - let dt = Local::now().with_month(5).unwrap(); - assert_eq!(dt.format("%Y").to_string(), dt.with_timezone(&Utc).format("%Y").to_string()); - } - - #[test] - #[cfg(feature = "clock")] - fn test_datetime_is_copy() { - // UTC is known to be `Copy`. - let a = Utc::now(); - let b = a; - assert_eq!(a, b); - } - - #[test] - #[cfg(feature = "clock")] - fn test_datetime_is_send() { - use std::thread; - - // UTC is known to be `Send`. - let a = Utc::now(); - thread::spawn(move || { - let _ = a; - }) - .join() - .unwrap(); - } - - #[test] - fn test_subsecond_part() { - let datetime = Utc.ymd(2014, 7, 8).and_hms_nano(9, 10, 11, 1234567); - - assert_eq!(1, datetime.timestamp_subsec_millis()); - assert_eq!(1234, datetime.timestamp_subsec_micros()); - assert_eq!(1234567, datetime.timestamp_subsec_nanos()); - } - - #[test] - #[cfg(not(target_os = "windows"))] - fn test_from_system_time() { - use std::time::Duration; - - let epoch = Utc.ymd(1970, 1, 1).and_hms(0, 0, 0); - let nanos = 999_999_999; - - // SystemTime -> DateTime - assert_eq!(DateTime::::from(UNIX_EPOCH), epoch); - assert_eq!( - DateTime::::from(UNIX_EPOCH + Duration::new(999_999_999, nanos)), - Utc.ymd(2001, 9, 9).and_hms_nano(1, 46, 39, nanos) - ); - assert_eq!( - DateTime::::from(UNIX_EPOCH - Duration::new(999_999_999, nanos)), - Utc.ymd(1938, 4, 24).and_hms_nano(22, 13, 20, 1) - ); - - // DateTime -> SystemTime - assert_eq!(SystemTime::from(epoch), UNIX_EPOCH); - assert_eq!( - SystemTime::from(Utc.ymd(2001, 9, 9).and_hms_nano(1, 46, 39, nanos)), - UNIX_EPOCH + Duration::new(999_999_999, nanos) - ); - assert_eq!( - SystemTime::from(Utc.ymd(1938, 4, 24).and_hms_nano(22, 13, 20, 1)), - UNIX_EPOCH - Duration::new(999_999_999, 999_999_999) - ); - - // DateTime -> SystemTime (via `with_timezone`) - #[cfg(feature = "clock")] - { - assert_eq!(SystemTime::from(epoch.with_timezone(&Local)), UNIX_EPOCH); - } - assert_eq!(SystemTime::from(epoch.with_timezone(&FixedOffset::east(32400))), UNIX_EPOCH); - assert_eq!(SystemTime::from(epoch.with_timezone(&FixedOffset::west(28800))), UNIX_EPOCH); - } - - #[test] - #[cfg(target_os = "windows")] - fn test_from_system_time() { - use std::time::Duration; - - let nanos = 999_999_000; - - let epoch = Utc.ymd(1970, 1, 1).and_hms(0, 0, 0); - - // SystemTime -> DateTime - assert_eq!(DateTime::::from(UNIX_EPOCH), epoch); - assert_eq!( - DateTime::::from(UNIX_EPOCH + Duration::new(999_999_999, nanos)), - Utc.ymd(2001, 9, 9).and_hms_nano(1, 46, 39, nanos) - ); - assert_eq!( - DateTime::::from(UNIX_EPOCH - Duration::new(999_999_999, nanos)), - Utc.ymd(1938, 4, 24).and_hms_nano(22, 13, 20, 1_000) - ); - - // DateTime -> SystemTime - assert_eq!(SystemTime::from(epoch), UNIX_EPOCH); - assert_eq!( - SystemTime::from(Utc.ymd(2001, 9, 9).and_hms_nano(1, 46, 39, nanos)), - UNIX_EPOCH + Duration::new(999_999_999, nanos) - ); - assert_eq!( - SystemTime::from(Utc.ymd(1938, 4, 24).and_hms_nano(22, 13, 20, 1_000)), - UNIX_EPOCH - Duration::new(999_999_999, nanos) - ); - - // DateTime -> SystemTime (via `with_timezone`) - #[cfg(feature = "clock")] - { - assert_eq!(SystemTime::from(epoch.with_timezone(&Local)), UNIX_EPOCH); - } - assert_eq!(SystemTime::from(epoch.with_timezone(&FixedOffset::east(32400))), UNIX_EPOCH); - assert_eq!(SystemTime::from(epoch.with_timezone(&FixedOffset::west(28800))), UNIX_EPOCH); - } - - #[test] - #[cfg(feature = "clock")] - fn test_datetime_format_alignment() { - let datetime = Utc.ymd(2007, 01, 02); - - // Item::Literal - let percent = datetime.format("%%"); - assert_eq!(" %", format!("{:>3}", percent)); - assert_eq!("% ", format!("{:<3}", percent)); - assert_eq!(" % ", format!("{:^3}", percent)); - - // Item::Numeric - let year = datetime.format("%Y"); - assert_eq!(" 2007", format!("{:>6}", year)); - assert_eq!("2007 ", format!("{:<6}", year)); - assert_eq!(" 2007 ", format!("{:^6}", year)); - - // Item::Fixed - let tz = datetime.format("%Z"); - assert_eq!(" UTC", format!("{:>5}", tz)); - assert_eq!("UTC ", format!("{:<5}", tz)); - assert_eq!(" UTC ", format!("{:^5}", tz)); - - // [Item::Numeric, Item::Space, Item::Literal, Item::Space, Item::Numeric] - let ymd = datetime.format("%Y %B %d"); - let ymd_formatted = "2007 January 02"; - assert_eq!(format!(" {}", ymd_formatted), format!("{:>17}", ymd)); - assert_eq!(format!("{} ", ymd_formatted), format!("{:<17}", ymd)); - assert_eq!(format!(" {} ", ymd_formatted), format!("{:^17}", ymd)); - } - - #[test] - #[cfg(feature = "clock")] - fn test_years_elapsed() { - // This is always at least one year because 1 year = 52.1775 weeks. - let one_year_ago = - Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 1.5).ceil() as i64); - // A bit more than 2 years. - let two_year_ago = - Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 2.5).ceil() as i64); - - assert_eq!(one_year_ago.elapsed_years(), 1); - assert_eq!(two_year_ago.elapsed_years(), 2); - - // if the given DateTime is later than now, the function will always return 0. - assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); - } - - #[test] - fn test_datetime_from_local() { - // 2000-01-12T02:00:00Z - let naivedatetime_utc = NaiveDate::from_ymd(2000, 1, 12).and_hms(2, 0, 0); - let datetime_utc = DateTime::::from_utc(naivedatetime_utc, Utc); - - // 2000-01-12T10:00:00+8:00:00 - let timezone_east = FixedOffset::east(8 * 60 * 60); - let naivedatetime_east = NaiveDate::from_ymd(2000, 1, 12).and_hms(10, 0, 0); - let datetime_east = DateTime::::from_local(naivedatetime_east, timezone_east); - - // 2000-01-11T19:00:00-7:00:00 - let timezone_west = FixedOffset::west(7 * 60 * 60); - let naivedatetime_west = NaiveDate::from_ymd(2000, 1, 11).and_hms(19, 0, 0); - let datetime_west = DateTime::::from_local(naivedatetime_west, timezone_west); - - assert_eq!(datetime_east, datetime_utc.with_timezone(&timezone_east)); - assert_eq!(datetime_west, datetime_utc.with_timezone(&timezone_west)); - } -} diff --git a/src/datetime/mod.rs b/src/datetime/mod.rs index fe41b4cc0f..a2feff3d32 100644 --- a/src/datetime/mod.rs +++ b/src/datetime/mod.rs @@ -351,6 +351,21 @@ impl DateTime { pub fn naive_local(&self) -> NaiveDateTime { self.datetime + self.offset.fix() } + + /// Retrieve the elapsed years from now to the given [`DateTime`]. + #[cfg(feature = "clock")] + pub fn elapsed_years(&self) -> u32 { + let now = Utc::now().with_timezone(&self.timezone()); + + let years = + if (now.month(), now.day(), now.time()) < (self.month(), self.day(), self.time()) { + now.year() - self.year() - 1 + } else { + now.year() - self.year() + }; + + u32::try_from(years).unwrap_or(0) + } } impl Default for DateTime { diff --git a/src/datetime/tests.rs b/src/datetime/tests.rs index 8c373d3ba3..f3f42acb21 100644 --- a/src/datetime/tests.rs +++ b/src/datetime/tests.rs @@ -407,3 +407,18 @@ fn test_datetime_from_local() { assert_eq!(datetime_east, datetime_utc.with_timezone(&timezone_east)); assert_eq!(datetime_west, datetime_utc.with_timezone(&timezone_west)); } + +#[test] +#[cfg(feature = "clock")] +fn test_years_elapsed() { + // This is always at least one year because 1 year = 52.1775 weeks. + let one_year_ago = Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 1.5).ceil() as i64); + // A bit more than 2 years. + let two_year_ago = Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 2.5).ceil() as i64); + + assert_eq!(one_year_ago.elapsed_years(), 1); + assert_eq!(one_year_ago.elapsed_years(), 2); + + // If the given DateTime is later than now, the function will always return 0. + assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); +} From d893578e282642ebdcd201b28ba779ca4abf3ae0 Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Fri, 27 May 2022 14:51:19 +0200 Subject: [PATCH 26/29] Clean up --- src/date.rs | 4 ++-- src/datetime/mod.rs | 1 + src/datetime/tests.rs | 4 +++- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/date.rs b/src/date.rs index 296624b224..2f9a5ca039 100644 --- a/src/date.rs +++ b/src/date.rs @@ -516,8 +516,8 @@ where #[cfg(test)] mod tests { - use consts::f64; - use offset::Utc; + use crate::consts::f64; + use crate::offset::Utc; use oldtime::Duration; #[test] diff --git a/src/datetime/mod.rs b/src/datetime/mod.rs index a2feff3d32..0233e4d6bf 100644 --- a/src/datetime/mod.rs +++ b/src/datetime/mod.rs @@ -11,6 +11,7 @@ use alloc::string::{String, ToString}; #[cfg(any(feature = "alloc", feature = "std", test))] use core::borrow::Borrow; use core::cmp::Ordering; +use core::convert::TryFrom; use core::ops::{Add, Sub}; use core::{fmt, hash, str}; #[cfg(feature = "std")] diff --git a/src/datetime/tests.rs b/src/datetime/tests.rs index f3f42acb21..86036040d9 100644 --- a/src/datetime/tests.rs +++ b/src/datetime/tests.rs @@ -1,6 +1,8 @@ use std::time::{SystemTime, UNIX_EPOCH}; use super::DateTime; +#[cfg(feature = "clock")] +use crate::consts::f64; use crate::naive::{NaiveDate, NaiveTime}; #[cfg(feature = "clock")] use crate::offset::Local; @@ -417,7 +419,7 @@ fn test_years_elapsed() { let two_year_ago = Utc::today() - Duration::weeks((f64::WEEKS_PER_YEAR * 2.5).ceil() as i64); assert_eq!(one_year_ago.elapsed_years(), 1); - assert_eq!(one_year_ago.elapsed_years(), 2); + assert_eq!(two_year_ago.elapsed_years(), 2); // If the given DateTime is later than now, the function will always return 0. assert_eq!((Utc::today() + Duration::weeks(12)).elapsed_years(), 0); From 83aab1a6d90f72557f09cac8a9c530ae58adba35 Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Sat, 28 May 2022 15:53:35 +0200 Subject: [PATCH 27/29] After review --- src/date.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/date.rs b/src/date.rs index 2f9a5ca039..6bf8c22978 100644 --- a/src/date.rs +++ b/src/date.rs @@ -277,7 +277,7 @@ impl Date { self.date } - /// Retrieve the elapsed years from now to the given [`Date`]. + /// Retrieves the elapsed years from now to the given [`Date`]. #[cfg(feature = "clock")] pub fn elapsed_years(&self) -> u32 { let now = Utc::today().with_timezone(&self.timezone()); From 07f1e43bd12a2921a9f5cbfd51f1ceb8c9be6953 Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Sat, 28 May 2022 15:58:28 +0200 Subject: [PATCH 28/29] Add `crate::` to the use statement --- src/date.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/date.rs b/src/date.rs index 6bf8c22978..a1b3c230d8 100644 --- a/src/date.rs +++ b/src/date.rs @@ -518,7 +518,7 @@ where mod tests { use crate::consts::f64; use crate::offset::Utc; - use oldtime::Duration; + use crate::oldtime::Duration; #[test] #[cfg(feature = "clock")] From 22945a2c093a8a0d7f57874d1e97cc7b815ce7f0 Mon Sep 17 00:00:00 2001 From: yozhgoor Date: Wed, 8 Jun 2022 11:21:20 +0200 Subject: [PATCH 29/29] Replace `TryFrom` --- src/date.rs | 7 +++++-- src/datetime/mod.rs | 8 +++++--- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/src/date.rs b/src/date.rs index a1b3c230d8..d6d76d8997 100644 --- a/src/date.rs +++ b/src/date.rs @@ -6,7 +6,6 @@ #[cfg(any(feature = "alloc", feature = "std", test))] use core::borrow::Borrow; use core::cmp::Ordering; -use core::convert::TryFrom; use core::ops::{Add, Sub}; use core::{fmt, hash}; @@ -288,7 +287,11 @@ impl Date { now.year() - self.year() }; - u32::try_from(years).unwrap_or(0) + if years.is_positive() { + years as u32 + } else { + 0 + } } } diff --git a/src/datetime/mod.rs b/src/datetime/mod.rs index 0233e4d6bf..3ee98db13a 100644 --- a/src/datetime/mod.rs +++ b/src/datetime/mod.rs @@ -11,7 +11,6 @@ use alloc::string::{String, ToString}; #[cfg(any(feature = "alloc", feature = "std", test))] use core::borrow::Borrow; use core::cmp::Ordering; -use core::convert::TryFrom; use core::ops::{Add, Sub}; use core::{fmt, hash, str}; #[cfg(feature = "std")] @@ -364,8 +363,11 @@ impl DateTime { } else { now.year() - self.year() }; - - u32::try_from(years).unwrap_or(0) + if years.is_positive() { + years as u32 + } else { + 0 + } } }