| // This is a part of Chrono. |
| // See README.md and LICENSE.txt for details. |
| |
| //! The local (system) time zone. |
| |
| use oldtime; |
| |
| use {Datelike, Timelike}; |
| use naive::{NaiveDate, NaiveTime, NaiveDateTime}; |
| use {Date, DateTime}; |
| use super::{TimeZone, LocalResult}; |
| use super::fixed::FixedOffset; |
| |
| /// Converts a `time::Tm` struct into the timezone-aware `DateTime`. |
| /// This assumes that `time` is working correctly, i.e. any error is fatal. |
| fn tm_to_datetime(mut tm: oldtime::Tm) -> DateTime<Local> { |
| if tm.tm_sec >= 60 { |
| tm.tm_nsec += (tm.tm_sec - 59) * 1_000_000_000; |
| tm.tm_sec = 59; |
| } |
| |
| #[cfg(not(windows))] |
| fn tm_to_naive_date(tm: &oldtime::Tm) -> NaiveDate { |
| // from_yo is more efficient than from_ymd (since it's the internal representation). |
| NaiveDate::from_yo(tm.tm_year + 1900, tm.tm_yday as u32 + 1) |
| } |
| |
| #[cfg(windows)] |
| fn tm_to_naive_date(tm: &oldtime::Tm) -> NaiveDate { |
| // ...but tm_yday is broken in Windows (issue #85) |
| NaiveDate::from_ymd(tm.tm_year + 1900, tm.tm_mon as u32 + 1, tm.tm_mday as u32) |
| } |
| |
| let date = tm_to_naive_date(&tm); |
| let time = NaiveTime::from_hms_nano(tm.tm_hour as u32, tm.tm_min as u32, |
| tm.tm_sec as u32, tm.tm_nsec as u32); |
| let offset = FixedOffset::east(tm.tm_utcoff); |
| DateTime::from_utc(date.and_time(time) - offset, offset) |
| } |
| |
| /// Converts a local `NaiveDateTime` to the `time::Timespec`. |
| fn datetime_to_timespec(d: &NaiveDateTime, local: bool) -> oldtime::Timespec { |
| // well, this exploits an undocumented `Tm::to_timespec` behavior |
| // to get the exact function we want (either `timegm` or `mktime`). |
| // the number 1 is arbitrary but should be non-zero to trigger `mktime`. |
| let tm_utcoff = if local {1} else {0}; |
| |
| let tm = oldtime::Tm { |
| tm_sec: d.second() as i32, |
| tm_min: d.minute() as i32, |
| tm_hour: d.hour() as i32, |
| tm_mday: d.day() as i32, |
| tm_mon: d.month0() as i32, // yes, C is that strange... |
| tm_year: d.year() - 1900, // this doesn't underflow, we know that d is `NaiveDateTime`. |
| tm_wday: 0, // to_local ignores this |
| tm_yday: 0, // and this |
| tm_isdst: -1, |
| tm_utcoff: tm_utcoff, |
| // do not set this, OS APIs are heavily inconsistent in terms of leap second handling |
| tm_nsec: 0, |
| }; |
| |
| tm.to_timespec() |
| } |
| |
| /// The local timescale. This is implemented via the standard `time` crate. |
| /// |
| /// Using the [`TimeZone`](./trait.TimeZone.html) methods |
| /// on the Local struct is the preferred way to construct `DateTime<Local>` |
| /// instances. |
| /// |
| /// # Example |
| /// |
| /// ~~~~ |
| /// use chrono::{Local, DateTime, TimeZone}; |
| /// |
| /// let dt: DateTime<Local> = Local::now(); |
| /// let dt: DateTime<Local> = Local.timestamp(0, 0); |
| /// ~~~~ |
| #[derive(Copy, Clone, Debug)] |
| pub struct Local; |
| |
| impl Local { |
| /// Returns a `Date` which corresponds to the current date. |
| pub fn today() -> Date<Local> { |
| Local::now().date() |
| } |
| |
| /// Returns a `DateTime` which corresponds to the current date. |
| pub fn now() -> DateTime<Local> { |
| tm_to_datetime(oldtime::now()) |
| } |
| } |
| |
| impl TimeZone for Local { |
| type Offset = FixedOffset; |
| |
| fn from_offset(_offset: &FixedOffset) -> Local { Local } |
| |
| // they are easier to define in terms of the finished date and time unlike other offsets |
| fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<FixedOffset> { |
| self.from_local_date(local).map(|date| *date.offset()) |
| } |
| |
| fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult<FixedOffset> { |
| self.from_local_datetime(local).map(|datetime| *datetime.offset()) |
| } |
| |
| fn offset_from_utc_date(&self, utc: &NaiveDate) -> FixedOffset { |
| *self.from_utc_date(utc).offset() |
| } |
| |
| fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> FixedOffset { |
| *self.from_utc_datetime(utc).offset() |
| } |
| |
| // override them for avoiding redundant works |
| fn from_local_date(&self, local: &NaiveDate) -> LocalResult<Date<Local>> { |
| // this sounds very strange, but required for keeping `TimeZone::ymd` sane. |
| // in the other words, we use the offset at the local midnight |
| // but keep the actual date unaltered (much like `FixedOffset`). |
| let midnight = self.from_local_datetime(&local.and_hms(0, 0, 0)); |
| midnight.map(|datetime| Date::from_utc(*local, *datetime.offset())) |
| } |
| |
| fn from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult<DateTime<Local>> { |
| let timespec = datetime_to_timespec(local, true); |
| |
| // datetime_to_timespec completely ignores leap seconds, so we need to adjust for them |
| let mut tm = oldtime::at(timespec); |
| assert_eq!(tm.tm_nsec, 0); |
| tm.tm_nsec = local.nanosecond() as i32; |
| |
| LocalResult::Single(tm_to_datetime(tm)) |
| } |
| |
| fn from_utc_date(&self, utc: &NaiveDate) -> Date<Local> { |
| let midnight = self.from_utc_datetime(&utc.and_hms(0, 0, 0)); |
| Date::from_utc(*utc, *midnight.offset()) |
| } |
| |
| fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Local> { |
| let timespec = datetime_to_timespec(utc, false); |
| |
| // datetime_to_timespec completely ignores leap seconds, so we need to adjust for them |
| let mut tm = oldtime::at(timespec); |
| assert_eq!(tm.tm_nsec, 0); |
| tm.tm_nsec = utc.nanosecond() as i32; |
| |
| tm_to_datetime(tm) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use Datelike; |
| use offset::TimeZone; |
| use super::Local; |
| |
| #[test] |
| fn test_local_date_sanity_check() { // issue #27 |
| assert_eq!(Local.ymd(2999, 12, 28).day(), 28); |
| } |
| |
| #[test] |
| fn test_leap_second() { // issue #123 |
| let today = Local::today(); |
| |
| let dt = today.and_hms_milli(1, 2, 59, 1000); |
| let timestr = dt.time().to_string(); |
| // the OS API may or may not support the leap second, |
| // but there are only two sensible options. |
| assert!(timestr == "01:02:60" || timestr == "01:03:00", |
| "unexpected timestr {:?}", timestr); |
| |
| let dt = today.and_hms_milli(1, 2, 3, 1234); |
| let timestr = dt.time().to_string(); |
| assert!(timestr == "01:02:03.234" || timestr == "01:02:04.234", |
| "unexpected timestr {:?}", timestr); |
| } |
| } |
| |