From 586b41df54eae40d7902ad0cd21d0dd63975f472 Mon Sep 17 00:00:00 2001 From: Kang Seonghoon Date: Tue, 29 Jul 2014 15:55:40 +0900 Subject: [PATCH] mass renaming from `BlahBlahZ` to `NaiveBlahBlah`. --- README.md | 24 +-- src/date.rs | 465 +++++++++++++++++++++++++----------------------- src/datetime.rs | 173 ++++++------------ src/lib.rs | 28 +-- src/offset.rs | 68 +++---- src/time.rs | 195 ++++++++++---------- 6 files changed, 453 insertions(+), 500 deletions(-) diff --git a/README.md b/README.md index a4cc400..eafb77a 100644 --- a/README.md +++ b/README.md @@ -10,25 +10,25 @@ Date and time handling for Rust. ```rust // find out if the doomsday rule is correct! -use chrono::{Weekday, DateZ, date}; +use chrono::{Weekday, NaiveDate, date}; use std::iter::range_inclusive; -for y in range_inclusive(date::MINZ.year(), date::MAXZ.year()) { +for y in range_inclusive(date::MIN_NAIVE.year(), date::MAX_NAIVE.year()) { // even months - let d4 = DateZ::from_ymd(y, 4, 4); - let d6 = DateZ::from_ymd(y, 6, 6); - let d8 = DateZ::from_ymd(y, 8, 8); - let d10 = DateZ::from_ymd(y, 10, 10); - let d12 = DateZ::from_ymd(y, 12, 12); + let d4 = NaiveDate::from_ymd(y, 4, 4); + let d6 = NaiveDate::from_ymd(y, 6, 6); + let d8 = NaiveDate::from_ymd(y, 8, 8); + let d10 = NaiveDate::from_ymd(y, 10, 10); + let d12 = NaiveDate::from_ymd(y, 12, 12); // nine to five, seven-eleven - let d59 = DateZ::from_ymd(y, 5, 9); - let d95 = DateZ::from_ymd(y, 9, 5); - let d711 = DateZ::from_ymd(y, 7, 11); - let d117 = DateZ::from_ymd(y, 11, 7); + let d59 = NaiveDate::from_ymd(y, 5, 9); + let d95 = NaiveDate::from_ymd(y, 9, 5); + let d711 = NaiveDate::from_ymd(y, 7, 11); + let d117 = NaiveDate::from_ymd(y, 11, 7); // "March 0" - let d30 = DateZ::from_ymd(y, 3, 1).pred(); + let d30 = NaiveDate::from_ymd(y, 3, 1).pred(); let weekday = d30.weekday(); let other_dates = [d4, d6, d8, d10, d12, d59, d95, d711, d117]; diff --git a/src/date.rs b/src/date.rs index e5cd2b7..04c2d54 100644 --- a/src/date.rs +++ b/src/date.rs @@ -10,8 +10,8 @@ use std::{fmt, num, hash}; use num::Integer; use duration::Duration; use offset::{Offset, UTC}; -use time::TimeZ; -use datetime::{DateTimeZ, DateTime}; +use time::NaiveTime; +use datetime::{NaiveDateTime, DateTime}; use self::internals::{DateImpl, Of, Mdf, YearFlags}; @@ -223,91 +223,91 @@ pub trait Datelike { /// Allows for every proleptic Gregorian date from Jan 1, 262145 BCE to Dec 31, 262143 CE. /// Also supports the conversion from ISO 8601 ordinal and week date. #[deriving(PartialEq, Eq, PartialOrd, Ord, Clone, Hash)] -pub struct DateZ { +pub struct NaiveDate { ymdf: DateImpl, // (year << 13) | of } -/// The minimum possible `DateZ`. -pub static MINZ: DateZ = DateZ { ymdf: (MIN_YEAR << 13) | (1 << 4) | 0o07 /*FE*/ }; -/// The maximum possible `DateZ`. -pub static MAXZ: DateZ = DateZ { ymdf: (MAX_YEAR << 13) | (365 << 4) | 0o17 /*F*/ }; +/// The minimum possible `NaiveDate`. +pub static MIN_NAIVE: NaiveDate = NaiveDate { ymdf: (MIN_YEAR << 13) | (1 << 4) | 0o07 /*FE*/ }; +/// The maximum possible `NaiveDate`. +pub static MAX_NAIVE: NaiveDate = NaiveDate { ymdf: (MAX_YEAR << 13) | (365 << 4) | 0o17 /*F*/ }; // as it is hard to verify year flags in `MIN` and `MAX`, we use a separate run-time test. #[test] fn test_datez_bounds() { - let calculated_min = DateZ::from_ymd(MIN_YEAR, 1, 1); - let calculated_max = DateZ::from_ymd(MAX_YEAR, 12, 31); - assert!(MINZ == calculated_min, - "`MINZ` should have a year flag {}", calculated_min.of().flags()); - assert!(MAXZ == calculated_max, - "`MAXZ` should have a year flag {}", calculated_max.of().flags()); + let calculated_min = NaiveDate::from_ymd(MIN_YEAR, 1, 1); + let calculated_max = NaiveDate::from_ymd(MAX_YEAR, 12, 31); + assert!(MIN_NAIVE == calculated_min, + "`MIN_NAIVE` should have a year flag {}", calculated_min.of().flags()); + assert!(MAX_NAIVE == calculated_max, + "`MAX_NAIVE` should have a year flag {}", calculated_max.of().flags()); } -impl DateZ { - /// Makes a new `DateZ` from year and packed ordinal-flags, with a verification. - fn from_of(year: i32, of: Of) -> Option { +impl NaiveDate { + /// Makes a new `NaiveDate` from year and packed ordinal-flags, with a verification. + fn from_of(year: i32, of: Of) -> Option { if year >= MIN_YEAR && year <= MAX_YEAR && of.valid() { let Of(of) = of; - Some(DateZ { ymdf: ((year << 13) as DateImpl) | (of as DateImpl) }) + Some(NaiveDate { ymdf: ((year << 13) as DateImpl) | (of as DateImpl) }) } else { None } } - /// Makes a new `DateZ` from year and packed month-day-flags, with a verification. - fn from_mdf(year: i32, mdf: Mdf) -> Option { - DateZ::from_of(year, mdf.to_of()) + /// Makes a new `NaiveDate` from year and packed month-day-flags, with a verification. + fn from_mdf(year: i32, mdf: Mdf) -> Option { + NaiveDate::from_of(year, mdf.to_of()) } - /// Makes a new `DateZ` from year, month and day. + /// Makes a new `NaiveDate` from year, month and day. /// This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. /// /// Fails on the out-of-range date, invalid month and/or day. - pub fn from_ymd(year: i32, month: u32, day: u32) -> DateZ { - DateZ::from_ymd_opt(year, month, day).expect("invalid or out-of-range date") + pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate { + NaiveDate::from_ymd_opt(year, month, day).expect("invalid or out-of-range date") } - /// Makes a new `DateZ` from year, month and day. + /// Makes a new `NaiveDate` from year, month and day. /// This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. /// /// Returns `None` on the out-of-range date, invalid month and/or day. - pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option { + pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option { let flags = YearFlags::from_year(year); - DateZ::from_mdf(year, Mdf::new(month, day, flags)) + NaiveDate::from_mdf(year, Mdf::new(month, day, flags)) } - /// Makes a new `DateZ` from year and day of year (DOY or "ordinal"). + /// Makes a new `NaiveDate` from year and day of year (DOY or "ordinal"). /// This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. /// /// Fails on the out-of-range date and/or invalid DOY. - pub fn from_yo(year: i32, ordinal: u32) -> DateZ { - DateZ::from_yo_opt(year, ordinal).expect("invalid or out-of-range date") + pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate { + NaiveDate::from_yo_opt(year, ordinal).expect("invalid or out-of-range date") } - /// Makes a new `DateZ` from year and day of year (DOY or "ordinal"). + /// Makes a new `NaiveDate` from year and day of year (DOY or "ordinal"). /// This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. /// /// Returns `None` on the out-of-range date and/or invalid DOY. - pub fn from_yo_opt(year: i32, ordinal: u32) -> Option { + pub fn from_yo_opt(year: i32, ordinal: u32) -> Option { let flags = YearFlags::from_year(year); - DateZ::from_of(year, Of::new(ordinal, flags)) + NaiveDate::from_of(year, Of::new(ordinal, flags)) } - /// Makes a new `DateZ` from ISO week date (year and week number) and day of the week (DOW). + /// Makes a new `NaiveDate` from ISO week date (year and week number) and day of the week (DOW). /// This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. - /// The resulting `DateZ` may have a different year from the input year. + /// The resulting `NaiveDate` may have a different year from the input year. /// /// Fails on the out-of-range date and/or invalid week number. - pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> DateZ { - DateZ::from_isoywd_opt(year, week, weekday).expect("invalid or out-of-range date") + pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate { + NaiveDate::from_isoywd_opt(year, week, weekday).expect("invalid or out-of-range date") } - /// Makes a new `DateZ` from ISO week date (year and week number) and day of the week (DOW). + /// Makes a new `NaiveDate` from ISO week date (year and week number) and day of the week (DOW). /// This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. - /// The resulting `DateZ` may have a different year from the input year. + /// The resulting `NaiveDate` may have a different year from the input year. /// /// Returns `None` on the out-of-range date and/or invalid week number. - pub fn from_isoywd_opt(year: i32, week: u32, weekday: Weekday) -> Option { + pub fn from_isoywd_opt(year: i32, week: u32, weekday: Weekday) -> Option { let flags = YearFlags::from_year(year); let nweeks = flags.nisoweeks(); if 1 <= week && week <= nweeks { @@ -316,15 +316,16 @@ impl DateZ { let delta = flags.isoweek_delta(); if weekord <= delta { // ordinal < 1, previous year let prevflags = YearFlags::from_year(year - 1); - DateZ::from_of(year - 1, Of::new(weekord + prevflags.ndays() - delta, prevflags)) + NaiveDate::from_of(year - 1, Of::new(weekord + prevflags.ndays() - delta, + prevflags)) } else { let ordinal = weekord - delta; let ndays = flags.ndays(); if ordinal <= ndays { // this year - DateZ::from_of(year, Of::new(ordinal, flags)) + NaiveDate::from_of(year, Of::new(ordinal, flags)) } else { // ordinal > ndays, next year let nextflags = YearFlags::from_year(year + 1); - DateZ::from_of(year + 1, Of::new(ordinal - ndays, nextflags)) + NaiveDate::from_of(year + 1, Of::new(ordinal - ndays, nextflags)) } } } else { @@ -332,82 +333,83 @@ impl DateZ { } } - /// Makes a new `DateTimeZ` from the current date and given `TimeZ`. + /// Makes a new `NaiveDateTime` from the current date and given `NaiveTime`. #[inline] - pub fn and_time(&self, time: TimeZ) -> DateTimeZ { - DateTimeZ::new(self.clone(), time) + pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime { + NaiveDateTime::new(self.clone(), time) } - /// Makes a new `DateTimeZ` from the current date, hour, minute and second. + /// Makes a new `NaiveDateTime` from the current date, hour, minute and second. /// /// Fails on invalid hour, minute and/or second. #[inline] - pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> DateTimeZ { + pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime { self.and_hms_opt(hour, min, sec).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute and second. + /// Makes a new `NaiveDateTime` from the current date, hour, minute and second. /// /// Returns `None` on invalid hour, minute and/or second. #[inline] - pub fn and_hms_opt(&self, hour: u32, min: u32, sec: u32) -> Option { - TimeZ::from_hms_opt(hour, min, sec).map(|time| self.and_time(time)) + pub fn and_hms_opt(&self, hour: u32, min: u32, sec: u32) -> Option { + NaiveTime::from_hms_opt(hour, min, sec).map(|time| self.and_time(time)) } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and millisecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and millisecond. /// The millisecond part can exceed 1,000 in order to represent the leap second. /// /// Fails on invalid hour, minute, second and/or millisecond. #[inline] - pub fn and_hms_milli(&self, hour: u32, min: u32, sec: u32, milli: u32) -> DateTimeZ { + pub fn and_hms_milli(&self, hour: u32, min: u32, sec: u32, milli: u32) -> NaiveDateTime { self.and_hms_milli_opt(hour, min, sec, milli).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and millisecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and millisecond. /// The millisecond part can exceed 1,000 in order to represent the leap second. /// /// Returns `None` on invalid hour, minute, second and/or millisecond. #[inline] pub fn and_hms_milli_opt(&self, hour: u32, min: u32, sec: u32, - milli: u32) -> Option { - TimeZ::from_hms_milli_opt(hour, min, sec, milli).map(|time| self.and_time(time)) + milli: u32) -> Option { + NaiveTime::from_hms_milli_opt(hour, min, sec, milli).map(|time| self.and_time(time)) } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and microsecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and microsecond. /// The microsecond part can exceed 1,000,000 in order to represent the leap second. /// /// Fails on invalid hour, minute, second and/or microsecond. #[inline] - pub fn and_hms_micro(&self, hour: u32, min: u32, sec: u32, micro: u32) -> DateTimeZ { + pub fn and_hms_micro(&self, hour: u32, min: u32, sec: u32, micro: u32) -> NaiveDateTime { self.and_hms_micro_opt(hour, min, sec, micro).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and microsecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and microsecond. /// The microsecond part can exceed 1,000,000 in order to represent the leap second. /// /// Returns `None` on invalid hour, minute, second and/or microsecond. #[inline] pub fn and_hms_micro_opt(&self, hour: u32, min: u32, sec: u32, - micro: u32) -> Option { - TimeZ::from_hms_micro_opt(hour, min, sec, micro).map(|time| self.and_time(time)) + micro: u32) -> Option { + NaiveTime::from_hms_micro_opt(hour, min, sec, micro).map(|time| self.and_time(time)) } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and nanosecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and nanosecond. /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second. /// /// Fails on invalid hour, minute, second and/or nanosecond. #[inline] - pub fn and_hms_nano(&self, hour: u32, min: u32, sec: u32, nano: u32) -> DateTimeZ { + pub fn and_hms_nano(&self, hour: u32, min: u32, sec: u32, nano: u32) -> NaiveDateTime { self.and_hms_nano_opt(hour, min, sec, nano).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and nanosecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and nanosecond. /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second. /// /// Returns `None` on invalid hour, minute, second and/or nanosecond. #[inline] - pub fn and_hms_nano_opt(&self, hour: u32, min: u32, sec: u32, nano: u32) -> Option { - TimeZ::from_hms_nano_opt(hour, min, sec, nano).map(|time| self.and_time(time)) + pub fn and_hms_nano_opt(&self, hour: u32, min: u32, sec: u32, + nano: u32) -> Option { + NaiveTime::from_hms_nano_opt(hour, min, sec, nano).map(|time| self.and_time(time)) } /// Returns the packed month-day-flags. @@ -422,61 +424,61 @@ impl DateZ { Of((self.ymdf & 0b1111_11111_1111) as u32) } - /// Makes a new `DateZ` with the packed month-day-flags changed. + /// Makes a new `NaiveDate` with the packed month-day-flags changed. /// - /// Returns `None` when the resulting `DateZ` would be invalid. + /// Returns `None` when the resulting `NaiveDate` would be invalid. #[inline] - fn with_mdf(&self, mdf: Mdf) -> Option { + fn with_mdf(&self, mdf: Mdf) -> Option { self.with_of(mdf.to_of()) } - /// Makes a new `DateZ` with the packed ordinal-flags changed. + /// Makes a new `NaiveDate` with the packed ordinal-flags changed. /// - /// Returns `None` when the resulting `DateZ` would be invalid. + /// Returns `None` when the resulting `NaiveDate` would be invalid. #[inline] - fn with_of(&self, of: Of) -> Option { + fn with_of(&self, of: Of) -> Option { if of.valid() { let Of(of) = of; - Some(DateZ { ymdf: (self.ymdf & !0b111111111_1111) | of as DateImpl }) + Some(NaiveDate { ymdf: (self.ymdf & !0b111111111_1111) | of as DateImpl }) } else { None } } - /// Makes a new `DateZ` for the next date. + /// Makes a new `NaiveDate` for the next date. /// /// Fails when `self` is the last representable date. #[inline] - pub fn succ(&self) -> DateZ { + pub fn succ(&self) -> NaiveDate { self.succ_opt().expect("out of bound") } - /// Makes a new `DateZ` for the next date. + /// Makes a new `NaiveDate` for the next date. /// /// Returns `None` when `self` is the last representable date. #[inline] - pub fn succ_opt(&self) -> Option { - self.with_of(self.of().succ()).or_else(|| DateZ::from_ymd_opt(self.year() + 1, 1, 1)) + pub fn succ_opt(&self) -> Option { + self.with_of(self.of().succ()).or_else(|| NaiveDate::from_ymd_opt(self.year() + 1, 1, 1)) } - /// Makes a new `DateZ` for the prior date. + /// Makes a new `NaiveDate` for the prior date. /// /// Fails when `self` is the first representable date. #[inline] - pub fn pred(&self) -> DateZ { + pub fn pred(&self) -> NaiveDate { self.pred_opt().expect("out of bound") } - /// Makes a new `DateZ` for the prior date. + /// Makes a new `NaiveDate` for the prior date. /// /// Returns `None` when `self` is the first representable date. #[inline] - pub fn pred_opt(&self) -> Option { - self.with_of(self.of().pred()).or_else(|| DateZ::from_ymd_opt(self.year() - 1, 12, 31)) + pub fn pred_opt(&self) -> Option { + self.with_of(self.of().pred()).or_else(|| NaiveDate::from_ymd_opt(self.year() - 1, 12, 31)) } } -impl Datelike for DateZ { +impl Datelike for NaiveDate { #[inline] fn year(&self) -> i32 { (self.ymdf >> 13) as i32 } #[inline] fn month(&self) -> u32 { self.mdf().month() } #[inline] fn month0(&self) -> u32 { self.mdf().month() - 1 } @@ -504,7 +506,7 @@ impl Datelike for DateZ { } #[inline] - fn with_year(&self, year: i32) -> Option { + fn with_year(&self, year: i32) -> Option { // we need to operate with `mdf` since we should keep the month and day number as is let mdf = self.mdf(); @@ -512,47 +514,47 @@ impl Datelike for DateZ { let flags = YearFlags::from_year(year); let mdf = mdf.with_flags(flags); - DateZ::from_mdf(year, mdf) + NaiveDate::from_mdf(year, mdf) } #[inline] - fn with_month(&self, month: u32) -> Option { + fn with_month(&self, month: u32) -> Option { self.with_mdf(self.mdf().with_month(month)) } #[inline] - fn with_month0(&self, month0: u32) -> Option { + fn with_month0(&self, month0: u32) -> Option { self.with_mdf(self.mdf().with_month(month0 + 1)) } #[inline] - fn with_day(&self, day: u32) -> Option { + fn with_day(&self, day: u32) -> Option { self.with_mdf(self.mdf().with_day(day)) } #[inline] - fn with_day0(&self, day0: u32) -> Option { + fn with_day0(&self, day0: u32) -> Option { self.with_mdf(self.mdf().with_day(day0 + 1)) } #[inline] - fn with_ordinal(&self, ordinal: u32) -> Option { + fn with_ordinal(&self, ordinal: u32) -> Option { self.with_of(self.of().with_ordinal(ordinal)) } #[inline] - fn with_ordinal0(&self, ordinal0: u32) -> Option { + fn with_ordinal0(&self, ordinal0: u32) -> Option { self.with_of(self.of().with_ordinal(ordinal0 + 1)) } } -impl num::Bounded for DateZ { - #[inline] fn min_value() -> DateZ { MINZ } - #[inline] fn max_value() -> DateZ { MAXZ } +impl num::Bounded for NaiveDate { + #[inline] fn min_value() -> NaiveDate { MIN_NAIVE } + #[inline] fn max_value() -> NaiveDate { MAX_NAIVE } } -impl Add for DateZ { - fn add(&self, rhs: &Duration) -> DateZ { +impl Add for NaiveDate { + fn add(&self, rhs: &Duration) -> NaiveDate { // TODO overflow let year = self.year(); @@ -564,20 +566,21 @@ impl Add for DateZ { let (year_mod_400, ordinal) = internals::cycle_to_yo(cycle as u32); let flags = unsafe { YearFlags::from_year_mod_400(year_mod_400 as i32) }; - DateZ::from_of(year_div_400 * 400 + year_mod_400 as i32, Of::new(ordinal, flags)).unwrap() + NaiveDate::from_of(year_div_400 * 400 + year_mod_400 as i32, + Of::new(ordinal, flags)).unwrap() } } /* // Rust issue #7590, the current coherence checker can't handle multiple Add impls -impl Add for Duration { +impl Add for Duration { #[inline] - fn add(&self, rhs: &DateZ) -> DateZ { rhs.add(self) } + fn add(&self, rhs: &NaiveDate) -> NaiveDate { rhs.add(self) } } */ -impl Sub for DateZ { - fn sub(&self, rhs: &DateZ) -> Duration { +impl Sub for NaiveDate { + fn sub(&self, rhs: &NaiveDate) -> Duration { let year1 = self.year(); let year2 = rhs.year(); let (year1_div_400, year1_mod_400) = year1.div_mod_floor(&400); @@ -588,7 +591,7 @@ impl Sub for DateZ { } } -impl fmt::Show for DateZ { +impl fmt::Show for NaiveDate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let year = self.year(); let mdf = self.mdf(); @@ -604,33 +607,33 @@ impl fmt::Show for DateZ { /// ISO 8601 calendar date with timezone. #[deriving(Clone)] pub struct Date { - date: DateZ, + date: NaiveDate, offset: Off, } /// The minimum possible `Date`. -pub static MIN: Date = Date { date: MINZ, offset: UTC }; +pub static MIN: Date = Date { date: MIN_NAIVE, offset: UTC }; /// The maximum possible `Date`. -pub static MAX: Date = Date { date: MAXZ, offset: UTC }; +pub static MAX: Date = Date { date: MAX_NAIVE, offset: UTC }; impl Date { /// Makes a new `Date` with given *UTC* date and offset. /// The local date should be constructed via the `Offset` trait. #[inline] - pub fn from_utc(date: DateZ, offset: Off) -> Date { + pub fn from_utc(date: NaiveDate, offset: Off) -> Date { Date { date: date, offset: offset } } - /// Makes a new `DateTimeZ` from the current date and given `TimeZ`. + /// Makes a new `NaiveDateTime` from the current date and given `NaiveTime`. /// The offset in the current date is preserved. /// /// Fails on invalid datetime. #[inline] - pub fn and_time(&self, time: TimeZ) -> Option> { + pub fn and_time(&self, time: NaiveTime) -> Option> { self.offset.from_local_datetime(&self.date.and_time(time)).single() } - /// Makes a new `DateTimeZ` from the current date, hour, minute and second. + /// Makes a new `NaiveDateTime` from the current date, hour, minute and second. /// The offset in the current date is preserved. /// /// Fails on invalid hour, minute and/or second. @@ -639,16 +642,16 @@ impl Date { self.and_hms_opt(hour, min, sec).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute and second. + /// Makes a new `NaiveDateTime` from the current date, hour, minute and second. /// The offset in the current date is preserved. /// /// Returns `None` on invalid hour, minute and/or second. #[inline] pub fn and_hms_opt(&self, hour: u32, min: u32, sec: u32) -> Option> { - TimeZ::from_hms_opt(hour, min, sec).and_then(|time| self.and_time(time)) + NaiveTime::from_hms_opt(hour, min, sec).and_then(|time| self.and_time(time)) } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and millisecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and millisecond. /// The millisecond part can exceed 1,000 in order to represent the leap second. /// The offset in the current date is preserved. /// @@ -658,7 +661,7 @@ impl Date { self.and_hms_milli_opt(hour, min, sec, milli).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and millisecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and millisecond. /// The millisecond part can exceed 1,000 in order to represent the leap second. /// The offset in the current date is preserved. /// @@ -666,10 +669,10 @@ impl Date { #[inline] pub fn and_hms_milli_opt(&self, hour: u32, min: u32, sec: u32, milli: u32) -> Option> { - TimeZ::from_hms_milli_opt(hour, min, sec, milli).and_then(|time| self.and_time(time)) + NaiveTime::from_hms_milli_opt(hour, min, sec, milli).and_then(|time| self.and_time(time)) } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and microsecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and microsecond. /// The microsecond part can exceed 1,000,000 in order to represent the leap second. /// The offset in the current date is preserved. /// @@ -679,7 +682,7 @@ impl Date { self.and_hms_micro_opt(hour, min, sec, micro).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and microsecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and microsecond. /// The microsecond part can exceed 1,000,000 in order to represent the leap second. /// The offset in the current date is preserved. /// @@ -687,10 +690,10 @@ impl Date { #[inline] pub fn and_hms_micro_opt(&self, hour: u32, min: u32, sec: u32, micro: u32) -> Option> { - TimeZ::from_hms_micro_opt(hour, min, sec, micro).and_then(|time| self.and_time(time)) + NaiveTime::from_hms_micro_opt(hour, min, sec, micro).and_then(|time| self.and_time(time)) } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and nanosecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and nanosecond. /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second. /// The offset in the current date is preserved. /// @@ -700,7 +703,7 @@ impl Date { self.and_hms_nano_opt(hour, min, sec, nano).expect("invalid time") } - /// Makes a new `DateTimeZ` from the current date, hour, minute, second and nanosecond. + /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and nanosecond. /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second. /// The offset in the current date is preserved. /// @@ -708,7 +711,7 @@ impl Date { #[inline] pub fn and_hms_nano_opt(&self, hour: u32, min: u32, sec: u32, nano: u32) -> Option> { - TimeZ::from_hms_nano_opt(hour, min, sec, nano).and_then(|time| self.and_time(time)) + NaiveTime::from_hms_nano_opt(hour, min, sec, nano).and_then(|time| self.and_time(time)) } /// Makes a new `Date` for the next date. @@ -744,7 +747,7 @@ impl Date { } /// Returns a view to the local date. - fn local(&self) -> DateZ { + fn local(&self) -> NaiveDate { self.offset.to_local_date(&self.date) } } @@ -861,7 +864,7 @@ impl fmt::Show for Date { #[cfg(test)] mod tests { - use super::{Datelike, DateZ, MIN_YEAR, MAX_YEAR}; + use super::{Datelike, NaiveDate, MIN_YEAR, MAX_YEAR}; use super::{Sun, Mon, Tue, Wed, Thu, Fri, Sat}; use duration::Duration; use std::{i32, u32}; @@ -869,69 +872,77 @@ mod tests { #[test] fn test_date_from_ymd() { - assert!(DateZ::from_ymd_opt(2012, 0, 1).is_none()); - assert!(DateZ::from_ymd_opt(2012, 1, 1).is_some()); - assert!(DateZ::from_ymd_opt(2012, 2, 29).is_some()); - assert!(DateZ::from_ymd_opt(2014, 2, 29).is_none()); - assert!(DateZ::from_ymd_opt(2014, 3, 0).is_none()); - assert!(DateZ::from_ymd_opt(2014, 3, 1).is_some()); - assert!(DateZ::from_ymd_opt(2014, 3, 31).is_some()); - assert!(DateZ::from_ymd_opt(2014, 3, 32).is_none()); - assert!(DateZ::from_ymd_opt(2014, 12, 31).is_some()); - assert!(DateZ::from_ymd_opt(2014, 13, 1).is_none()); + let ymd_opt = |y,m,d| NaiveDate::from_ymd_opt(y, m, d); + + assert!(ymd_opt(2012, 0, 1).is_none()); + assert!(ymd_opt(2012, 1, 1).is_some()); + assert!(ymd_opt(2012, 2, 29).is_some()); + assert!(ymd_opt(2014, 2, 29).is_none()); + assert!(ymd_opt(2014, 3, 0).is_none()); + assert!(ymd_opt(2014, 3, 1).is_some()); + assert!(ymd_opt(2014, 3, 31).is_some()); + assert!(ymd_opt(2014, 3, 32).is_none()); + assert!(ymd_opt(2014, 12, 31).is_some()); + assert!(ymd_opt(2014, 13, 1).is_none()); } #[test] fn test_date_from_yo() { - assert_eq!(DateZ::from_yo_opt(2012, 0), None); - assert_eq!(DateZ::from_yo_opt(2012, 1), Some(DateZ::from_ymd(2012, 1, 1))); - assert_eq!(DateZ::from_yo_opt(2012, 2), Some(DateZ::from_ymd(2012, 1, 2))); - assert_eq!(DateZ::from_yo_opt(2012, 32), Some(DateZ::from_ymd(2012, 2, 1))); - assert_eq!(DateZ::from_yo_opt(2012, 60), Some(DateZ::from_ymd(2012, 2, 29))); - assert_eq!(DateZ::from_yo_opt(2012, 61), Some(DateZ::from_ymd(2012, 3, 1))); - assert_eq!(DateZ::from_yo_opt(2012, 100), Some(DateZ::from_ymd(2012, 4, 9))); - assert_eq!(DateZ::from_yo_opt(2012, 200), Some(DateZ::from_ymd(2012, 7, 18))); - assert_eq!(DateZ::from_yo_opt(2012, 300), Some(DateZ::from_ymd(2012, 10, 26))); - assert_eq!(DateZ::from_yo_opt(2012, 366), Some(DateZ::from_ymd(2012, 12, 31))); - assert_eq!(DateZ::from_yo_opt(2012, 367), None); + let yo_opt = |y,o| NaiveDate::from_yo_opt(y, o); + let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d); - assert_eq!(DateZ::from_yo_opt(2014, 0), None); - assert_eq!(DateZ::from_yo_opt(2014, 1), Some(DateZ::from_ymd(2014, 1, 1))); - assert_eq!(DateZ::from_yo_opt(2014, 2), Some(DateZ::from_ymd(2014, 1, 2))); - assert_eq!(DateZ::from_yo_opt(2014, 32), Some(DateZ::from_ymd(2014, 2, 1))); - assert_eq!(DateZ::from_yo_opt(2014, 59), Some(DateZ::from_ymd(2014, 2, 28))); - assert_eq!(DateZ::from_yo_opt(2014, 60), Some(DateZ::from_ymd(2014, 3, 1))); - assert_eq!(DateZ::from_yo_opt(2014, 100), Some(DateZ::from_ymd(2014, 4, 10))); - assert_eq!(DateZ::from_yo_opt(2014, 200), Some(DateZ::from_ymd(2014, 7, 19))); - assert_eq!(DateZ::from_yo_opt(2014, 300), Some(DateZ::from_ymd(2014, 10, 27))); - assert_eq!(DateZ::from_yo_opt(2014, 365), Some(DateZ::from_ymd(2014, 12, 31))); - assert_eq!(DateZ::from_yo_opt(2014, 366), None); + assert_eq!(yo_opt(2012, 0), None); + assert_eq!(yo_opt(2012, 1), Some(ymd(2012, 1, 1))); + assert_eq!(yo_opt(2012, 2), Some(ymd(2012, 1, 2))); + assert_eq!(yo_opt(2012, 32), Some(ymd(2012, 2, 1))); + assert_eq!(yo_opt(2012, 60), Some(ymd(2012, 2, 29))); + assert_eq!(yo_opt(2012, 61), Some(ymd(2012, 3, 1))); + assert_eq!(yo_opt(2012, 100), Some(ymd(2012, 4, 9))); + assert_eq!(yo_opt(2012, 200), Some(ymd(2012, 7, 18))); + assert_eq!(yo_opt(2012, 300), Some(ymd(2012, 10, 26))); + assert_eq!(yo_opt(2012, 366), Some(ymd(2012, 12, 31))); + assert_eq!(yo_opt(2012, 367), None); + + assert_eq!(yo_opt(2014, 0), None); + assert_eq!(yo_opt(2014, 1), Some(ymd(2014, 1, 1))); + assert_eq!(yo_opt(2014, 2), Some(ymd(2014, 1, 2))); + assert_eq!(yo_opt(2014, 32), Some(ymd(2014, 2, 1))); + assert_eq!(yo_opt(2014, 59), Some(ymd(2014, 2, 28))); + assert_eq!(yo_opt(2014, 60), Some(ymd(2014, 3, 1))); + assert_eq!(yo_opt(2014, 100), Some(ymd(2014, 4, 10))); + assert_eq!(yo_opt(2014, 200), Some(ymd(2014, 7, 19))); + assert_eq!(yo_opt(2014, 300), Some(ymd(2014, 10, 27))); + assert_eq!(yo_opt(2014, 365), Some(ymd(2014, 12, 31))); + assert_eq!(yo_opt(2014, 366), None); } #[test] fn test_date_from_isoywd() { - assert_eq!(DateZ::from_isoywd_opt(2004, 0, Sun), None); - assert_eq!(DateZ::from_isoywd_opt(2004, 1, Mon), Some(DateZ::from_ymd(2003, 12, 29))); - assert_eq!(DateZ::from_isoywd_opt(2004, 1, Sun), Some(DateZ::from_ymd(2004, 1, 4))); - assert_eq!(DateZ::from_isoywd_opt(2004, 2, Mon), Some(DateZ::from_ymd(2004, 1, 5))); - assert_eq!(DateZ::from_isoywd_opt(2004, 2, Sun), Some(DateZ::from_ymd(2004, 1, 11))); - assert_eq!(DateZ::from_isoywd_opt(2004, 52, Mon), Some(DateZ::from_ymd(2004, 12, 20))); - assert_eq!(DateZ::from_isoywd_opt(2004, 52, Sun), Some(DateZ::from_ymd(2004, 12, 26))); - assert_eq!(DateZ::from_isoywd_opt(2004, 53, Mon), Some(DateZ::from_ymd(2004, 12, 27))); - assert_eq!(DateZ::from_isoywd_opt(2004, 53, Sun), Some(DateZ::from_ymd(2005, 1, 2))); - assert_eq!(DateZ::from_isoywd_opt(2004, 54, Mon), None); + let isoywd_opt = |y,w,d| NaiveDate::from_isoywd_opt(y, w, d); + let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d); - assert_eq!(DateZ::from_isoywd_opt(2011, 0, Sun), None); - assert_eq!(DateZ::from_isoywd_opt(2011, 1, Mon), Some(DateZ::from_ymd(2011, 1, 3))); - assert_eq!(DateZ::from_isoywd_opt(2011, 1, Sun), Some(DateZ::from_ymd(2011, 1, 9))); - assert_eq!(DateZ::from_isoywd_opt(2011, 2, Mon), Some(DateZ::from_ymd(2011, 1, 10))); - assert_eq!(DateZ::from_isoywd_opt(2011, 2, Sun), Some(DateZ::from_ymd(2011, 1, 16))); + assert_eq!(isoywd_opt(2004, 0, Sun), None); + assert_eq!(isoywd_opt(2004, 1, Mon), Some(ymd(2003, 12, 29))); + assert_eq!(isoywd_opt(2004, 1, Sun), Some(ymd(2004, 1, 4))); + assert_eq!(isoywd_opt(2004, 2, Mon), Some(ymd(2004, 1, 5))); + assert_eq!(isoywd_opt(2004, 2, Sun), Some(ymd(2004, 1, 11))); + assert_eq!(isoywd_opt(2004, 52, Mon), Some(ymd(2004, 12, 20))); + assert_eq!(isoywd_opt(2004, 52, Sun), Some(ymd(2004, 12, 26))); + assert_eq!(isoywd_opt(2004, 53, Mon), Some(ymd(2004, 12, 27))); + assert_eq!(isoywd_opt(2004, 53, Sun), Some(ymd(2005, 1, 2))); + assert_eq!(isoywd_opt(2004, 54, Mon), None); - assert_eq!(DateZ::from_isoywd_opt(2018, 51, Mon), Some(DateZ::from_ymd(2018, 12, 17))); - assert_eq!(DateZ::from_isoywd_opt(2018, 51, Sun), Some(DateZ::from_ymd(2018, 12, 23))); - assert_eq!(DateZ::from_isoywd_opt(2018, 52, Mon), Some(DateZ::from_ymd(2018, 12, 24))); - assert_eq!(DateZ::from_isoywd_opt(2018, 52, Sun), Some(DateZ::from_ymd(2018, 12, 30))); - assert_eq!(DateZ::from_isoywd_opt(2018, 53, Mon), None); + assert_eq!(isoywd_opt(2011, 0, Sun), None); + assert_eq!(isoywd_opt(2011, 1, Mon), Some(ymd(2011, 1, 3))); + assert_eq!(isoywd_opt(2011, 1, Sun), Some(ymd(2011, 1, 9))); + assert_eq!(isoywd_opt(2011, 2, Mon), Some(ymd(2011, 1, 10))); + assert_eq!(isoywd_opt(2011, 2, Sun), Some(ymd(2011, 1, 16))); + + assert_eq!(isoywd_opt(2018, 51, Mon), Some(ymd(2018, 12, 17))); + assert_eq!(isoywd_opt(2018, 51, Sun), Some(ymd(2018, 12, 23))); + assert_eq!(isoywd_opt(2018, 52, Mon), Some(ymd(2018, 12, 24))); + assert_eq!(isoywd_opt(2018, 52, Sun), Some(ymd(2018, 12, 30))); + assert_eq!(isoywd_opt(2018, 53, Mon), None); } #[test] @@ -939,7 +950,7 @@ mod tests { for year in range_inclusive(2000i32, 2400) { for week in range_inclusive(1u32, 53) { for &weekday in [Mon, Tue, Wed, Thu, Fri, Sat, Sun].iter() { - let d = DateZ::from_isoywd_opt(year, week, weekday); + let d = NaiveDate::from_isoywd_opt(year, week, weekday); if d.is_some() { let d = d.unwrap(); assert_eq!(d.weekday(), weekday); @@ -955,11 +966,11 @@ mod tests { for year in range_inclusive(2000i32, 2400) { for month in range_inclusive(1u32, 12) { for day in range_inclusive(1u32, 31) { - let d = DateZ::from_ymd_opt(year, month, day); + let d = NaiveDate::from_ymd_opt(year, month, day); if d.is_some() { let d = d.unwrap(); let (year_, week_, weekday_) = d.isoweekdate(); - let d_ = DateZ::from_isoywd(year_, week_, weekday_); + let d_ = NaiveDate::from_isoywd(year_, week_, weekday_); assert_eq!(d, d_); } } @@ -970,13 +981,13 @@ mod tests { #[test] fn test_date_fields() { fn check(year: i32, month: u32, day: u32, ordinal: u32) { - let d1 = DateZ::from_ymd(year, month, day); + let d1 = NaiveDate::from_ymd(year, month, day); assert_eq!(d1.year(), year); assert_eq!(d1.month(), month); assert_eq!(d1.day(), day); assert_eq!(d1.ordinal(), ordinal); - let d2 = DateZ::from_yo(year, ordinal); + let d2 = NaiveDate::from_yo(year, ordinal); assert_eq!(d2.year(), year); assert_eq!(d2.month(), month); assert_eq!(d2.day(), day); @@ -1008,83 +1019,85 @@ mod tests { #[test] fn test_date_weekday() { - assert_eq!(DateZ::from_ymd(1582, 10, 15).weekday(), Fri); - assert_eq!(DateZ::from_ymd(1875, 5, 20).weekday(), Thu); // ISO 8601 reference date - assert_eq!(DateZ::from_ymd(2000, 1, 1).weekday(), Sat); + assert_eq!(NaiveDate::from_ymd(1582, 10, 15).weekday(), Fri); + assert_eq!(NaiveDate::from_ymd(1875, 5, 20).weekday(), Thu); // ISO 8601 reference date + assert_eq!(NaiveDate::from_ymd(2000, 1, 1).weekday(), Sat); } #[test] fn test_date_with_fields() { - let d = DateZ::from_ymd(2000, 2, 29); - assert_eq!(d.with_year(-400), Some(DateZ::from_ymd(-400, 2, 29))); + let d = NaiveDate::from_ymd(2000, 2, 29); + assert_eq!(d.with_year(-400), Some(NaiveDate::from_ymd(-400, 2, 29))); assert_eq!(d.with_year(-100), None); - assert_eq!(d.with_year(1600), Some(DateZ::from_ymd(1600, 2, 29))); + assert_eq!(d.with_year(1600), Some(NaiveDate::from_ymd(1600, 2, 29))); assert_eq!(d.with_year(1900), None); - assert_eq!(d.with_year(2000), Some(DateZ::from_ymd(2000, 2, 29))); + assert_eq!(d.with_year(2000), Some(NaiveDate::from_ymd(2000, 2, 29))); assert_eq!(d.with_year(2001), None); - assert_eq!(d.with_year(2004), Some(DateZ::from_ymd(2004, 2, 29))); + assert_eq!(d.with_year(2004), Some(NaiveDate::from_ymd(2004, 2, 29))); assert_eq!(d.with_year(i32::MAX), None); - let d = DateZ::from_ymd(2000, 4, 30); + let d = NaiveDate::from_ymd(2000, 4, 30); assert_eq!(d.with_month(0), None); - assert_eq!(d.with_month(1), Some(DateZ::from_ymd(2000, 1, 30))); + assert_eq!(d.with_month(1), Some(NaiveDate::from_ymd(2000, 1, 30))); assert_eq!(d.with_month(2), None); - assert_eq!(d.with_month(3), Some(DateZ::from_ymd(2000, 3, 30))); - assert_eq!(d.with_month(4), Some(DateZ::from_ymd(2000, 4, 30))); - assert_eq!(d.with_month(12), Some(DateZ::from_ymd(2000, 12, 30))); + assert_eq!(d.with_month(3), Some(NaiveDate::from_ymd(2000, 3, 30))); + assert_eq!(d.with_month(4), Some(NaiveDate::from_ymd(2000, 4, 30))); + assert_eq!(d.with_month(12), Some(NaiveDate::from_ymd(2000, 12, 30))); assert_eq!(d.with_month(13), None); assert_eq!(d.with_month(u32::MAX), None); - let d = DateZ::from_ymd(2000, 2, 8); + let d = NaiveDate::from_ymd(2000, 2, 8); assert_eq!(d.with_day(0), None); - assert_eq!(d.with_day(1), Some(DateZ::from_ymd(2000, 2, 1))); - assert_eq!(d.with_day(29), Some(DateZ::from_ymd(2000, 2, 29))); + assert_eq!(d.with_day(1), Some(NaiveDate::from_ymd(2000, 2, 1))); + assert_eq!(d.with_day(29), Some(NaiveDate::from_ymd(2000, 2, 29))); assert_eq!(d.with_day(30), None); assert_eq!(d.with_day(u32::MAX), None); - let d = DateZ::from_ymd(2000, 5, 5); + let d = NaiveDate::from_ymd(2000, 5, 5); assert_eq!(d.with_ordinal(0), None); - assert_eq!(d.with_ordinal(1), Some(DateZ::from_ymd(2000, 1, 1))); - assert_eq!(d.with_ordinal(60), Some(DateZ::from_ymd(2000, 2, 29))); - assert_eq!(d.with_ordinal(61), Some(DateZ::from_ymd(2000, 3, 1))); - assert_eq!(d.with_ordinal(366), Some(DateZ::from_ymd(2000, 12, 31))); + assert_eq!(d.with_ordinal(1), Some(NaiveDate::from_ymd(2000, 1, 1))); + assert_eq!(d.with_ordinal(60), Some(NaiveDate::from_ymd(2000, 2, 29))); + assert_eq!(d.with_ordinal(61), Some(NaiveDate::from_ymd(2000, 3, 1))); + assert_eq!(d.with_ordinal(366), Some(NaiveDate::from_ymd(2000, 12, 31))); assert_eq!(d.with_ordinal(367), None); assert_eq!(d.with_ordinal(u32::MAX), None); } #[test] fn test_date_num_days_from_ce() { - assert_eq!(DateZ::from_ymd(1, 1, 1).num_days_from_ce(), 1); + assert_eq!(NaiveDate::from_ymd(1, 1, 1).num_days_from_ce(), 1); for year in range_inclusive(-9999i32, 10000) { - assert_eq!(DateZ::from_ymd(year, 1, 1).num_days_from_ce(), - DateZ::from_ymd(year - 1, 12, 31).num_days_from_ce() + 1); + assert_eq!(NaiveDate::from_ymd(year, 1, 1).num_days_from_ce(), + NaiveDate::from_ymd(year - 1, 12, 31).num_days_from_ce() + 1); } } #[test] fn test_date_succ() { - assert_eq!(DateZ::from_ymd(2014, 5, 6).succ_opt(), Some(DateZ::from_ymd(2014, 5, 7))); - assert_eq!(DateZ::from_ymd(2014, 5, 31).succ_opt(), Some(DateZ::from_ymd(2014, 6, 1))); - assert_eq!(DateZ::from_ymd(2014, 12, 31).succ_opt(), Some(DateZ::from_ymd(2015, 1, 1))); - assert_eq!(DateZ::from_ymd(2016, 2, 28).succ_opt(), Some(DateZ::from_ymd(2016, 2, 29))); - assert_eq!(DateZ::from_ymd(MAX_YEAR, 12, 31).succ_opt(), None); + let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d); + assert_eq!(ymd(2014, 5, 6).succ_opt(), Some(ymd(2014, 5, 7))); + assert_eq!(ymd(2014, 5, 31).succ_opt(), Some(ymd(2014, 6, 1))); + assert_eq!(ymd(2014, 12, 31).succ_opt(), Some(ymd(2015, 1, 1))); + assert_eq!(ymd(2016, 2, 28).succ_opt(), Some(ymd(2016, 2, 29))); + assert_eq!(ymd(MAX_YEAR, 12, 31).succ_opt(), None); } #[test] fn test_date_pred() { - assert_eq!(DateZ::from_ymd(2016, 3, 1).pred_opt(), Some(DateZ::from_ymd(2016, 2, 29))); - assert_eq!(DateZ::from_ymd(2015, 1, 1).pred_opt(), Some(DateZ::from_ymd(2014, 12, 31))); - assert_eq!(DateZ::from_ymd(2014, 6, 1).pred_opt(), Some(DateZ::from_ymd(2014, 5, 31))); - assert_eq!(DateZ::from_ymd(2014, 5, 7).pred_opt(), Some(DateZ::from_ymd(2014, 5, 6))); - assert_eq!(DateZ::from_ymd(MIN_YEAR, 1, 1).pred_opt(), None); + let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d); + assert_eq!(ymd(2016, 3, 1).pred_opt(), Some(ymd(2016, 2, 29))); + assert_eq!(ymd(2015, 1, 1).pred_opt(), Some(ymd(2014, 12, 31))); + assert_eq!(ymd(2014, 6, 1).pred_opt(), Some(ymd(2014, 5, 31))); + assert_eq!(ymd(2014, 5, 7).pred_opt(), Some(ymd(2014, 5, 6))); + assert_eq!(ymd(MIN_YEAR, 1, 1).pred_opt(), None); } #[test] fn test_date_add() { fn check((y1,m1,d1): (i32, u32, u32), rhs: Duration, (y,m,d): (i32, u32, u32)) { - let lhs = DateZ::from_ymd(y1, m1, d1); - let sum = DateZ::from_ymd(y, m, d); + let lhs = NaiveDate::from_ymd(y1, m1, d1); + let sum = NaiveDate::from_ymd(y, m, d); assert_eq!(lhs + rhs, sum); //assert_eq!(rhs + lhs, sum); } @@ -1104,8 +1117,8 @@ mod tests { #[test] fn test_date_sub() { fn check((y1,m1,d1): (i32, u32, u32), (y2,m2,d2): (i32, u32, u32), diff: Duration) { - let lhs = DateZ::from_ymd(y1, m1, d1); - let rhs = DateZ::from_ymd(y2, m2, d2); + let lhs = NaiveDate::from_ymd(y1, m1, d1); + let rhs = NaiveDate::from_ymd(y2, m2, d2); assert_eq!(lhs - rhs, diff); assert_eq!(rhs - lhs, -diff); } @@ -1120,14 +1133,14 @@ mod tests { #[test] fn test_date_fmt() { - assert_eq!(DateZ::from_ymd(2012, 3, 4).to_string(), "2012-03-04".to_string()); - assert_eq!(DateZ::from_ymd(0, 3, 4).to_string(), "0000-03-04".to_string()); - assert_eq!(DateZ::from_ymd(-307, 3, 4).to_string(), "-0307-03-04".to_string()); - assert_eq!(DateZ::from_ymd(12345, 3, 4).to_string(), "+12345-03-04".to_string()); + assert_eq!(NaiveDate::from_ymd(2012, 3, 4).to_string(), "2012-03-04".to_string()); + assert_eq!(NaiveDate::from_ymd(0, 3, 4).to_string(), "0000-03-04".to_string()); + assert_eq!(NaiveDate::from_ymd(-307, 3, 4).to_string(), "-0307-03-04".to_string()); + assert_eq!(NaiveDate::from_ymd(12345, 3, 4).to_string(), "+12345-03-04".to_string()); - // the format specifier should have no effect on `TimeZ` - assert_eq!(format!("{:+30}", DateZ::from_ymd(1234, 5, 6)), "1234-05-06".to_string()); - assert_eq!(format!("{:30}", DateZ::from_ymd(12345, 6, 7)), "+12345-06-07".to_string()); + // the format specifier should have no effect on `NaiveTime` + assert_eq!(format!("{:+30}", NaiveDate::from_ymd(1234, 5, 6)), "1234-05-06".to_string()); + assert_eq!(format!("{:30}", NaiveDate::from_ymd(12345, 6, 7)), "+12345-06-07".to_string()); } } @@ -1136,13 +1149,13 @@ mod tests { * * The current implementation is optimized for determining year, month, day and day of week. * 4-bit `YearFlags` map to one of 14 possible classes of year in the Gregorian calendar, - * which are included in every packed `DateZ` instance. + * which are included in every packed `NaiveDate` instance. * The conversion between the packed calendar date (`Mdf`) and the ordinal date (`Of`) is * based on the moderately-sized lookup table (~1.5KB) * and the packed representation is chosen for the efficient lookup. * Every internal data structure does not validate its input, * but the conversion keeps the valid value valid and the invalid value invalid - * so that the user-facing `DateZ` can validate the input as late as possible. + * so that the user-facing `NaiveDate` can validate the input as late as possible. */ #[allow(dead_code)] // some internal methods have been left for consistency mod internals { diff --git a/src/datetime.rs b/src/datetime.rs index 35e9e1e..5ea8e5e 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -9,100 +9,33 @@ use std::{fmt, hash}; use offset::Offset; use duration::Duration; -use time::{Timelike, TimeZ, Time}; -use date::{Datelike, DateZ, Date, Weekday}; +use time::{Timelike, NaiveTime, Time}; +use date::{Datelike, NaiveDate, Date, Weekday}; /// ISO 8601 combined date and time without timezone. #[deriving(PartialEq, Eq, PartialOrd, Ord, Clone, Hash)] -pub struct DateTimeZ { - date: DateZ, - time: TimeZ, +pub struct NaiveDateTime { + date: NaiveDate, + time: NaiveTime, } -impl DateTimeZ { - /// Makes a new `DateTimeZ` from date and time components. +impl NaiveDateTime { + /// Makes a new `NaiveDateTime` from date and time components. + /// Equivalent to `date.and_time(time)` and many other helper constructors on `NaiveDate`. #[inline] - pub fn new(date: DateZ, time: TimeZ) -> DateTimeZ { - DateTimeZ { date: date, time: time } - } - - /// Makes a new `DateTimeZ` from year, month, day, hour, minute and second. - /// - /// Fails on invalid arguments. - #[inline] - pub fn from_ymdhms(year: i32, month: u32, day: u32, - hour: u32, min: u32, sec: u32) -> DateTimeZ { - let dt = DateTimeZ::from_ymdhms_opt(year, month, day, hour, min, sec); - dt.expect("invalid or out-of-range date or time") - } - - /// Makes a new `DateTimeZ` from year, month, day, hour, minute and second. - /// - /// Returns `None` on invalid arguments. - #[inline] - pub fn from_ymdhms_opt(year: i32, month: u32, day: u32, - hour: u32, min: u32, sec: u32) -> Option { - match (DateZ::from_ymd_opt(year, month, day), TimeZ::from_hms_opt(hour, min, sec)) { - (Some(d), Some(t)) => Some(DateTimeZ::new(d, t)), - (_, _) => None, - } - } - - /// Makes a new `DateTimeZ` from year, day of year (DOY or "ordinal"), hour, minute and second. - /// - /// Fails on invalid arguments. - #[inline] - pub fn from_yohms(year: i32, ordinal: u32, - hour: u32, min: u32, sec: u32) -> DateTimeZ { - let dt = DateTimeZ::from_yohms_opt(year, ordinal, hour, min, sec); - dt.expect("invalid or out-of-range date or time") - } - - /// Makes a new `DateTimeZ` from year, day of year (DOY or "ordinal"), hour, minute and second. - /// - /// Returns `None` on invalid arguments. - #[inline] - pub fn from_yohms_opt(year: i32, ordinal: u32, - hour: u32, min: u32, sec: u32) -> Option { - match (DateZ::from_yo_opt(year, ordinal), TimeZ::from_hms_opt(hour, min, sec)) { - (Some(d), Some(t)) => Some(DateTimeZ::new(d, t)), - (_, _) => None, - } - } - - /// Makes a new `DateTimeZ` from ISO week date (year and week number), day of the week (DOW), - /// hour, minute and second. - /// - /// Fails on invalid arguments. - #[inline] - pub fn from_isoywdhms(year: i32, week: u32, weekday: Weekday, - hour: u32, min: u32, sec: u32) -> DateTimeZ { - let dt = DateTimeZ::from_isoywdhms_opt(year, week, weekday, hour, min, sec); - dt.expect("invalid or out-of-range date or time") - } - - /// Makes a new `DateTimeZ` from ISO week date (year and week number), day of the week (DOW), - /// hour, minute and second. - /// - /// Returns `None` on invalid arguments. - #[inline] - pub fn from_isoywdhms_opt(year: i32, week: u32, weekday: Weekday, - hour: u32, min: u32, sec: u32) -> Option { - match (DateZ::from_isoywd_opt(year, week, weekday), TimeZ::from_hms_opt(hour, min, sec)) { - (Some(d), Some(t)) => Some(DateTimeZ::new(d, t)), - (_, _) => None, - } + pub fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime { + NaiveDateTime { date: date, time: time } } /// Retrieves a date component. #[inline] - pub fn date(&self) -> DateZ { + pub fn date(&self) -> NaiveDate { self.date } /// Retrieves a time component. #[inline] - pub fn time(&self) -> TimeZ { + pub fn time(&self) -> NaiveTime { self.time } @@ -116,7 +49,7 @@ impl DateTimeZ { } } -impl Datelike for DateTimeZ { +impl Datelike for NaiveDateTime { #[inline] fn year(&self) -> i32 { self.date.year() } #[inline] fn month(&self) -> u32 { self.date.month() } #[inline] fn month0(&self) -> u32 { self.date.month0() } @@ -128,72 +61,72 @@ impl Datelike for DateTimeZ { #[inline] fn isoweekdate(&self) -> (i32, u32, Weekday) { self.date.isoweekdate() } #[inline] - fn with_year(&self, year: i32) -> Option { - self.date.with_year(year).map(|d| DateTimeZ { date: d, ..*self }) + fn with_year(&self, year: i32) -> Option { + self.date.with_year(year).map(|d| NaiveDateTime { date: d, ..*self }) } #[inline] - fn with_month(&self, month: u32) -> Option { - self.date.with_month(month).map(|d| DateTimeZ { date: d, ..*self }) + fn with_month(&self, month: u32) -> Option { + self.date.with_month(month).map(|d| NaiveDateTime { date: d, ..*self }) } #[inline] - fn with_month0(&self, month0: u32) -> Option { - self.date.with_month0(month0).map(|d| DateTimeZ { date: d, ..*self }) + fn with_month0(&self, month0: u32) -> Option { + self.date.with_month0(month0).map(|d| NaiveDateTime { date: d, ..*self }) } #[inline] - fn with_day(&self, day: u32) -> Option { - self.date.with_day(day).map(|d| DateTimeZ { date: d, ..*self }) + fn with_day(&self, day: u32) -> Option { + self.date.with_day(day).map(|d| NaiveDateTime { date: d, ..*self }) } #[inline] - fn with_day0(&self, day0: u32) -> Option { - self.date.with_day0(day0).map(|d| DateTimeZ { date: d, ..*self }) + fn with_day0(&self, day0: u32) -> Option { + self.date.with_day0(day0).map(|d| NaiveDateTime { date: d, ..*self }) } #[inline] - fn with_ordinal(&self, ordinal: u32) -> Option { - self.date.with_ordinal(ordinal).map(|d| DateTimeZ { date: d, ..*self }) + fn with_ordinal(&self, ordinal: u32) -> Option { + self.date.with_ordinal(ordinal).map(|d| NaiveDateTime { date: d, ..*self }) } #[inline] - fn with_ordinal0(&self, ordinal0: u32) -> Option { - self.date.with_ordinal0(ordinal0).map(|d| DateTimeZ { date: d, ..*self }) + fn with_ordinal0(&self, ordinal0: u32) -> Option { + self.date.with_ordinal0(ordinal0).map(|d| NaiveDateTime { date: d, ..*self }) } } -impl Timelike for DateTimeZ { +impl Timelike for NaiveDateTime { #[inline] fn hour(&self) -> u32 { self.time.hour() } #[inline] fn minute(&self) -> u32 { self.time.minute() } #[inline] fn second(&self) -> u32 { self.time.second() } #[inline] fn nanosecond(&self) -> u32 { self.time.nanosecond() } #[inline] - fn with_hour(&self, hour: u32) -> Option { - self.time.with_hour(hour).map(|t| DateTimeZ { time: t, ..*self }) + fn with_hour(&self, hour: u32) -> Option { + self.time.with_hour(hour).map(|t| NaiveDateTime { time: t, ..*self }) } #[inline] - fn with_minute(&self, min: u32) -> Option { - self.time.with_minute(min).map(|t| DateTimeZ { time: t, ..*self }) + fn with_minute(&self, min: u32) -> Option { + self.time.with_minute(min).map(|t| NaiveDateTime { time: t, ..*self }) } #[inline] - fn with_second(&self, sec: u32) -> Option { - self.time.with_second(sec).map(|t| DateTimeZ { time: t, ..*self }) + fn with_second(&self, sec: u32) -> Option { + self.time.with_second(sec).map(|t| NaiveDateTime { time: t, ..*self }) } #[inline] - fn with_nanosecond(&self, nano: u32) -> Option { - self.time.with_nanosecond(nano).map(|t| DateTimeZ { time: t, ..*self }) + fn with_nanosecond(&self, nano: u32) -> Option { + self.time.with_nanosecond(nano).map(|t| NaiveDateTime { time: t, ..*self }) } } -impl Add for DateTimeZ { - fn add(&self, rhs: &Duration) -> DateTimeZ { - // we want `(DateZ + days in Duration) + (TimeZ + secs/nanos in Duration)` - // to be equal to `DateTimeZ + Duration`, but `DateZ + Duration` rounds towards zero. +impl Add for NaiveDateTime { + fn add(&self, rhs: &Duration) -> NaiveDateTime { + // we want `(NaiveDate + days in Duration) + (NaiveTime + secs/nanos in Duration)` + // to be equal to `NaiveDateTime + Duration`, but `NaiveDate + Duration` rounds towards zero. let mut date = self.date + Duration::days(rhs.to_tuple().val0()); let time = self.time + *rhs; if time < self.time { @@ -201,25 +134,25 @@ impl Add for DateTimeZ { // this condition always means that the time part has been overflowed. date = date.succ(); } - DateTimeZ { date: date, time: time } + NaiveDateTime { date: date, time: time } } } /* // Rust issue #7590, the current coherence checker can't handle multiple Add impls -impl Add for Duration { +impl Add for Duration { #[inline] - fn add(&self, rhs: &DateTimeZ) -> DateTimeZ { rhs.add(self) } + fn add(&self, rhs: &NaiveDateTime) -> NaiveDateTime { rhs.add(self) } } */ -impl Sub for DateTimeZ { - fn sub(&self, rhs: &DateTimeZ) -> Duration { +impl Sub for NaiveDateTime { + fn sub(&self, rhs: &NaiveDateTime) -> Duration { (self.date - rhs.date) + (self.time - rhs.time) } } -impl fmt::Show for DateTimeZ { +impl fmt::Show for NaiveDateTime { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}T{}", self.date, self.time) } @@ -228,7 +161,7 @@ impl fmt::Show for DateTimeZ { /// ISO 8601 combined date and time with timezone. #[deriving(Clone)] pub struct DateTime { - datetime: DateTimeZ, + datetime: NaiveDateTime, offset: Off, } @@ -236,7 +169,7 @@ impl DateTime { /// Makes a new `DateTime` with given *UTC* datetime and offset. /// The local datetime should be constructed via the `Offset` trait. #[inline] - pub fn from_utc(datetime: DateTimeZ, offset: Off) -> DateTime { + pub fn from_utc(datetime: NaiveDateTime, offset: Off) -> DateTime { DateTime { datetime: datetime, offset: offset } } @@ -259,7 +192,7 @@ impl DateTime { } /// Returns a view to the local datetime. - fn local(&self) -> DateTimeZ { + fn local(&self) -> NaiveDateTime { self.offset.to_local_datetime(&self.datetime) } } @@ -402,12 +335,12 @@ impl fmt::Show for DateTime { #[cfg(test)] mod tests { - use super::DateTimeZ; + use date::NaiveDate; use duration::Duration; #[test] fn test_datetime_add() { - let ymdhms = |y,m,d,h,n,s| DateTimeZ::from_ymdhms(y,m,d,h,n,s); + let ymdhms = |y,m,d,h,n,s| NaiveDate::from_ymd(y,m,d).and_hms(h,n,s); assert_eq!(ymdhms(2014, 5, 6, 7, 8, 9) + Duration::seconds(3600 + 60 + 1), ymdhms(2014, 5, 6, 8, 9, 10)); assert_eq!(ymdhms(2014, 5, 6, 7, 8, 9) + Duration::seconds(-(3600 + 60 + 1)), @@ -422,7 +355,7 @@ mod tests { #[test] fn test_datetime_sub() { - let ymdhms = |y,m,d,h,n,s| DateTimeZ::from_ymdhms(y,m,d,h,n,s); + let ymdhms = |y,m,d,h,n,s| NaiveDate::from_ymd(y,m,d).and_hms(h,n,s); assert_eq!(ymdhms(2014, 5, 6, 7, 8, 9) - ymdhms(2014, 5, 6, 7, 8, 9), Duration::zero()); assert_eq!(ymdhms(2014, 5, 6, 7, 8, 10) - ymdhms(2014, 5, 6, 7, 8, 9), Duration::seconds(1)); @@ -437,7 +370,7 @@ mod tests { #[test] fn test_datetime_num_seconds_from_unix_epoch() { let to_timestamp = - |y,m,d,h,n,s| DateTimeZ::from_ymdhms(y,m,d,h,n,s).num_seconds_from_unix_epoch(); + |y,m,d,h,n,s| NaiveDate::from_ymd(y,m,d).and_hms(h,n,s).num_seconds_from_unix_epoch(); assert_eq!(to_timestamp(1969, 12, 31, 23, 59, 59), -1); assert_eq!(to_timestamp(1970, 1, 1, 0, 0, 0), 0); assert_eq!(to_timestamp(1970, 1, 1, 0, 0, 1), 1); diff --git a/src/lib.rs b/src/lib.rs index d0a961f..389f881 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -16,9 +16,9 @@ extern crate num; pub use duration::Duration; pub use date::{Weekday, Mon, Tue, Wed, Thu, Fri, Sat, Sun}; -pub use date::{Datelike, DateZ}; -pub use time::{Timelike, TimeZ}; -pub use datetime::DateTimeZ; +pub use date::{Datelike, NaiveDate}; +pub use time::{Timelike, NaiveTime}; +pub use datetime::NaiveDateTime; pub mod duration; pub mod offset; @@ -30,22 +30,22 @@ pub mod datetime; fn test_readme_doomsday() { use std::iter::range_inclusive; - for y in range_inclusive(date::MINZ.year(), date::MAXZ.year()) { + for y in range_inclusive(date::MIN_NAIVE.year(), date::MAX_NAIVE.year()) { // even months - let d4 = DateZ::from_ymd(y, 4, 4); - let d6 = DateZ::from_ymd(y, 6, 6); - let d8 = DateZ::from_ymd(y, 8, 8); - let d10 = DateZ::from_ymd(y, 10, 10); - let d12 = DateZ::from_ymd(y, 12, 12); + let d4 = NaiveDate::from_ymd(y, 4, 4); + let d6 = NaiveDate::from_ymd(y, 6, 6); + let d8 = NaiveDate::from_ymd(y, 8, 8); + let d10 = NaiveDate::from_ymd(y, 10, 10); + let d12 = NaiveDate::from_ymd(y, 12, 12); // nine to five, seven-eleven - let d59 = DateZ::from_ymd(y, 5, 9); - let d95 = DateZ::from_ymd(y, 9, 5); - let d711 = DateZ::from_ymd(y, 7, 11); - let d117 = DateZ::from_ymd(y, 11, 7); + let d59 = NaiveDate::from_ymd(y, 5, 9); + let d95 = NaiveDate::from_ymd(y, 9, 5); + let d711 = NaiveDate::from_ymd(y, 7, 11); + let d117 = NaiveDate::from_ymd(y, 11, 7); // "March 0" - let d30 = DateZ::from_ymd(y, 3, 1).pred(); + let d30 = NaiveDate::from_ymd(y, 3, 1).pred(); let weekday = d30.weekday(); let other_dates = [d4, d6, d8, d10, d12, d59, d95, d711, d117]; diff --git a/src/offset.rs b/src/offset.rs index c52c6cc..39425d7 100644 --- a/src/offset.rs +++ b/src/offset.rs @@ -9,9 +9,9 @@ use std::fmt; use num::Integer; use duration::Duration; -use date::{DateZ, Date, Weekday}; -use time::{TimeZ, Time}; -use datetime::{DateTimeZ, DateTime}; +use date::{NaiveDate, Date, Weekday}; +use time::{NaiveTime, Time}; +use datetime::{NaiveDateTime, DateTime}; /// The conversion result from the local time to the timezone-aware datetime types. pub enum LocalResult { @@ -74,7 +74,7 @@ pub trait Offset: Clone + fmt::Show { /// /// Returns `None` on the out-of-range date, invalid month and/or day. fn ymd_opt(&self, year: i32, month: u32, day: u32) -> LocalResult> { - match DateZ::from_ymd_opt(year, month, day) { + match NaiveDate::from_ymd_opt(year, month, day) { Some(d) => self.from_local_date(&d), None => NoResult, } @@ -99,7 +99,7 @@ pub trait Offset: Clone + fmt::Show { /// /// Returns `None` on the out-of-range date and/or invalid DOY. fn yo_opt(&self, year: i32, ordinal: u32) -> LocalResult> { - match DateZ::from_yo_opt(year, ordinal) { + match NaiveDate::from_yo_opt(year, ordinal) { Some(d) => self.from_local_date(&d), None => NoResult, } @@ -128,7 +128,7 @@ pub trait Offset: Clone + fmt::Show { /// /// Returns `None` on the out-of-range date and/or invalid week number. fn isoywd_opt(&self, year: i32, week: u32, weekday: Weekday) -> LocalResult> { - match DateZ::from_isoywd_opt(year, week, weekday) { + match NaiveDate::from_isoywd_opt(year, week, weekday) { Some(d) => self.from_local_date(&d), None => NoResult, } @@ -145,7 +145,7 @@ pub trait Offset: Clone + fmt::Show { /// /// Returns `None` on invalid hour, minute and/or second. fn hms_opt(&self, hour: u32, min: u32, sec: u32) -> LocalResult> { - match TimeZ::from_hms_opt(hour, min, sec) { + match NaiveTime::from_hms_opt(hour, min, sec) { Some(t) => self.from_local_time(&t), None => NoResult, } @@ -164,7 +164,7 @@ pub trait Offset: Clone + fmt::Show { /// /// Returns `None` on invalid hour, minute, second and/or millisecond. fn hms_milli_opt(&self, hour: u32, min: u32, sec: u32, milli: u32) -> LocalResult> { - match TimeZ::from_hms_milli_opt(hour, min, sec, milli) { + match NaiveTime::from_hms_milli_opt(hour, min, sec, milli) { Some(t) => self.from_local_time(&t), None => NoResult, } @@ -183,7 +183,7 @@ pub trait Offset: Clone + fmt::Show { /// /// Returns `None` on invalid hour, minute, second and/or microsecond. fn hms_micro_opt(&self, hour: u32, min: u32, sec: u32, micro: u32) -> LocalResult> { - match TimeZ::from_hms_micro_opt(hour, min, sec, micro) { + match NaiveTime::from_hms_micro_opt(hour, min, sec, micro) { Some(t) => self.from_local_time(&t), None => NoResult, } @@ -202,32 +202,32 @@ pub trait Offset: Clone + fmt::Show { /// /// Returns `None` on invalid hour, minute, second and/or nanosecond. fn hms_nano_opt(&self, hour: u32, min: u32, sec: u32, nano: u32) -> LocalResult> { - match TimeZ::from_hms_nano_opt(hour, min, sec, nano) { + match NaiveTime::from_hms_nano_opt(hour, min, sec, nano) { Some(t) => self.from_local_time(&t), None => NoResult, } } - /// Converts the local `DateZ` to the timezone-aware `Date` if possible. - fn from_local_date(&self, local: &DateZ) -> LocalResult>; + /// Converts the local `NaiveDate` to the timezone-aware `Date` if possible. + fn from_local_date(&self, local: &NaiveDate) -> LocalResult>; - /// Converts the local `TimeZ` to the timezone-aware `Time` if possible. - fn from_local_time(&self, local: &TimeZ) -> LocalResult>; + /// Converts the local `NaiveTime` to the timezone-aware `Time` if possible. + fn from_local_time(&self, local: &NaiveTime) -> LocalResult>; - /// Converts the local `DateTimeZ` to the timezone-aware `DateTime` if possible. - fn from_local_datetime(&self, local: &DateTimeZ) -> LocalResult>; + /// Converts the local `NaiveDateTime` to the timezone-aware `DateTime` if possible. + fn from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult>; - /// Converts the UTC `DateZ` to the local time. + /// Converts the UTC `NaiveDate` to the local time. /// The UTC is continuous and thus this cannot fail (but can give the duplicate local time). - fn to_local_date(&self, utc: &DateZ) -> DateZ; + fn to_local_date(&self, utc: &NaiveDate) -> NaiveDate; - /// Converts the UTC `TimeZ` to the local time. + /// Converts the UTC `NaiveTime` to the local time. /// The UTC is continuous and thus this cannot fail (but can give the duplicate local time). - fn to_local_time(&self, utc: &TimeZ) -> TimeZ; + fn to_local_time(&self, utc: &NaiveTime) -> NaiveTime; - /// Converts the UTC `DateTimeZ` to the local time. + /// Converts the UTC `NaiveDateTime` to the local time. /// The UTC is continuous and thus this cannot fail (but can give the duplicate local time). - fn to_local_datetime(&self, utc: &DateTimeZ) -> DateTimeZ; + fn to_local_datetime(&self, utc: &NaiveDateTime) -> NaiveDateTime; } /// The UTC timescale. This is the most efficient offset when you don't need the local time. @@ -235,19 +235,19 @@ pub trait Offset: Clone + fmt::Show { pub struct UTC; impl Offset for UTC { - fn from_local_date(&self, local: &DateZ) -> LocalResult> { + fn from_local_date(&self, local: &NaiveDate) -> LocalResult> { Single(Date::from_utc(local.clone(), UTC)) } - fn from_local_time(&self, local: &TimeZ) -> LocalResult> { + fn from_local_time(&self, local: &NaiveTime) -> LocalResult> { Single(Time::from_utc(local.clone(), UTC)) } - fn from_local_datetime(&self, local: &DateTimeZ) -> LocalResult> { + fn from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult> { Single(DateTime::from_utc(local.clone(), UTC)) } - fn to_local_date(&self, utc: &DateZ) -> DateZ { utc.clone() } - fn to_local_time(&self, utc: &TimeZ) -> TimeZ { utc.clone() } - fn to_local_datetime(&self, utc: &DateTimeZ) -> DateTimeZ { utc.clone() } + fn to_local_date(&self, utc: &NaiveDate) -> NaiveDate { utc.clone() } + fn to_local_time(&self, utc: &NaiveTime) -> NaiveTime { utc.clone() } + fn to_local_datetime(&self, utc: &NaiveDateTime) -> NaiveDateTime { utc.clone() } } impl fmt::Show for UTC { @@ -303,23 +303,23 @@ impl FixedOffset { } impl Offset for FixedOffset { - fn from_local_date(&self, local: &DateZ) -> LocalResult> { + fn from_local_date(&self, local: &NaiveDate) -> LocalResult> { Single(Date::from_utc(local.clone(), self.clone())) } - fn from_local_time(&self, local: &TimeZ) -> LocalResult> { + fn from_local_time(&self, local: &NaiveTime) -> LocalResult> { Single(Time::from_utc(*local + Duration::seconds(-self.local_minus_utc), self.clone())) } - fn from_local_datetime(&self, local: &DateTimeZ) -> LocalResult> { + fn from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult> { Single(DateTime::from_utc(*local + Duration::seconds(-self.local_minus_utc), self.clone())) } - fn to_local_date(&self, utc: &DateZ) -> DateZ { + fn to_local_date(&self, utc: &NaiveDate) -> NaiveDate { utc.clone() } - fn to_local_time(&self, utc: &TimeZ) -> TimeZ { + fn to_local_time(&self, utc: &NaiveTime) -> NaiveTime { *utc + Duration::seconds(self.local_minus_utc) } - fn to_local_datetime(&self, utc: &DateTimeZ) -> DateTimeZ { + fn to_local_datetime(&self, utc: &NaiveDateTime) -> NaiveDateTime { *utc + Duration::seconds(self.local_minus_utc) } } diff --git a/src/time.rs b/src/time.rs index ad4a3fc..5c74b54 100644 --- a/src/time.rs +++ b/src/time.rs @@ -66,82 +66,83 @@ pub trait Timelike { /// ISO 8601 time without timezone. /// Allows for the nanosecond precision and optional leap second representation. #[deriving(PartialEq, Eq, PartialOrd, Ord, Clone, Hash)] -pub struct TimeZ { +pub struct NaiveTime { secs: u32, frac: u32, } -impl TimeZ { - /// Makes a new `TimeZ` from hour, minute and second. +impl NaiveTime { + /// Makes a new `NaiveTime` from hour, minute and second. /// /// Fails on invalid hour, minute and/or second. #[inline] - pub fn from_hms(hour: u32, min: u32, sec: u32) -> TimeZ { - TimeZ::from_hms_opt(hour, min, sec).expect("invalid time") + pub fn from_hms(hour: u32, min: u32, sec: u32) -> NaiveTime { + NaiveTime::from_hms_opt(hour, min, sec).expect("invalid time") } - /// Makes a new `TimeZ` from hour, minute and second. + /// Makes a new `NaiveTime` from hour, minute and second. /// /// Returns `None` on invalid hour, minute and/or second. #[inline] - pub fn from_hms_opt(hour: u32, min: u32, sec: u32) -> Option { - TimeZ::from_hms_nano_opt(hour, min, sec, 0) + pub fn from_hms_opt(hour: u32, min: u32, sec: u32) -> Option { + NaiveTime::from_hms_nano_opt(hour, min, sec, 0) } - /// Makes a new `TimeZ` from hour, minute, second and millisecond. + /// Makes a new `NaiveTime` from hour, minute, second and millisecond. /// The millisecond part can exceed 1,000 in order to represent the leap second. /// /// Fails on invalid hour, minute, second and/or millisecond. #[inline] - pub fn from_hms_milli(hour: u32, min: u32, sec: u32, milli: u32) -> TimeZ { - TimeZ::from_hms_milli_opt(hour, min, sec, milli).expect("invalid time") + pub fn from_hms_milli(hour: u32, min: u32, sec: u32, milli: u32) -> NaiveTime { + NaiveTime::from_hms_milli_opt(hour, min, sec, milli).expect("invalid time") } - /// Makes a new `TimeZ` from hour, minute, second and millisecond. + /// Makes a new `NaiveTime` from hour, minute, second and millisecond. /// The millisecond part can exceed 1,000 in order to represent the leap second. /// /// Returns `None` on invalid hour, minute, second and/or millisecond. #[inline] - pub fn from_hms_milli_opt(hour: u32, min: u32, sec: u32, milli: u32) -> Option { - milli.checked_mul(&1_000_000).and_then(|nano| TimeZ::from_hms_nano_opt(hour, min, sec, - nano)) + pub fn from_hms_milli_opt(hour: u32, min: u32, sec: u32, milli: u32) -> Option { + milli.checked_mul(&1_000_000) + .and_then(|nano| NaiveTime::from_hms_nano_opt(hour, min, sec, nano)) } - /// Makes a new `TimeZ` from hour, minute, second and microsecond. + /// Makes a new `NaiveTime` from hour, minute, second and microsecond. /// The microsecond part can exceed 1,000,000 in order to represent the leap second. /// /// Fails on invalid hour, minute, second and/or microsecond. #[inline] - pub fn from_hms_micro(hour: u32, min: u32, sec: u32, micro: u32) -> TimeZ { - TimeZ::from_hms_micro_opt(hour, min, sec, micro).expect("invalid time") + pub fn from_hms_micro(hour: u32, min: u32, sec: u32, micro: u32) -> NaiveTime { + NaiveTime::from_hms_micro_opt(hour, min, sec, micro).expect("invalid time") } - /// Makes a new `TimeZ` from hour, minute, second and microsecond. + /// Makes a new `NaiveTime` from hour, minute, second and microsecond. /// The microsecond part can exceed 1,000,000 in order to represent the leap second. /// /// Returns `None` on invalid hour, minute, second and/or microsecond. #[inline] - pub fn from_hms_micro_opt(hour: u32, min: u32, sec: u32, micro: u32) -> Option { - micro.checked_mul(&1_000).and_then(|nano| TimeZ::from_hms_nano_opt(hour, min, sec, nano)) + pub fn from_hms_micro_opt(hour: u32, min: u32, sec: u32, micro: u32) -> Option { + micro.checked_mul(&1_000) + .and_then(|nano| NaiveTime::from_hms_nano_opt(hour, min, sec, nano)) } - /// Makes a new `TimeZ` from hour, minute, second and nanosecond. + /// Makes a new `NaiveTime` from hour, minute, second and nanosecond. /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second. /// /// Fails on invalid hour, minute, second and/or nanosecond. #[inline] - pub fn from_hms_nano(hour: u32, min: u32, sec: u32, nano: u32) -> TimeZ { - TimeZ::from_hms_nano_opt(hour, min, sec, nano).expect("invalid time") + pub fn from_hms_nano(hour: u32, min: u32, sec: u32, nano: u32) -> NaiveTime { + NaiveTime::from_hms_nano_opt(hour, min, sec, nano).expect("invalid time") } - /// Makes a new `TimeZ` from hour, minute, second and nanosecond. + /// Makes a new `NaiveTime` from hour, minute, second and nanosecond. /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second. /// /// Returns `None` on invalid hour, minute, second and/or nanosecond. - pub fn from_hms_nano_opt(hour: u32, min: u32, sec: u32, nano: u32) -> Option { + pub fn from_hms_nano_opt(hour: u32, min: u32, sec: u32, nano: u32) -> Option { if hour >= 24 || min >= 60 || sec >= 60 || nano >= 2_000_000_000 { return None; } let secs = hour * 3600 + min * 60 + sec; - Some(TimeZ { secs: secs, frac: nano }) + Some(NaiveTime { secs: secs, frac: nano }) } /// Returns a triple of the hour, minute and second numbers. @@ -152,37 +153,37 @@ impl TimeZ { } } -impl Timelike for TimeZ { +impl Timelike for NaiveTime { #[inline] fn hour(&self) -> u32 { self.hms().val0() } #[inline] fn minute(&self) -> u32 { self.hms().val1() } #[inline] fn second(&self) -> u32 { self.hms().val2() } #[inline] fn nanosecond(&self) -> u32 { self.frac } #[inline] - fn with_hour(&self, hour: u32) -> Option { + fn with_hour(&self, hour: u32) -> Option { if hour >= 24 { return None; } let secs = hour * 3600 + self.secs % 3600; - Some(TimeZ { secs: secs, ..*self }) + Some(NaiveTime { secs: secs, ..*self }) } #[inline] - fn with_minute(&self, min: u32) -> Option { + fn with_minute(&self, min: u32) -> Option { if min >= 60 { return None; } let secs = self.secs / 3600 * 3600 + min * 60 + self.secs % 60; - Some(TimeZ { secs: secs, ..*self }) + Some(NaiveTime { secs: secs, ..*self }) } #[inline] - fn with_second(&self, sec: u32) -> Option { + fn with_second(&self, sec: u32) -> Option { if sec >= 60 { return None; } let secs = self.secs / 60 * 60 + sec; - Some(TimeZ { secs: secs, ..*self }) + Some(NaiveTime { secs: secs, ..*self }) } #[inline] - fn with_nanosecond(&self, nano: u32) -> Option { + fn with_nanosecond(&self, nano: u32) -> Option { if nano >= 2_000_000_000 { return None; } - Some(TimeZ { frac: nano, ..*self }) + Some(NaiveTime { frac: nano, ..*self }) } #[inline] @@ -191,8 +192,8 @@ impl Timelike for TimeZ { } } -impl Add for TimeZ { - fn add(&self, rhs: &Duration) -> TimeZ { +impl Add for NaiveTime { + fn add(&self, rhs: &Duration) -> NaiveTime { let (_, rhssecs, rhsnanos) = rhs.to_tuple(); let mut secs = self.secs + rhssecs; let mut nanos = self.frac + rhsnanos; @@ -204,20 +205,20 @@ impl Add for TimeZ { nanos -= maxnanos; secs += 1; } - TimeZ { secs: secs % 86400, frac: nanos } + NaiveTime { secs: secs % 86400, frac: nanos } } } /* // Rust issue #7590, the current coherence checker can't handle multiple Add impls -impl Add for Duration { +impl Add for Duration { #[inline] - fn add(&self, rhs: &TimeZ) -> TimeZ { rhs.add(self) } + fn add(&self, rhs: &NaiveTime) -> NaiveTime { rhs.add(self) } } */ -impl Sub for TimeZ { - fn sub(&self, rhs: &TimeZ) -> Duration { +impl Sub for NaiveTime { + fn sub(&self, rhs: &NaiveTime) -> Duration { // the number of whole non-leap seconds let secs = self.secs as i32 - rhs.secs as i32 - 1; @@ -233,7 +234,7 @@ impl Sub for TimeZ { } } -impl fmt::Show for TimeZ { +impl fmt::Show for NaiveTime { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let (hour, min, sec) = self.hms(); let (sec, nano) = if self.frac >= 1_000_000_000 { @@ -258,7 +259,7 @@ impl fmt::Show for TimeZ { /// ISO 8601 time with timezone. #[deriving(Clone)] pub struct Time { - time: TimeZ, + time: NaiveTime, offset: Off, } @@ -266,12 +267,12 @@ impl Time { /// Makes a new `Time` with given *UTC* time and offset. /// The local time should be constructed via the `Offset` trait. #[inline] - pub fn from_utc(time: TimeZ, offset: Off) -> Time { + pub fn from_utc(time: NaiveTime, offset: Off) -> Time { Time { time: time, offset: offset } } /// Returns a view to the local time. - fn local(&self) -> TimeZ { + fn local(&self) -> NaiveTime { self.offset.to_local_time(&self.time) } } @@ -363,67 +364,73 @@ impl fmt::Show for Time { #[cfg(test)] mod tests { - use super::{Timelike, TimeZ}; + use super::{Timelike, NaiveTime}; use duration::Duration; use std::u32; #[test] fn test_time_from_hms_milli() { - assert_eq!(TimeZ::from_hms_milli_opt(3, 5, 7, 0), - Some(TimeZ::from_hms_nano(3, 5, 7, 0))); - assert_eq!(TimeZ::from_hms_milli_opt(3, 5, 7, 777), - Some(TimeZ::from_hms_nano(3, 5, 7, 777_000_000))); - assert_eq!(TimeZ::from_hms_milli_opt(3, 5, 7, 1_999), - Some(TimeZ::from_hms_nano(3, 5, 7, 1_999_000_000))); - assert_eq!(TimeZ::from_hms_milli_opt(3, 5, 7, 2_000), None); - assert_eq!(TimeZ::from_hms_milli_opt(3, 5, 7, 5_000), None); // overflow check - assert_eq!(TimeZ::from_hms_milli_opt(3, 5, 7, u32::MAX), None); + assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, 0), + Some(NaiveTime::from_hms_nano(3, 5, 7, 0))); + assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, 777), + Some(NaiveTime::from_hms_nano(3, 5, 7, 777_000_000))); + assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, 1_999), + Some(NaiveTime::from_hms_nano(3, 5, 7, 1_999_000_000))); + assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, 2_000), None); + assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, 5_000), None); // overflow check + assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, u32::MAX), None); } #[test] fn test_time_from_hms_micro() { - assert_eq!(TimeZ::from_hms_micro_opt(3, 5, 7, 0), - Some(TimeZ::from_hms_nano(3, 5, 7, 0))); - assert_eq!(TimeZ::from_hms_micro_opt(3, 5, 7, 333), - Some(TimeZ::from_hms_nano(3, 5, 7, 333_000))); - assert_eq!(TimeZ::from_hms_micro_opt(3, 5, 7, 777_777), - Some(TimeZ::from_hms_nano(3, 5, 7, 777_777_000))); - assert_eq!(TimeZ::from_hms_micro_opt(3, 5, 7, 1_999_999), - Some(TimeZ::from_hms_nano(3, 5, 7, 1_999_999_000))); - assert_eq!(TimeZ::from_hms_micro_opt(3, 5, 7, 2_000_000), None); - assert_eq!(TimeZ::from_hms_micro_opt(3, 5, 7, 5_000_000), None); // overflow check - assert_eq!(TimeZ::from_hms_micro_opt(3, 5, 7, u32::MAX), None); + assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 0), + Some(NaiveTime::from_hms_nano(3, 5, 7, 0))); + assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 333), + Some(NaiveTime::from_hms_nano(3, 5, 7, 333_000))); + assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 777_777), + Some(NaiveTime::from_hms_nano(3, 5, 7, 777_777_000))); + assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 1_999_999), + Some(NaiveTime::from_hms_nano(3, 5, 7, 1_999_999_000))); + assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 2_000_000), None); + assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 5_000_000), None); // overflow check + assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, u32::MAX), None); } #[test] fn test_time_hms() { - assert_eq!(TimeZ::from_hms(3, 5, 7).hour(), 3); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_hour(0), Some(TimeZ::from_hms(0, 5, 7))); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_hour(23), Some(TimeZ::from_hms(23, 5, 7))); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_hour(24), None); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_hour(u32::MAX), None); + assert_eq!(NaiveTime::from_hms(3, 5, 7).hour(), 3); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(0), + Some(NaiveTime::from_hms(0, 5, 7))); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(23), + Some(NaiveTime::from_hms(23, 5, 7))); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(24), None); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(u32::MAX), None); - assert_eq!(TimeZ::from_hms(3, 5, 7).minute(), 5); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_minute(0), Some(TimeZ::from_hms(3, 0, 7))); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_minute(59), Some(TimeZ::from_hms(3, 59, 7))); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_minute(60), None); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_minute(u32::MAX), None); + assert_eq!(NaiveTime::from_hms(3, 5, 7).minute(), 5); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_minute(0), + Some(NaiveTime::from_hms(3, 0, 7))); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_minute(59), + Some(NaiveTime::from_hms(3, 59, 7))); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_minute(60), None); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_minute(u32::MAX), None); - assert_eq!(TimeZ::from_hms(3, 5, 7).second(), 7); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_second(0), Some(TimeZ::from_hms(3, 5, 0))); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_second(59), Some(TimeZ::from_hms(3, 5, 59))); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_second(60), None); - assert_eq!(TimeZ::from_hms(3, 5, 7).with_second(u32::MAX), None); + assert_eq!(NaiveTime::from_hms(3, 5, 7).second(), 7); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_second(0), + Some(NaiveTime::from_hms(3, 5, 0))); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_second(59), + Some(NaiveTime::from_hms(3, 5, 59))); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_second(60), None); + assert_eq!(NaiveTime::from_hms(3, 5, 7).with_second(u32::MAX), None); } #[test] fn test_time_add() { - fn check(lhs: TimeZ, rhs: Duration, sum: TimeZ) { + fn check(lhs: NaiveTime, rhs: Duration, sum: NaiveTime) { assert_eq!(lhs + rhs, sum); //assert_eq!(rhs + lhs, sum); } - let hmsm = |h,m,s,mi| TimeZ::from_hms_milli(h, m, s, mi); + let hmsm = |h,m,s,mi| NaiveTime::from_hms_milli(h, m, s, mi); check(hmsm(3, 5, 7, 900), Duration::zero(), hmsm(3, 5, 7, 900)); check(hmsm(3, 5, 7, 900), Duration::milliseconds(100), hmsm(3, 5, 8, 0)); @@ -435,13 +442,13 @@ mod tests { #[test] fn test_time_sub() { - fn check(lhs: TimeZ, rhs: TimeZ, diff: Duration) { + fn check(lhs: NaiveTime, rhs: NaiveTime, diff: Duration) { // `time1 - time2 = duration` is equivalent to `time2 - time1 = -duration` assert_eq!(lhs - rhs, diff); assert_eq!(rhs - lhs, -diff); } - let hmsm = |h,m,s,mi| TimeZ::from_hms_milli(h, m, s, mi); + let hmsm = |h,m,s,mi| NaiveTime::from_hms_milli(h, m, s, mi); check(hmsm(3, 5, 7, 900), hmsm(3, 5, 7, 900), Duration::zero()); check(hmsm(3, 5, 7, 900), hmsm(3, 5, 7, 600), Duration::milliseconds(300)); @@ -463,19 +470,19 @@ mod tests { #[test] fn test_time_fmt() { - assert_eq!(TimeZ::from_hms_milli(23, 59, 59, 999).to_string(), + assert_eq!(NaiveTime::from_hms_milli(23, 59, 59, 999).to_string(), "23:59:59,999".to_string()); - assert_eq!(TimeZ::from_hms_milli(23, 59, 59, 1_000).to_string(), + assert_eq!(NaiveTime::from_hms_milli(23, 59, 59, 1_000).to_string(), "23:59:60".to_string()); - assert_eq!(TimeZ::from_hms_milli(23, 59, 59, 1_001).to_string(), + assert_eq!(NaiveTime::from_hms_milli(23, 59, 59, 1_001).to_string(), "23:59:60,001".to_string()); - assert_eq!(TimeZ::from_hms_micro(0, 0, 0, 43210).to_string(), + assert_eq!(NaiveTime::from_hms_micro(0, 0, 0, 43210).to_string(), "00:00:00,043210".to_string()); - assert_eq!(TimeZ::from_hms_nano(0, 0, 0, 6543210).to_string(), + assert_eq!(NaiveTime::from_hms_nano(0, 0, 0, 6543210).to_string(), "00:00:00,006543210".to_string()); - // the format specifier should have no effect on `TimeZ` - assert_eq!(format!("{:30}", TimeZ::from_hms_milli(3, 5, 7, 9)), + // the format specifier should have no effect on `NaiveTime` + assert_eq!(format!("{:30}", NaiveTime::from_hms_milli(3, 5, 7, 9)), "03:05:07,009".to_string()); } }