chrono/src/date.rs

374 lines
14 KiB
Rust
Raw Normal View History

// This is a part of Chrono.
2014-04-01 17:14:57 +00:00
// See README.md and LICENSE.txt for details.
//! ISO 8601 calendar date with time zone.
2014-03-28 11:38:11 +00:00
use std::{fmt, hash};
use std::cmp::Ordering;
use std::ops::{Add, Sub};
use oldtime::Duration as OldDuration;
use {Weekday, Datelike};
Flattened intermediate implementation modules. There used to be multiple modules like `chrono::datetime` which only provide a single type `DateTime`. In retrospect, this module structure never reflected how people use those types; with the release of 0.3.0 `chrono::prelude` is a preferred way to glob-import types, and due to reexports `chrono::DateTime` and likes are also common enough. Therefore this commit removes those implementation modules and flattens the module structure. Specifically: Before After ---------------------------------- ---------------------------- chrono::date::Date chrono::Date chrono::date::MIN chrono::MIN_DATE chrono::date::MAX chrono::MAX_DATE chrono::datetime::DateTime chrono::DateTime chrono::datetime::TsSeconds chrono::TsSeconds chrono::datetime::serde::* chrono::serde::* chrono::naive::time::NaiveTime chrono::naive::NaiveTime chrono::naive::date::NaiveDate chrono::naive::NaiveDate chrono::naive::date::MIN chrono::naive::MIN_DATE chrono::naive::date::MAX chrono::naive::MAX_DATE chrono::naive::datetime::NaiveDateTime chrono::naive::NaiveDateTime chrono::naive::datetime::TsSeconds chrono::naive::TsSeconds chrono::naive::datetime::serde::* chrono::naive::serde::* chrono::offset::utc::UTC chrono::offset::UTC chrono::offset::fixed::FixedOffset chrono::offset::FixedOffset chrono::offset::local::Local chrono::offset::Local chrono::format::parsed::Parsed chrono::format::Parsed All internal documentation links have been updated (phew!) and verified with LinkChecker [1]. Probably we can automate this check in the future. [1] https://wummel.github.io/linkchecker/ Closes #161. Compared to the original proposal, `chrono::naive` is retained as we had `TsSeconds` types duplicated for `NaiveDateTime` and `DateTime` (legitimately).
2017-06-21 05:03:49 +00:00
use offset::{TimeZone, UTC};
use naive::{self, NaiveDate, NaiveTime};
use DateTime;
use format::{Item, DelayedFormat, StrftimeItems};
2014-03-28 11:38:11 +00:00
/// ISO 8601 calendar date with time zone.
///
/// This type should be considered ambiguous at best,
/// due to the inherent lack of precision required for the time zone resolution.
/// For serialization and deserialization uses, it is best to use `NaiveDate` instead.
/// There are some guarantees on the usage of `Date<Tz>`:
///
/// - If properly constructed via `TimeZone::ymd` and others without an error,
/// the corresponding local date should exist for at least a moment.
/// (It may still have a gap from the offset changes.)
///
/// - The `TimeZone` is free to assign *any* `Offset` to the local date,
/// as long as that offset did occur in given day.
/// For example, if `2015-03-08T01:59-08:00` is followed by `2015-03-08T03:00-07:00`,
/// it may produce either `2015-03-08-08:00` or `2015-03-08-07:00`
/// but *not* `2015-03-08+00:00` and others.
///
/// - Once constructed as a full `DateTime`,
/// `DateTime::date` and other associated methods should return those for the original `Date`.
/// For example, if `dt = tz.ymd(y,m,d).hms(h,n,s)` were valid, `dt.date() == tz.ymd(y,m,d)`.
///
/// - The date is timezone-agnostic up to one day (i.e. practically always),
/// so the local date and UTC date should be equal for most cases
/// even though the raw calculation between `NaiveDate` and `Duration` may not.
#[derive(Clone)]
pub struct Date<Tz: TimeZone> {
date: NaiveDate,
offset: Tz::Offset,
2014-07-29 06:41:07 +00:00
}
/// The minimum possible `Date`.
Flattened intermediate implementation modules. There used to be multiple modules like `chrono::datetime` which only provide a single type `DateTime`. In retrospect, this module structure never reflected how people use those types; with the release of 0.3.0 `chrono::prelude` is a preferred way to glob-import types, and due to reexports `chrono::DateTime` and likes are also common enough. Therefore this commit removes those implementation modules and flattens the module structure. Specifically: Before After ---------------------------------- ---------------------------- chrono::date::Date chrono::Date chrono::date::MIN chrono::MIN_DATE chrono::date::MAX chrono::MAX_DATE chrono::datetime::DateTime chrono::DateTime chrono::datetime::TsSeconds chrono::TsSeconds chrono::datetime::serde::* chrono::serde::* chrono::naive::time::NaiveTime chrono::naive::NaiveTime chrono::naive::date::NaiveDate chrono::naive::NaiveDate chrono::naive::date::MIN chrono::naive::MIN_DATE chrono::naive::date::MAX chrono::naive::MAX_DATE chrono::naive::datetime::NaiveDateTime chrono::naive::NaiveDateTime chrono::naive::datetime::TsSeconds chrono::naive::TsSeconds chrono::naive::datetime::serde::* chrono::naive::serde::* chrono::offset::utc::UTC chrono::offset::UTC chrono::offset::fixed::FixedOffset chrono::offset::FixedOffset chrono::offset::local::Local chrono::offset::Local chrono::format::parsed::Parsed chrono::format::Parsed All internal documentation links have been updated (phew!) and verified with LinkChecker [1]. Probably we can automate this check in the future. [1] https://wummel.github.io/linkchecker/ Closes #161. Compared to the original proposal, `chrono::naive` is retained as we had `TsSeconds` types duplicated for `NaiveDateTime` and `DateTime` (legitimately).
2017-06-21 05:03:49 +00:00
pub const MIN_DATE: Date<UTC> = Date { date: naive::MIN_DATE, offset: UTC };
2014-07-29 06:41:07 +00:00
/// The maximum possible `Date`.
Flattened intermediate implementation modules. There used to be multiple modules like `chrono::datetime` which only provide a single type `DateTime`. In retrospect, this module structure never reflected how people use those types; with the release of 0.3.0 `chrono::prelude` is a preferred way to glob-import types, and due to reexports `chrono::DateTime` and likes are also common enough. Therefore this commit removes those implementation modules and flattens the module structure. Specifically: Before After ---------------------------------- ---------------------------- chrono::date::Date chrono::Date chrono::date::MIN chrono::MIN_DATE chrono::date::MAX chrono::MAX_DATE chrono::datetime::DateTime chrono::DateTime chrono::datetime::TsSeconds chrono::TsSeconds chrono::datetime::serde::* chrono::serde::* chrono::naive::time::NaiveTime chrono::naive::NaiveTime chrono::naive::date::NaiveDate chrono::naive::NaiveDate chrono::naive::date::MIN chrono::naive::MIN_DATE chrono::naive::date::MAX chrono::naive::MAX_DATE chrono::naive::datetime::NaiveDateTime chrono::naive::NaiveDateTime chrono::naive::datetime::TsSeconds chrono::naive::TsSeconds chrono::naive::datetime::serde::* chrono::naive::serde::* chrono::offset::utc::UTC chrono::offset::UTC chrono::offset::fixed::FixedOffset chrono::offset::FixedOffset chrono::offset::local::Local chrono::offset::Local chrono::format::parsed::Parsed chrono::format::Parsed All internal documentation links have been updated (phew!) and verified with LinkChecker [1]. Probably we can automate this check in the future. [1] https://wummel.github.io/linkchecker/ Closes #161. Compared to the original proposal, `chrono::naive` is retained as we had `TsSeconds` types duplicated for `NaiveDateTime` and `DateTime` (legitimately).
2017-06-21 05:03:49 +00:00
pub const MAX_DATE: Date<UTC> = Date { date: naive::MAX_DATE, offset: UTC };
2014-07-29 06:41:07 +00:00
impl<Tz: TimeZone> Date<Tz> {
2014-07-29 06:41:07 +00:00
/// Makes a new `Date` with given *UTC* date and offset.
/// The local date should be constructed via the `TimeZone` trait.
//
// note: this constructor is purposedly not named to `new` to discourage the direct usage.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn from_utc(date: NaiveDate, offset: Tz::Offset) -> Date<Tz> {
2014-07-29 06:41:07 +00:00
Date { date: date, offset: offset }
}
/// Makes a new `DateTime` from the current date and given `NaiveTime`.
2014-07-29 06:41:07 +00:00
/// The offset in the current date is preserved.
///
/// Panics on invalid datetime.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn and_time(&self, time: NaiveTime) -> Option<DateTime<Tz>> {
let localdt = self.naive_local().and_time(time);
self.timezone().from_local_datetime(&localdt).single()
2014-07-29 06:41:07 +00:00
}
/// Makes a new `DateTime` from the current date, hour, minute and second.
2014-07-29 06:41:07 +00:00
/// The offset in the current date is preserved.
///
/// Panics on invalid hour, minute and/or second.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> DateTime<Tz> {
2014-07-29 06:41:07 +00:00
self.and_hms_opt(hour, min, sec).expect("invalid time")
}
/// Makes a new `DateTime` from the current date, hour, minute and second.
2014-07-29 06:41:07 +00:00
/// 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<DateTime<Tz>> {
NaiveTime::from_hms_opt(hour, min, sec).and_then(|time| self.and_time(time))
2014-07-29 06:41:07 +00:00
}
/// Makes a new `DateTime` from the current date, hour, minute, second and millisecond.
2014-07-29 06:41:07 +00:00
/// The millisecond part can exceed 1,000 in order to represent the leap second.
/// The offset in the current date is preserved.
///
/// Panics on invalid hour, minute, second and/or millisecond.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn and_hms_milli(&self, hour: u32, min: u32, sec: u32, milli: u32) -> DateTime<Tz> {
2014-07-29 06:41:07 +00:00
self.and_hms_milli_opt(hour, min, sec, milli).expect("invalid time")
}
/// Makes a new `DateTime` from the current date, hour, minute, second and millisecond.
2014-07-29 06:41:07 +00:00
/// The millisecond part can exceed 1,000 in order to represent the leap second.
/// The offset in the current date is preserved.
///
/// 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<DateTime<Tz>> {
NaiveTime::from_hms_milli_opt(hour, min, sec, milli).and_then(|time| self.and_time(time))
2014-07-29 06:41:07 +00:00
}
/// Makes a new `DateTime` from the current date, hour, minute, second and microsecond.
2014-07-29 06:41:07 +00:00
/// The microsecond part can exceed 1,000,000 in order to represent the leap second.
/// The offset in the current date is preserved.
///
/// Panics on invalid hour, minute, second and/or microsecond.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn and_hms_micro(&self, hour: u32, min: u32, sec: u32, micro: u32) -> DateTime<Tz> {
2014-07-29 06:41:07 +00:00
self.and_hms_micro_opt(hour, min, sec, micro).expect("invalid time")
}
/// Makes a new `DateTime` from the current date, hour, minute, second and microsecond.
2014-07-29 06:41:07 +00:00
/// The microsecond part can exceed 1,000,000 in order to represent the leap second.
/// The offset in the current date is preserved.
///
/// 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<DateTime<Tz>> {
NaiveTime::from_hms_micro_opt(hour, min, sec, micro).and_then(|time| self.and_time(time))
2014-07-29 06:41:07 +00:00
}
/// Makes a new `DateTime` from the current date, hour, minute, second and nanosecond.
2014-07-29 06:41:07 +00:00
/// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
/// The offset in the current date is preserved.
///
/// Panics on invalid hour, minute, second and/or nanosecond.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn and_hms_nano(&self, hour: u32, min: u32, sec: u32, nano: u32) -> DateTime<Tz> {
2014-07-29 06:41:07 +00:00
self.and_hms_nano_opt(hour, min, sec, nano).expect("invalid time")
}
/// Makes a new `DateTime` from the current date, hour, minute, second and nanosecond.
2014-07-29 06:41:07 +00:00
/// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
/// The offset in the current date is preserved.
///
/// 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<DateTime<Tz>> {
NaiveTime::from_hms_nano_opt(hour, min, sec, nano).and_then(|time| self.and_time(time))
2014-07-29 06:41:07 +00:00
}
/// Makes a new `Date` for the next date.
///
/// Panics when `self` is the last representable date.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn succ(&self) -> Date<Tz> {
2014-07-29 06:41:07 +00:00
self.succ_opt().expect("out of bound")
}
/// Makes a new `Date` for the next date.
///
/// Returns `None` when `self` is the last representable date.
#[inline]
pub fn succ_opt(&self) -> Option<Date<Tz>> {
2014-07-29 06:41:07 +00:00
self.date.succ_opt().map(|date| Date::from_utc(date, self.offset.clone()))
}
/// Makes a new `Date` for the prior date.
///
/// Panics when `self` is the first representable date.
2014-07-29 06:41:07 +00:00
#[inline]
pub fn pred(&self) -> Date<Tz> {
2014-07-29 06:41:07 +00:00
self.pred_opt().expect("out of bound")
}
/// Makes a new `Date` for the prior date.
///
/// Returns `None` when `self` is the first representable date.
#[inline]
pub fn pred_opt(&self) -> Option<Date<Tz>> {
2014-07-29 06:41:07 +00:00
self.date.pred_opt().map(|date| Date::from_utc(date, self.offset.clone()))
}
/// Retrieves an associated offset from UTC.
#[inline]
pub fn offset<'a>(&'a self) -> &'a 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 `Date` (but will change the string representation).
#[inline]
pub fn with_timezone<Tz2: TimeZone>(&self, tz: &Tz2) -> Date<Tz2> {
tz.from_utc_date(&self.date)
}
/// Adds given `Duration` to the current date.
///
/// Returns `None` when it will result in overflow.
#[inline]
pub fn checked_add_signed(self, rhs: OldDuration) -> Option<Date<Tz>> {
let date = try_opt!(self.date.checked_add_signed(rhs));
Some(Date { date: date, offset: self.offset })
}
/// Subtracts given `Duration` from the current date.
///
/// Returns `None` when it will result in overflow.
#[inline]
pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<Date<Tz>> {
let date = try_opt!(self.date.checked_sub_signed(rhs));
Some(Date { date: date, offset: self.offset })
}
/// Subtracts another `Date` from the current date.
/// Returns a `Duration` of integral numbers.
///
/// This does not overflow or underflow at all,
/// as all possible output fits in the range of `Duration`.
#[inline]
pub fn signed_duration_since<Tz2: TimeZone>(self, rhs: Date<Tz2>) -> OldDuration {
self.date.signed_duration_since(rhs.date)
}
/// Returns a view to the naive UTC date.
#[inline]
pub fn naive_utc(&self) -> NaiveDate {
self.date
}
/// Returns a view to the naive local date.
`FixedOffset` is now the official "fixed offset value" type. This may sound strange, but the final type for the offset "value" was originally `time::Duration` (returned by `Offset::local_minus_utc`). This caused a lot of problems becaus adding `Duration` fully interacts with leap seconds and `Duration` itself is somewhat deprecated. This commit entirely replaces this role of `Duration` with `FixedOffset`. So if we had `Offset` and `Duration` to represent the "storage" offset type and the offset "value" in the past, we now have `Offset` and `FixedOffset`. Storage-to-value conversion is called to "fix" the offset---an apt term for the type. The list of actual changes: - The time zone offset is now restricted to UTC-23:59:59 through UTC+23:59:59, and no subsecond value is allowed. As described above, `FixedOffset` is now fully used for this purpose. - One can now add and subtract `FixedOffset` to/from timelike values. Replaces a temporary `chrono::offset::add_with_leapsecond` function. Datelike & non-timelike values are never affected by the offset. - UTC and local views to `Date<Tz>` are now identical. We keep relevant methods for the consistency right now. - `chrono::format::format` now receives `FixedOffset` in place of `(Old)Duration`. - `Offset` now has a `fix` method to resolve, or to "fix" the "storage" offset (`Offset`) to the offset "value" (`FixedOffset`). - `FixedOffset::{local_minus_utc, utc_minus_local}` methods are added. They no longer depend on `Duration` as well.
2017-02-06 18:43:59 +00:00
///
/// This is technically same to [`naive_utc`](#method.naive_utc)
/// because the offset is restricted to never exceed one day,
/// but provided for the consistency.
#[inline]
pub fn naive_local(&self) -> NaiveDate {
`FixedOffset` is now the official "fixed offset value" type. This may sound strange, but the final type for the offset "value" was originally `time::Duration` (returned by `Offset::local_minus_utc`). This caused a lot of problems becaus adding `Duration` fully interacts with leap seconds and `Duration` itself is somewhat deprecated. This commit entirely replaces this role of `Duration` with `FixedOffset`. So if we had `Offset` and `Duration` to represent the "storage" offset type and the offset "value" in the past, we now have `Offset` and `FixedOffset`. Storage-to-value conversion is called to "fix" the offset---an apt term for the type. The list of actual changes: - The time zone offset is now restricted to UTC-23:59:59 through UTC+23:59:59, and no subsecond value is allowed. As described above, `FixedOffset` is now fully used for this purpose. - One can now add and subtract `FixedOffset` to/from timelike values. Replaces a temporary `chrono::offset::add_with_leapsecond` function. Datelike & non-timelike values are never affected by the offset. - UTC and local views to `Date<Tz>` are now identical. We keep relevant methods for the consistency right now. - `chrono::format::format` now receives `FixedOffset` in place of `(Old)Duration`. - `Offset` now has a `fix` method to resolve, or to "fix" the "storage" offset (`Offset`) to the offset "value" (`FixedOffset`). - `FixedOffset::{local_minus_utc, utc_minus_local}` methods are added. They no longer depend on `Duration` as well.
2017-02-06 18:43:59 +00:00
self.date
}
}
/// Maps the local date to other date with given conversion function.
fn map_local<Tz: TimeZone, F>(d: &Date<Tz>, mut f: F) -> Option<Date<Tz>>
where F: FnMut(NaiveDate) -> Option<NaiveDate> {
f(d.naive_local()).and_then(|date| d.timezone().from_local_date(&date).single())
}
impl<Tz: TimeZone> Date<Tz> where Tz::Offset: fmt::Display {
/// Formats the date with the specified formatting items.
#[inline]
pub fn format_with_items<'a, I>(&self, items: I) -> DelayedFormat<I>
where I: Iterator<Item=Item<'a>> + Clone {
2015-02-18 16:48:29 +00:00
DelayedFormat::new_with_offset(Some(self.naive_local()), None, &self.offset, items)
}
/// Formats the date with the specified format string.
/// See the [`format::strftime` module](../format/strftime/index.html)
/// on the supported escape sequences.
#[inline]
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
self.format_with_items(StrftimeItems::new(fmt))
}
2014-07-29 06:41:07 +00:00
}
impl<Tz: TimeZone> Datelike for Date<Tz> {
#[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 isoweekdate(&self) -> (i32, u32, Weekday) { self.naive_local().isoweekdate() }
2014-07-29 06:41:07 +00:00
#[inline]
fn with_year(&self, year: i32) -> Option<Date<Tz>> {
map_local(self, |date| date.with_year(year))
2014-07-29 06:41:07 +00:00
}
#[inline]
fn with_month(&self, month: u32) -> Option<Date<Tz>> {
map_local(self, |date| date.with_month(month))
2014-07-29 06:41:07 +00:00
}
#[inline]
fn with_month0(&self, month0: u32) -> Option<Date<Tz>> {
map_local(self, |date| date.with_month0(month0))
2014-07-29 06:41:07 +00:00
}
#[inline]
fn with_day(&self, day: u32) -> Option<Date<Tz>> {
map_local(self, |date| date.with_day(day))
2014-07-29 06:41:07 +00:00
}
#[inline]
fn with_day0(&self, day0: u32) -> Option<Date<Tz>> {
map_local(self, |date| date.with_day0(day0))
2014-07-29 06:41:07 +00:00
}
#[inline]
fn with_ordinal(&self, ordinal: u32) -> Option<Date<Tz>> {
map_local(self, |date| date.with_ordinal(ordinal))
2014-07-29 06:41:07 +00:00
}
#[inline]
fn with_ordinal0(&self, ordinal0: u32) -> Option<Date<Tz>> {
map_local(self, |date| date.with_ordinal0(ordinal0))
2014-07-29 06:41:07 +00:00
}
}
// we need them as automatic impls cannot handle associated types
impl<Tz: TimeZone> Copy for Date<Tz> where <Tz as TimeZone>::Offset: Copy {}
unsafe impl<Tz: TimeZone> Send for Date<Tz> where <Tz as TimeZone>::Offset: Send {}
impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<Date<Tz2>> for Date<Tz> {
fn eq(&self, other: &Date<Tz2>) -> bool { self.date == other.date }
2014-07-29 06:41:07 +00:00
}
impl<Tz: TimeZone> Eq for Date<Tz> {
2014-07-29 06:41:07 +00:00
}
impl<Tz: TimeZone> PartialOrd for Date<Tz> {
fn partial_cmp(&self, other: &Date<Tz>) -> Option<Ordering> {
2014-07-29 06:41:07 +00:00
self.date.partial_cmp(&other.date)
}
}
impl<Tz: TimeZone> Ord for Date<Tz> {
fn cmp(&self, other: &Date<Tz>) -> Ordering { self.date.cmp(&other.date) }
2014-07-29 06:41:07 +00:00
}
impl<Tz: TimeZone> hash::Hash for Date<Tz> {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.date.hash(state) }
2014-07-29 06:41:07 +00:00
}
impl<Tz: TimeZone> Add<OldDuration> for Date<Tz> {
type Output = Date<Tz>;
#[inline]
fn add(self, rhs: OldDuration) -> Date<Tz> {
self.checked_add_signed(rhs).expect("`Date + Duration` overflowed")
2014-07-29 06:41:07 +00:00
}
}
impl<Tz: TimeZone> Sub<OldDuration> for Date<Tz> {
type Output = Date<Tz>;
#[inline]
fn sub(self, rhs: OldDuration) -> Date<Tz> {
self.checked_sub_signed(rhs).expect("`Date - Duration` overflowed")
}
}
impl<Tz: TimeZone> fmt::Debug for Date<Tz> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?}{:?}", self.naive_local(), self.offset)
}
}
impl<Tz: TimeZone> fmt::Display for Date<Tz> where Tz::Offset: fmt::Display {
2014-07-29 06:41:07 +00:00
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}{}", self.naive_local(), self.offset)
2014-07-29 06:41:07 +00:00
}
}