xeos
/
chrono
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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                  chrono::Date
    chrono:πŸ“…:MIN                   chrono::MIN_DATE
    chrono:πŸ“…: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:πŸ“…:NaiveDate      chrono::naive::NaiveDate
    chrono::naive:πŸ“…:MIN            chrono::naive::MIN_DATE
    chrono::naive:πŸ“…: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).
This commit is contained in:
Kang Seonghoon 2017-06-21 14:03:49 +09:00
parent 4be3962e31
commit c06bc01f0b
No known key found for this signature in database
GPG Key ID: 82440FABA6709020
15 changed files with 461 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AUTHORS.txt
View File

@ -7,6 +7,7 @@ Ashley Mannix <ashleymannix@live.com.au>
Ben Boeckel <mathstuf@gmail.com>
Ben Eills <ben@beneills.com>
Brandon W Maister <bwm@knewton.com>
Brandon W Maister <quodlibetor@gmail.com>
Colin Ray <r.colinray@gmail.com>
Corey Farwell <coreyf@rwell.org>
Dan <dan@ebip.co.uk>
@ -19,6 +20,7 @@ Eric Findlay <e.findlay@protonmail.ch>
Eunchong Yu <kroisse@gmail.com>
Frans Skarman <frans.skarman@gmail.com>
Huon Wilson <dbau.pp+github@gmail.com>
Igor Gnatenko <ignatenko@redhat.com>
Jim Turner <jturner314@gmail.com>
Jisoo Park <xxxyel@gmail.com>
Joe Wilm <joe@jwilm.com>

44
README.md
View File

@ -90,7 +90,7 @@ methods.
### Date and Time
Chrono provides a
[**`DateTime`**](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html)
[**`DateTime`**](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html)
type to represent a date and a time in a timezone.
For more abstract moment-in-time tracking such as internal timekeeping
@ -105,11 +105,11 @@ the [**`TimeZone`**](https://docs.rs/chrono/0.4.0/chrono/offset/trait.TimeZone.h
which defines how the local date is converted to and back from the UTC date.
There are three well-known `TimeZone` implementations:
* [**`UTC`**](https://docs.rs/chrono/0.4.0/chrono/offset/utc/struct.UTC.html) specifies the UTC time zone. It is most efficient.
* [**`UTC`**](https://docs.rs/chrono/0.4.0/chrono/offset/struct.UTC.html) specifies the UTC time zone. It is most efficient.
* [**`Local`**](https://docs.rs/chrono/0.4.0/chrono/offset/local/struct.Local.html) specifies the system local time zone.
* [**`Local`**](https://docs.rs/chrono/0.4.0/chrono/offset/struct.Local.html) specifies the system local time zone.
* [**`FixedOffset`**](https://docs.rs/chrono/0.4.0/chrono/offset/fixed/struct.FixedOffset.html) specifies
* [**`FixedOffset`**](https://docs.rs/chrono/0.4.0/chrono/offset/struct.FixedOffset.html) specifies
an arbitrary, fixed time zone such as UTC+09:00 or UTC-10:30.
This often results from the parsed textual date and time.
Since it stores the most information and does not depend on the system environment,
@ -117,12 +117,12 @@ There are three well-known `TimeZone` implementations:
`DateTime`s with different `TimeZone` types are distinct and do not mix,
but can be converted to each other using
the [`DateTime::with_timezone`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.with_timezone) method.
the [`DateTime::with_timezone`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.with_timezone) method.
You can get the current date and time in the UTC time zone
([`UTC::now()`](https://docs.rs/chrono/0.4.0/chrono/offset/utc/struct.UTC.html#method.now))
([`UTC::now()`](https://docs.rs/chrono/0.4.0/chrono/offset/struct.UTC.html#method.now))
or in the local time zone
([`Local::now()`](https://docs.rs/chrono/0.4.0/chrono/offset/local/struct.Local.html#method.now)).
([`Local::now()`](https://docs.rs/chrono/0.4.0/chrono/offset/struct.Local.html#method.now)).
```rust
use chrono::prelude::*;
@ -205,14 +205,14 @@ assert_eq!(UTC.ymd(1970, 1, 1).and_hms(0, 0, 0) - Duration::seconds(1_000_000_00
UTC.ymd(1938, 4, 24).and_hms(22, 13, 20));
```
Formatting is done via the [`format`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.format) method,
Formatting is done via the [`format`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.format) method,
which format is equivalent to the familiar `strftime` format.
(See the [`format::strftime` module documentation](https://docs.rs/chrono/0.4.0/chrono/format/strftime/index.html#specifiers)
for full syntax.)
The default `to_string` method and `{:?}` specifier also give a reasonable representation.
Chrono also provides [`to_rfc2822`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.to_rfc2822) and
[`to_rfc3339`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.to_rfc3339) methods
Chrono also provides [`to_rfc2822`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.to_rfc2822) and
[`to_rfc3339`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.to_rfc3339) methods
for well-known formats.
```rust
@ -238,13 +238,13 @@ Parsing can be done with three methods:
([`std::fmt::Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html))
format specifier prints, and requires the offset to be present.
2. [`DateTime::parse_from_str`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.parse_from_str) parses
2. [`DateTime::parse_from_str`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.parse_from_str) parses
a date and time with offsets and returns `DateTime<FixedOffset>`.
This should be used when the offset is a part of input and the caller cannot guess that.
It *cannot* be used when the offset can be missing.
[`DateTime::parse_from_rfc2822`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.parse_from_rfc2822)
[`DateTime::parse_from_rfc2822`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.parse_from_rfc2822)
and
[`DateTime::parse_from_rfc3339`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.parse_from_rfc3339)
[`DateTime::parse_from_rfc3339`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.parse_from_rfc3339)
are similar but for well-known formats.
3. [`Offset::datetime_from_str`](https://docs.rs/chrono/0.4.0/chrono/offset/trait.TimeZone.html#method.datetime_from_str) is
@ -288,7 +288,7 @@ assert!(UTC.datetime_from_str("Sat Nov 28 12:00:09 2014", "%a %b %e %T %Y").is_e
### Individual date
Chrono also provides an individual date type ([**`Date`**](https://docs.rs/chrono/0.4.0/chrono/date/struct.Date.html)).
Chrono also provides an individual date type ([**`Date`**](https://docs.rs/chrono/0.4.0/chrono/struct.Date.html)).
It also has time zones attached, and have to be constructed via time zones.
Most operations available to `DateTime` are also available to `Date` whenever appropriate.
@ -307,26 +307,26 @@ assert_eq!(UTC.ymd(2014, 11, 28).and_hms_milli(7, 8, 9, 10).format("%H%M%S").to_
There is no timezone-aware `Time` due to the lack of usefulness and also the complexity.
`DateTime` has [`date`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.date) method
`DateTime` has [`date`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.date) method
which returns a `Date` which represents its date component.
There is also a [`time`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.time) method,
There is also a [`time`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.time) method,
which simply returns a naive local time described below.
### Naive date and time
Chrono provides naive counterparts to `Date`, (non-existent) `Time` and `DateTime`
as [**`NaiveDate`**](https://docs.rs/chrono/0.4.0/chrono/naive/date/struct.NaiveDate.html),
[**`NaiveTime`**](https://docs.rs/chrono/0.4.0/chrono/naive/time/struct.NaiveTime.html) and
[**`NaiveDateTime`**](https://docs.rs/chrono/0.4.0/chrono/naive/datetime/struct.NaiveDateTime.html) respectively.
as [**`NaiveDate`**](https://docs.rs/chrono/0.4.0/chrono/naive/struct.NaiveDate.html),
[**`NaiveTime`**](https://docs.rs/chrono/0.4.0/chrono/naive/struct.NaiveTime.html) and
[**`NaiveDateTime`**](https://docs.rs/chrono/0.4.0/chrono/naive/struct.NaiveDateTime.html) respectively.
They have almost equivalent interfaces as their timezone-aware twins,
but are not associated to time zones obviously and can be quite low-level.
They are mostly useful for building blocks for higher-level types.
Timezone-aware `DateTime` and `Date` types have two methods returning naive versions:
[`naive_local`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.naive_local) returns
[`naive_local`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.naive_local) returns
a view to the naive local time,
and [`naive_utc`](https://docs.rs/chrono/0.4.0/chrono/datetime/struct.DateTime.html#method.naive_utc) returns
and [`naive_utc`](https://docs.rs/chrono/0.4.0/chrono/struct.DateTime.html#method.naive_utc) returns
a view to the naive UTC time.
## Limitations
@ -338,7 +338,7 @@ Date types are limited in about +/- 262,000 years from the common epoch.
Time types are limited in the nanosecond accuracy.
[Leap seconds are supported in the representation but
Chrono doesn't try to make use of them](https://docs.rs/chrono/0.4.0/chrono/naive/time/index.html#leap-second-handling).
Chrono doesn't try to make use of them](https://docs.rs/chrono/0.4.0/chrono/naive/struct.NaiveTime.html#leap-second-handling).
(The main reason is that leap seconds are not really predictable.)
Almost *every* operation over the possible leap seconds will ignore them.
Consider using `NaiveDateTime` with the implicit TAI (International Atomic Time) scale

13
src/date.rs
View File

@ -9,12 +9,9 @@ use std::ops::{Add, Sub};
use oldtime::Duration as OldDuration;
use {Weekday, Datelike};
use offset::TimeZone;
use offset::utc::UTC;
use naive;
use naive::date::NaiveDate;
use naive::time::NaiveTime;
use datetime::DateTime;
use offset::{TimeZone, UTC};
use naive::{self, NaiveDate, NaiveTime};
use DateTime;
use format::{Item, DelayedFormat, StrftimeItems};
/// ISO 8601 calendar date with time zone.
@ -48,9 +45,9 @@ pub struct Date<Tz: TimeZone> {
}
/// The minimum possible `Date`.
pub const MIN: Date<UTC> = Date { date: naive::date::MIN, offset: UTC };
pub const MIN_DATE: Date<UTC> = Date { date: naive::MIN_DATE, offset: UTC };
/// The maximum possible `Date`.
pub const MAX: Date<UTC> = Date { date: naive::date::MAX, offset: UTC };
pub const MAX_DATE: Date<UTC> = Date { date: naive::MAX_DATE, offset: UTC };
impl<Tz: TimeZone> Date<Tz> {
/// Makes a new `Date` with given *UTC* date and offset.

38
src/datetime.rs
View File

@ -11,13 +11,9 @@ use std::ops::Deref;
use oldtime::Duration as OldDuration;
use {Weekday, Timelike, Datelike};
use offset::{TimeZone, Offset};
use offset::utc::UTC;
use offset::local::Local;
use offset::fixed::FixedOffset;
use naive::time::NaiveTime;
use naive::datetime::NaiveDateTime;
use date::Date;
use offset::{TimeZone, Offset, UTC, Local, FixedOffset};
use naive::{NaiveTime, NaiveDateTime};
use Date;
use format::{Item, Numeric, Pad, Fixed};
use format::{parse, Parsed, ParseError, ParseResult, DelayedFormat, StrftimeItems};
@ -510,10 +506,7 @@ fn test_decodable_json_timestamps<FUTC, FFixed, FLocal, E>(utc_from_str: FUTC,
mod rustc_serialize {
use std::fmt;
use super::{DateTime, TsSeconds};
use offset::{TimeZone, LocalResult};
use offset::utc::UTC;
use offset::local::Local;
use offset::fixed::FixedOffset;
use offset::{TimeZone, LocalResult, UTC, Local, FixedOffset};
use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
impl<Tz: TimeZone> Encodable for DateTime<Tz> {
@ -609,11 +602,8 @@ mod rustc_serialize {
pub mod serde {
use std::fmt;
use super::DateTime;
use offset::{TimeZone, LocalResult};
use offset::utc::UTC;
use offset::local::Local;
use offset::fixed::FixedOffset;
use serde::{ser, de};
use offset::{TimeZone, LocalResult, UTC, Local, FixedOffset};
use serdelib::{ser, de};
/// Ser/de to/from timestamps in seconds
///
@ -630,7 +620,7 @@ pub mod serde {
/// # #[macro_use] extern crate serde_json;
/// # extern crate chrono;
/// # use chrono::{TimeZone, DateTime, UTC};
/// use chrono::datetime::serde::ts_seconds;
/// use chrono::serde::ts_seconds;
/// #[derive(Deserialize, Serialize)]
/// struct S {
/// #[serde(with = "ts_seconds")]
@ -653,7 +643,7 @@ pub mod serde {
/// ```
pub mod ts_seconds {
use std::fmt;
use serde::{ser, de};
use serdelib::{ser, de};
use {DateTime, UTC, FixedOffset};
use offset::TimeZone;
@ -674,7 +664,7 @@ pub mod serde {
/// # #[macro_use] extern crate serde_json;
/// # extern crate chrono;
/// # use chrono::{DateTime, UTC};
/// use chrono::datetime::serde::ts_seconds::deserialize as from_ts;
/// use chrono::serde::ts_seconds::deserialize as from_ts;
/// #[derive(Deserialize)]
/// struct S {
/// #[serde(deserialize_with = "from_ts")]
@ -708,7 +698,7 @@ pub mod serde {
/// # #[macro_use] extern crate serde_json;
/// # extern crate chrono;
/// # use chrono::{TimeZone, DateTime, UTC};
/// use chrono::datetime::serde::ts_seconds::serialize as to_ts;
/// use chrono::serde::ts_seconds::serialize as to_ts;
/// #[derive(Serialize)]
/// struct S {
/// #[serde(serialize_with = "to_ts")]
@ -882,12 +872,8 @@ pub mod serde {
mod tests {
use super::DateTime;
use Datelike;
use naive::time::NaiveTime;
use naive::date::NaiveDate;
use offset::TimeZone;
use offset::utc::UTC;
use offset::local::Local;
use offset::fixed::FixedOffset;
use naive::{NaiveTime, NaiveDate};
use offset::{TimeZone, UTC, Local, FixedOffset};
use oldtime::Duration;
#[test]

12
src/format/mod.rs
View File

@ -9,10 +9,8 @@ use std::error::Error;
use {Datelike, Timelike, Weekday, ParseWeekdayError};
use div::{div_floor, mod_floor};
use offset::Offset;
use offset::fixed::FixedOffset;
use naive::date::NaiveDate;
use naive::time::NaiveTime;
use offset::{Offset, FixedOffset};
use naive::{NaiveDate, NaiveTime};
pub use self::strftime::StrftimeItems;
pub use self::parsed::Parsed;
@ -175,14 +173,14 @@ pub enum Fixed {
///
/// In the parser, the colon can be omitted and/or surrounded with any amount of whitespaces.
/// The offset is limited from `-24:00` to `+24:00`,
/// which is same to [`FixedOffset`](../offset/fixed/struct.FixedOffset.html)'s range.
/// which is same to [`FixedOffset`](../offset/struct.FixedOffset.html)'s range.
TimezoneOffsetColon,
/// Offset from the local time to UTC (`+09:00` or `-04:00` or `Z`).
///
/// In the parser, the colon can be omitted and/or surrounded with any amount of whitespaces,
/// and `Z` can be either in upper case or in lower case.
/// The offset is limited from `-24:00` to `+24:00`,
/// which is same to [`FixedOffset`](../offset/fixed/struct.FixedOffset.html)'s range.
/// which is same to [`FixedOffset`](../offset/struct.FixedOffset.html)'s range.
TimezoneOffsetColonZ,
/// Same to [`TimezoneOffsetColon`](#variant.TimezoneOffsetColon) but prints no colon.
/// Parsing allows an optional colon.
@ -515,7 +513,7 @@ pub fn format<'a, I>(w: &mut fmt::Formatter, date: Option<&NaiveDate>, time: Opt
Ok(())
}
pub mod parsed;
mod parsed;
// due to the size of parsing routines, they are in separate modules.
mod scan;

8
src/format/parse.rs
View File

@ -603,8 +603,8 @@ fn test_parse() {
#[cfg(test)]
#[test]
fn test_rfc2822() {
use datetime::DateTime;
use offset::fixed::FixedOffset;
use DateTime;
use offset::FixedOffset;
use super::*;
use super::NOT_ENOUGH;
@ -687,8 +687,8 @@ fn parse_rfc850() {
#[cfg(test)]
#[test]
fn test_rfc3339() {
use datetime::DateTime;
use offset::fixed::FixedOffset;
use DateTime;
use offset::FixedOffset;
use super::*;
// Test data - (input, Ok(expected result after parse and format) or Err(error code))

26
src/format/parsed.rs
View File

@ -10,12 +10,9 @@ use oldtime::Duration as OldDuration;
use {Datelike, Timelike};
use Weekday;
use div::div_rem;
use offset::{TimeZone, Offset, LocalResult};
use offset::fixed::FixedOffset;
use naive::date::NaiveDate;
use naive::time::NaiveTime;
use naive::datetime::NaiveDateTime;
use datetime::DateTime;
use offset::{TimeZone, Offset, LocalResult, FixedOffset};
use naive::{NaiveDate, NaiveTime, NaiveDateTime};
use DateTime;
use super::{ParseResult, OUT_OF_RANGE, IMPOSSIBLE, NOT_ENOUGH};
/// Parsed parts of date and time. There are two classes of methods:
@ -641,11 +638,8 @@ mod tests {
use super::super::{OUT_OF_RANGE, IMPOSSIBLE, NOT_ENOUGH};
use Datelike;
use Weekday::*;
use naive::date::{self, NaiveDate};
use naive::time::NaiveTime;
use offset::TimeZone;
use offset::utc::UTC;
use offset::fixed::FixedOffset;
use naive::{MIN_DATE, MAX_DATE, NaiveDate, NaiveTime};
use offset::{TimeZone, UTC, FixedOffset};
#[test]
fn test_parsed_set_fields() {
@ -764,7 +758,7 @@ mod tests {
ymd(0, 1, 1));
assert_eq!(parse!(year_div_100: -1, year_mod_100: 42, month: 1, day: 1),
Err(OUT_OF_RANGE));
let max_year = date::MAX.year();
let max_year = MAX_DATE.year();
assert_eq!(parse!(year_div_100: max_year / 100,
year_mod_100: max_year % 100, month: 1, day: 1),
ymd(max_year, 1, 1));
@ -963,17 +957,17 @@ mod tests {
// more timestamps
let max_days_from_year_1970 =
date::MAX.signed_duration_since(NaiveDate::from_ymd(1970,1,1));
MAX_DATE.signed_duration_since(NaiveDate::from_ymd(1970,1,1));
let year_0_from_year_1970 =
NaiveDate::from_ymd(0,1,1).signed_duration_since(NaiveDate::from_ymd(1970,1,1));
let min_days_from_year_1970 =
date::MIN.signed_duration_since(NaiveDate::from_ymd(1970,1,1));
MIN_DATE.signed_duration_since(NaiveDate::from_ymd(1970,1,1));
assert_eq!(parse!(timestamp: min_days_from_year_1970.num_seconds()),
ymdhms(date::MIN.year(),1,1, 0,0,0));
ymdhms(MIN_DATE.year(),1,1, 0,0,0));
assert_eq!(parse!(timestamp: year_0_from_year_1970.num_seconds()),
ymdhms(0,1,1, 0,0,0));
assert_eq!(parse!(timestamp: max_days_from_year_1970.num_seconds() + 86399),
ymdhms(date::MAX.year(),12,31, 23,59,59));
ymdhms(MAX_DATE.year(),12,31, 23,59,59));
// leap seconds #1: partial fields
assert_eq!(parse!(second: 59, timestamp: 1_341_100_798), Err(IMPOSSIBLE));

115
src/lib.rs
View File

@ -76,7 +76,7 @@
//! ### Date and Time
//!
//! Chrono provides a
//! [**`DateTime`**](./datetime/struct.DateTime.html)
//! [**`DateTime`**](./struct.DateTime.html)
//! type to represent a date and a time in a timezone.
//!
//! For more abstract moment-in-time tracking such as internal timekeeping
@ -91,11 +91,11 @@
//! which defines how the local date is converted to and back from the UTC date.
//! There are three well-known `TimeZone` implementations:
//!
//! * [**`UTC`**](./offset/utc/struct.UTC.html) specifies the UTC time zone. It is most efficient.
//! * [**`UTC`**](./offset/struct.UTC.html) specifies the UTC time zone. It is most efficient.
//!
//! * [**`Local`**](./offset/local/struct.Local.html) specifies the system local time zone.
//! * [**`Local`**](./offset/struct.Local.html) specifies the system local time zone.
//!
//! * [**`FixedOffset`**](./offset/fixed/struct.FixedOffset.html) specifies
//! * [**`FixedOffset`**](./offset/struct.FixedOffset.html) specifies
//! an arbitrary, fixed time zone such as UTC+09:00 or UTC-10:30.
//! This often results from the parsed textual date and time.
//! Since it stores the most information and does not depend on the system environment,
@ -103,12 +103,12 @@
//!
//! `DateTime`s with different `TimeZone` types are distinct and do not mix,
//! but can be converted to each other using
//! the [`DateTime::with_timezone`](./datetime/struct.DateTime.html#method.with_timezone) method.
//! the [`DateTime::with_timezone`](./struct.DateTime.html#method.with_timezone) method.
//!
//! You can get the current date and time in the UTC time zone
//! ([`UTC::now()`](./offset/utc/struct.UTC.html#method.now))
//! ([`UTC::now()`](./offset/struct.UTC.html#method.now))
//! or in the local time zone
//! ([`Local::now()`](./offset/local/struct.Local.html#method.now)).
//! ([`Local::now()`](./offset/struct.Local.html#method.now)).
//!
//! ```rust
//! use chrono::prelude::*;
@ -198,14 +198,14 @@
//! # }
//! ```
//!
//! Formatting is done via the [`format`](./datetime/struct.DateTime.html#method.format) method,
//! Formatting is done via the [`format`](./struct.DateTime.html#method.format) method,
//! which format is equivalent to the familiar `strftime` format.
//! (See the [`format::strftime` module documentation](./format/strftime/index.html#specifiers)
//! for full syntax.)
//!
//! The default `to_string` method and `{:?}` specifier also give a reasonable representation.
//! Chrono also provides [`to_rfc2822`](./datetime/struct.DateTime.html#method.to_rfc2822) and
//! [`to_rfc3339`](./datetime/struct.DateTime.html#method.to_rfc3339) methods
//! Chrono also provides [`to_rfc2822`](./struct.DateTime.html#method.to_rfc2822) and
//! [`to_rfc3339`](./struct.DateTime.html#method.to_rfc3339) methods
//! for well-known formats.
//!
//! ```rust
@ -231,13 +231,13 @@
//! ([`std::fmt::Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html))
//! format specifier prints, and requires the offset to be present.
//!
//! 2. [`DateTime::parse_from_str`](./datetime/struct.DateTime.html#method.parse_from_str) parses
//! 2. [`DateTime::parse_from_str`](./struct.DateTime.html#method.parse_from_str) parses
//! a date and time with offsets and returns `DateTime<FixedOffset>`.
//! This should be used when the offset is a part of input and the caller cannot guess that.
//! It *cannot* be used when the offset can be missing.
//! [`DateTime::parse_from_rfc2822`](./datetime/struct.DateTime.html#method.parse_from_rfc2822)
//! [`DateTime::parse_from_rfc2822`](./struct.DateTime.html#method.parse_from_rfc2822)
//! and
//! [`DateTime::parse_from_rfc3339`](./datetime/struct.DateTime.html#method.parse_from_rfc3339)
//! [`DateTime::parse_from_rfc3339`](./struct.DateTime.html#method.parse_from_rfc3339)
//! are similar but for well-known formats.
//!
//! 3. [`Offset::datetime_from_str`](./offset/trait.TimeZone.html#method.datetime_from_str) is
@ -281,7 +281,7 @@
//!
//! ### Individual date
//!
//! Chrono also provides an individual date type ([**`Date`**](./date/struct.Date.html)).
//! Chrono also provides an individual date type ([**`Date`**](./struct.Date.html)).
//! It also has time zones attached, and have to be constructed via time zones.
//! Most operations available to `DateTime` are also available to `Date` whenever appropriate.
//!
@ -301,26 +301,26 @@
//!
//! There is no timezone-aware `Time` due to the lack of usefulness and also the complexity.
//!
//! `DateTime` has [`date`](./datetime/struct.DateTime.html#method.date) method
//! `DateTime` has [`date`](./struct.DateTime.html#method.date) method
//! which returns a `Date` which represents its date component.
//! There is also a [`time`](./datetime/struct.DateTime.html#method.time) method,
//! There is also a [`time`](./struct.DateTime.html#method.time) method,
//! which simply returns a naive local time described below.
//!
//! ### Naive date and time
//!
//! Chrono provides naive counterparts to `Date`, (non-existent) `Time` and `DateTime`
//! as [**`NaiveDate`**](./naive/date/struct.NaiveDate.html),
//! [**`NaiveTime`**](./naive/time/struct.NaiveTime.html) and
//! [**`NaiveDateTime`**](./naive/datetime/struct.NaiveDateTime.html) respectively.
//! as [**`NaiveDate`**](./naive/struct.NaiveDate.html),
//! [**`NaiveTime`**](./naive/struct.NaiveTime.html) and
//! [**`NaiveDateTime`**](./naive/struct.NaiveDateTime.html) respectively.
//!
//! They have almost equivalent interfaces as their timezone-aware twins,
//! but are not associated to time zones obviously and can be quite low-level.
//! They are mostly useful for building blocks for higher-level types.
//!
//! Timezone-aware `DateTime` and `Date` types have two methods returning naive versions:
//! [`naive_local`](./datetime/struct.DateTime.html#method.naive_local) returns
//! [`naive_local`](./struct.DateTime.html#method.naive_local) returns
//! a view to the naive local time,
//! and [`naive_utc`](./datetime/struct.DateTime.html#method.naive_utc) returns
//! and [`naive_utc`](./struct.DateTime.html#method.naive_utc) returns
//! a view to the naive UTC time.
//!
//! ## Limitations
@ -332,7 +332,7 @@
//! Time types are limited in the nanosecond accuracy.
//!
//! [Leap seconds are supported in the representation but
//! Chrono doesn't try to make use of them](./naive/time/index.html#leap-second-handling).
//! Chrono doesn't try to make use of them](./naive/struct.NaiveTime.html#leap-second-handling).
//! (The main reason is that leap seconds are not really predictable.)
//! Almost *every* operation over the possible leap seconds will ignore them.
//! Consider using `NaiveDateTime` with the implicit TAI (International Atomic Time) scale
@ -356,34 +356,26 @@ extern crate num;
#[cfg(feature = "rustc-serialize")]
extern crate rustc_serialize;
#[cfg(feature = "serde")]
extern crate serde;
extern crate serde as serdelib;
// this reexport is to aid the transition and should not be in the prelude!
pub use oldtime::Duration;
pub use offset::{TimeZone, Offset, LocalResult};
pub use offset::utc::UTC;
pub use offset::fixed::FixedOffset;
pub use offset::local::Local;
pub use naive::date::NaiveDate;
pub use naive::time::NaiveTime;
pub use naive::datetime::NaiveDateTime;
pub use date::Date;
pub use datetime::DateTime;
#[doc(no_inline)] pub use offset::{TimeZone, Offset, LocalResult, UTC, FixedOffset, Local};
#[doc(no_inline)] pub use naive::{NaiveDate, NaiveTime, NaiveDateTime};
pub use date_::{Date, MIN_DATE, MAX_DATE};
pub use datetime_::DateTime;
#[cfg(feature = "rustc-serialize")] pub use datetime_::TsSeconds;
pub use format::{ParseError, ParseResult};
/// A convenience module appropriate for glob imports (`use chrono::prelude::*;`).
pub mod prelude {
pub use {Datelike, Timelike, Weekday};
pub use offset::{TimeZone, Offset};
pub use offset::utc::UTC;
pub use offset::fixed::FixedOffset;
pub use offset::local::Local;
pub use naive::date::NaiveDate;
pub use naive::time::NaiveTime;
pub use naive::datetime::NaiveDateTime;
pub use date::Date;
pub use datetime::DateTime;
#[doc(no_inline)] pub use {Datelike, Timelike, Weekday};
#[doc(no_inline)] pub use {TimeZone, Offset};
#[doc(no_inline)] pub use {UTC, FixedOffset, Local};
#[doc(no_inline)] pub use {NaiveDate, NaiveTime, NaiveDateTime};
#[doc(no_inline)] pub use Date;
#[doc(no_inline)] pub use DateTime;
}
// useful throughout the codebase
@ -399,14 +391,35 @@ pub mod naive {
//! They are primarily building blocks for other types
//! (e.g. [`TimeZone`](../offset/trait.TimeZone.html)),
//! but can be also used for the simpler date and time handling.
pub mod date;
pub mod time;
pub mod datetime;
// avoid using them directly even in the crate itself
#[path = "date.rs"] mod date_;
#[path = "time.rs"] mod time_;
#[path = "datetime.rs"] mod datetime_;
pub use self::date_::{NaiveDate, MIN_DATE, MAX_DATE};
pub use self::time_::NaiveTime;
pub use self::datetime_::{NaiveDateTime, TsSeconds};
/// Tools to help serializing/deserializing naive types.
#[cfg(feature = "serde")]
pub mod serde {
pub use super::datetime_::serde::*;
}
}
pub mod date;
pub mod datetime;
#[path = "date.rs"] mod date_;
#[path = "datetime.rs"] mod datetime_;
pub mod format;
/// Ser/de helpers
///
/// The various modules in here are intended to be used with serde's [`with`
/// annotation](https://serde.rs/attributes.html#field-attributes).
#[cfg(feature = "serde")]
pub mod serde {
pub use super::datetime_::serde::*;
}
/// The day of week.
///
/// The order of the days of week depends on the context.
@ -594,7 +607,7 @@ impl fmt::Debug for ParseWeekdayError {
mod weekday_serde {
use super::Weekday;
use std::fmt;
use serde::{ser, de};
use serdelib::{ser, de};
impl ser::Serialize for Weekday {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@ -698,7 +711,7 @@ mod weekday_serde {
/// The common set of methods for date component.
pub trait Datelike: Sized {
/// Returns the year number in the [calendar date](./naive/date/index.html#calendar-date).
/// Returns the year number in the [calendar date](./naive/struct.NaiveDate.html#calendar-date).
fn year(&self) -> i32;
/// Returns the absolute year number starting from 1 with a boolean flag,
@ -826,7 +839,7 @@ pub trait Timelike: Sized {
/// Returns the number of nanoseconds since the whole non-leap second.
/// The range from 1,000,000,000 to 1,999,999,999 represents
/// the [leap second](./naive/time/index.html#leap-second-handling).
/// the [leap second](./naive/struct.NaiveTime.html#leap-second-handling).
fn nanosecond(&self) -> u32;
/// Makes a new value with the hour number changed.
@ -864,7 +877,7 @@ pub trait Timelike: Sized {
fn test_readme_doomsday() {
use num::iter::range_inclusive;
for y in range_inclusive(naive::date::MIN.year(), naive::date::MAX.year()) {
for y in range_inclusive(naive::MIN_DATE.year(), naive::MAX_DATE.year()) {
// even months
let d4 = NaiveDate::from_ymd(y, 4, 4);
let d6 = NaiveDate::from_ymd(y, 6, 6);

184
src/naive/date.rs
View File

@ -2,49 +2,6 @@
// See README.md and LICENSE.txt for details.
//! ISO 8601 calendar date without timezone.
//!
//! # Calendar Date
//!
//! The ISO 8601 **calendar date** follows the proleptic Gregorian calendar.
//! It is like a normal civil calendar but note some slight differences:
//!
//! * Dates before the Gregorian calendar's inception in 1582 are defined via the extrapolation.
//! Be careful, as historical dates are often noted in the Julian calendar and others
//! and the transition to Gregorian may differ across countries (as late as early 20C).
//!
//! (Some example: Both Shakespeare from Britain and Cervantes from Spain seemingly died
//! on the same calendar date---April 23, 1616---but in the different calendar.
//! Britain used the Julian calendar at that time, so Shakespeare's death is later.)
//!
//! * ISO 8601 calendars has the year 0, which is 1 BCE (a year before 1 CE).
//! If you need a typical BCE/BC and CE/AD notation for year numbers,
//! use the [`Datelike::year_ce`](../../trait.Datelike.html#method.year_ce) method.
//!
//! # Week Date
//!
//! The ISO 8601 **week date** is a triple of year number, week number
//! and [day of the week](../../enum.Weekday.html) with the following rules:
//!
//! * A week consists of Monday through Sunday, and is always numbered within some year.
//! The week number ranges from 1 to 52 or 53 depending on the year.
//!
//! * The week 1 of given year is defined as the first week containing January 4 of that year,
//! or equivalently, the first week containing four or more days in that year.
//!
//! * The year number in the week date may *not* correspond to the actual Gregorian year.
//! For example, January 3, 2016 (Sunday) was on the last (53rd) week of 2015.
//!
//! Chrono's date types default to the ISO 8601 [calendar date](#calendar-date),
//! but the [`Datelike::isoweekdate`](../../trait.Datelike.html#tymethod.isoweekdate) method
//! can be used to get the corresponding week date.
//!
//! # Ordinal Date
//!
//! The ISO 8601 **ordinal date** is a pair of year number and day of the year ("ordinal").
//! The ordinal number ranges from 1 to 365 or 366 depending on the year.
//! The year number is same to that of the [calendar date](#calendar-date).
//!
//! This is currently the internal format of Chrono's date types.
use std::{str, fmt, hash};
use std::ops::{Add, Sub};
@ -53,8 +10,7 @@ use oldtime::Duration as OldDuration;
use {Weekday, Datelike};
use div::div_mod_floor;
use naive::time::NaiveTime;
use naive::datetime::NaiveDateTime;
use naive::{NaiveTime, NaiveDateTime};
use format::{Item, Numeric, Pad};
use format::{parse, Parsed, ParseError, ParseResult, DelayedFormat, StrftimeItems};
@ -89,32 +45,76 @@ const MIN_DAYS_FROM_YEAR_0: i32 = (MIN_YEAR + 400_000) * 365 +
const MAX_BITS: usize = 44;
/// ISO 8601 calendar date without timezone.
/// Allows for every [proleptic Gregorian date](./index.html#calendar-date)
/// Allows for every [proleptic Gregorian date](#calendar-date)
/// from Jan 1, 262145 BCE to Dec 31, 262143 CE.
/// Also supports the conversion from ISO 8601 ordinal and week date.
///
/// # Calendar Date
///
/// The ISO 8601 **calendar date** follows the proleptic Gregorian calendar.
/// It is like a normal civil calendar but note some slight differences:
///
/// * Dates before the Gregorian calendar's inception in 1582 are defined via the extrapolation.
/// Be careful, as historical dates are often noted in the Julian calendar and others
/// and the transition to Gregorian may differ across countries (as late as early 20C).
///
/// (Some example: Both Shakespeare from Britain and Cervantes from Spain seemingly died
/// on the same calendar date---April 23, 1616---but in the different calendar.
/// Britain used the Julian calendar at that time, so Shakespeare's death is later.)
///
/// * ISO 8601 calendars has the year 0, which is 1 BCE (a year before 1 CE).
/// If you need a typical BCE/BC and CE/AD notation for year numbers,
/// use the [`Datelike::year_ce`](../../trait.Datelike.html#method.year_ce) method.
///
/// # Week Date
///
/// The ISO 8601 **week date** is a triple of year number, week number
/// and [day of the week](../../enum.Weekday.html) with the following rules:
///
/// * A week consists of Monday through Sunday, and is always numbered within some year.
/// The week number ranges from 1 to 52 or 53 depending on the year.
///
/// * The week 1 of given year is defined as the first week containing January 4 of that year,
/// or equivalently, the first week containing four or more days in that year.
///
/// * The year number in the week date may *not* correspond to the actual Gregorian year.
/// For example, January 3, 2016 (Sunday) was on the last (53rd) week of 2015.
///
/// Chrono's date types default to the ISO 8601 [calendar date](#calendar-date),
/// but the [`Datelike::isoweekdate`](../../trait.Datelike.html#tymethod.isoweekdate) method
/// can be used to get the corresponding week date.
///
/// # Ordinal Date
///
/// The ISO 8601 **ordinal date** is a pair of year number and day of the year ("ordinal").
/// The ordinal number ranges from 1 to 365 or 366 depending on the year.
/// The year number is same to that of the [calendar date](#calendar-date).
///
/// This is currently the internal format of Chrono's date types.
#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
pub struct NaiveDate {
ymdf: DateImpl, // (year << 13) | of
}
/// The minimum possible `NaiveDate` (January 1, 262145 BCE).
pub const MIN: NaiveDate = NaiveDate { ymdf: (MIN_YEAR << 13) | (1 << 4) | 0o07 /*FE*/ };
pub const MIN_DATE: NaiveDate = NaiveDate { ymdf: (MIN_YEAR << 13) | (1 << 4) | 0o07 /*FE*/ };
/// The maximum possible `NaiveDate` (December 31, 262143 CE).
pub const MAX: NaiveDate = NaiveDate { ymdf: (MAX_YEAR << 13) | (365 << 4) | 0o17 /*F*/ };
pub const MAX_DATE: 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.
// as it is hard to verify year flags in `MIN_DATE` and `MAX_DATE`,
// we use a separate run-time test.
#[test]
fn test_date_bounds() {
let calculated_min = NaiveDate::from_ymd(MIN_YEAR, 1, 1);
let calculated_max = NaiveDate::from_ymd(MAX_YEAR, 12, 31);
assert!(MIN == calculated_min,
"`MIN` should have a year flag {:?}", calculated_min.of().flags());
assert!(MAX == calculated_max,
"`MAX` should have a year flag {:?}", calculated_max.of().flags());
assert!(MIN_DATE == calculated_min,
"`MIN_DATE` should have a year flag {:?}", calculated_min.of().flags());
assert!(MAX_DATE == calculated_max,
"`MAX_DATE` should have a year flag {:?}", calculated_max.of().flags());
// let's also check that the entire range do not exceed 2^44 seconds
// (sometimes used for bounding `Duration` against overflow)
let maxsecs = MAX.signed_duration_since(MIN).num_seconds();
let maxsecs = MAX_DATE.signed_duration_since(MIN_DATE).num_seconds();
let maxsecs = maxsecs + 86401; // also take care of DateTime
assert!(maxsecs < (1 << MAX_BITS),
"The entire `NaiveDate` range somehow exceeds 2^{} seconds", MAX_BITS);
@ -136,7 +136,7 @@ impl NaiveDate {
NaiveDate::from_of(year, mdf.to_of())
}
/// Makes a new `NaiveDate` from the [calendar date](./index.html#calendar-date)
/// Makes a new `NaiveDate` from the [calendar date](#calendar-date)
/// (year, month and day).
///
/// Panics on the out-of-range date, invalid month and/or day.
@ -158,7 +158,7 @@ impl NaiveDate {
NaiveDate::from_ymd_opt(year, month, day).expect("invalid or out-of-range date")
}
/// Makes a new `NaiveDate` from the [calendar date](./index.html#calendar-date)
/// Makes a new `NaiveDate` from the [calendar date](#calendar-date)
/// (year, month and day).
///
/// Returns `None` on the out-of-range date, invalid month and/or day.
@ -182,7 +182,7 @@ impl NaiveDate {
NaiveDate::from_mdf(year, Mdf::new(month, day, flags))
}
/// Makes a new `NaiveDate` from the [ordinal date](./index.html#ordinal-date)
/// Makes a new `NaiveDate` from the [ordinal date](#ordinal-date)
/// (year and day of the year).
///
/// Panics on the out-of-range date and/or invalid day of year.
@ -204,7 +204,7 @@ impl NaiveDate {
NaiveDate::from_yo_opt(year, ordinal).expect("invalid or out-of-range date")
}
/// Makes a new `NaiveDate` from the [ordinal date](./index.html#ordinal-date)
/// Makes a new `NaiveDate` from the [ordinal date](#ordinal-date)
/// (year and day of the year).
///
/// Returns `None` on the out-of-range date and/or invalid day of year.
@ -229,7 +229,7 @@ impl NaiveDate {
NaiveDate::from_of(year, Of::new(ordinal, flags))
}
/// Makes a new `NaiveDate` from the [ISO week date](./index.html#week-date)
/// Makes a new `NaiveDate` from the [ISO week date](#week-date)
/// (year, week number and day of the week).
/// The resulting `NaiveDate` may have a different year from the input year.
///
@ -252,7 +252,7 @@ impl NaiveDate {
NaiveDate::from_isoywd_opt(year, week, weekday).expect("invalid or out-of-range date")
}
/// Makes a new `NaiveDate` from the [ISO week date](./index.html#week-date)
/// Makes a new `NaiveDate` from the [ISO week date](#week-date)
/// (year, week number and day of the week).
/// The resulting `NaiveDate` may have a different year from the input year.
///
@ -466,7 +466,7 @@ impl NaiveDate {
/// Makes a new `NaiveDateTime` from the current date, hour, minute and second.
///
/// No [leap second](../time/index.html#leap-second-handling) is allowed here;
/// No [leap second](./struct.NaiveTime.html#leap-second-handling) is allowed here;
/// use `NaiveDate::and_hms_*` methods with a subsecond parameter instead.
///
/// Panics on invalid hour, minute and/or second.
@ -490,7 +490,7 @@ impl NaiveDate {
/// Makes a new `NaiveDateTime` from the current date, hour, minute and second.
///
/// No [leap second](../time/index.html#leap-second-handling) is allowed here;
/// No [leap second](./struct.NaiveTime.html#leap-second-handling) is allowed here;
/// use `NaiveDate::and_hms_*_opt` methods with a subsecond parameter instead.
///
/// Returns `None` on invalid hour, minute and/or second.
@ -514,7 +514,7 @@ impl NaiveDate {
/// 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](../time/index.html#leap-second-handling).
/// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
///
/// Panics on invalid hour, minute, second and/or millisecond.
///
@ -539,7 +539,7 @@ impl NaiveDate {
/// 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](../time/index.html#leap-second-handling).
/// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
///
/// Returns `None` on invalid hour, minute, second and/or millisecond.
///
@ -565,7 +565,7 @@ impl NaiveDate {
/// 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](../time/index.html#leap-second-handling).
/// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
///
/// Panics on invalid hour, minute, second and/or microsecond.
///
@ -590,7 +590,7 @@ impl NaiveDate {
/// 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](../time/index.html#leap-second-handling).
/// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
///
/// Returns `None` on invalid hour, minute, second and/or microsecond.
///
@ -616,7 +616,7 @@ impl NaiveDate {
/// 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](../time/index.html#leap-second-handling).
/// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
///
/// Panics on invalid hour, minute, second and/or nanosecond.
///
@ -641,7 +641,7 @@ impl NaiveDate {
/// 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](../time/index.html#leap-second-handling).
/// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
///
/// Returns `None` on invalid hour, minute, second and/or nanosecond.
///
@ -723,11 +723,11 @@ impl NaiveDate {
///
/// ~~~~
/// use chrono::NaiveDate;
/// use chrono::naive::date::MAX;
/// use chrono::naive::MAX_DATE;
///
/// assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ_opt(),
/// Some(NaiveDate::from_ymd(2015, 6, 4)));
/// assert_eq!(MAX.succ_opt(), None);
/// assert_eq!(MAX_DATE.succ_opt(), None);
/// ~~~~
#[inline]
pub fn succ_opt(&self) -> Option<NaiveDate> {
@ -760,11 +760,11 @@ impl NaiveDate {
///
/// ~~~~
/// use chrono::NaiveDate;
/// use chrono::naive::date::MIN;
/// use chrono::naive::MIN_DATE;
///
/// assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred_opt(),
/// Some(NaiveDate::from_ymd(2015, 6, 2)));
/// assert_eq!(MIN.pred_opt(), None);
/// assert_eq!(MIN_DATE.pred_opt(), None);
/// ~~~~
#[inline]
pub fn pred_opt(&self) -> Option<NaiveDate> {
@ -780,7 +780,7 @@ impl NaiveDate {
/// ~~~~
/// # extern crate chrono; extern crate time; fn main() {
/// use chrono::NaiveDate;
/// use chrono::naive::date::MAX;
/// use chrono::naive::MAX_DATE;
/// use time::Duration;
///
/// let d = NaiveDate::from_ymd(2015, 9, 5);
@ -790,7 +790,7 @@ impl NaiveDate {
/// Some(NaiveDate::from_ymd(2015, 7, 27)));
/// assert_eq!(d.checked_add_signed(Duration::days(1_000_000_000)), None);
/// assert_eq!(d.checked_add_signed(Duration::days(-1_000_000_000)), None);
/// assert_eq!(MAX.checked_add_signed(Duration::days(1)), None);
/// assert_eq!(MAX_DATE.checked_add_signed(Duration::days(1)), None);
/// # }
/// ~~~~
pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDate> {
@ -816,7 +816,7 @@ impl NaiveDate {
/// ~~~~
/// # extern crate chrono; extern crate time; fn main() {
/// use chrono::NaiveDate;
/// use chrono::naive::date::MIN;
/// use chrono::naive::MIN_DATE;
/// use time::Duration;
///
/// let d = NaiveDate::from_ymd(2015, 9, 5);
@ -826,7 +826,7 @@ impl NaiveDate {
/// Some(NaiveDate::from_ymd(2015, 10, 15)));
/// assert_eq!(d.checked_sub_signed(Duration::days(1_000_000_000)), None);
/// assert_eq!(d.checked_sub_signed(Duration::days(-1_000_000_000)), None);
/// assert_eq!(MIN.checked_sub_signed(Duration::days(1)), None);
/// assert_eq!(MIN_DATE.checked_sub_signed(Duration::days(1)), None);
/// # }
/// ~~~~
pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDate> {
@ -951,7 +951,7 @@ impl NaiveDate {
}
impl Datelike for NaiveDate {
/// Returns the year number in the [calendar date](./index.html#calendar-date).
/// Returns the year number in the [calendar date](#calendar-date).
///
/// # Example
///
@ -1013,7 +1013,7 @@ impl Datelike for NaiveDate {
/// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day(), 14);
/// ~~~~
///
/// Combined with [`NaiveDate::pred`](./struct.NaiveDate.html#method.pred),
/// Combined with [`NaiveDate::pred`](#method.pred),
/// one can determine the number of days in a particular month.
/// (Note that this panics when `year` is out of range.)
///
@ -1070,7 +1070,7 @@ impl Datelike for NaiveDate {
/// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal(), 74);
/// ~~~~
///
/// Combined with [`NaiveDate::pred`](./struct.NaiveDate.html#method.pred),
/// Combined with [`NaiveDate::pred`](#method.pred),
/// one can determine the number of days in a particular year.
/// (Note that this panics when `year` is out of range.)
///
@ -1487,9 +1487,9 @@ fn test_encodable_json<F, E>(to_string: F)
Some(r#""0000-01-01""#.into()));
assert_eq!(to_string(&NaiveDate::from_ymd(-1, 12, 31)).ok(),
Some(r#""-0001-12-31""#.into()));
assert_eq!(to_string(&MIN).ok(),
assert_eq!(to_string(&MIN_DATE).ok(),
Some(r#""-262144-01-01""#.into()));
assert_eq!(to_string(&MAX).ok(),
assert_eq!(to_string(&MAX_DATE).ok(),
Some(r#""+262143-12-31""#.into()));
}
@ -1505,8 +1505,8 @@ fn test_decodable_json<F, E>(from_str: F)
assert_eq!(from_str(r#""0000-01-01""#).ok(), Some(NaiveDate::from_ymd(0, 1, 1)));
assert_eq!(from_str(r#""0-1-1""#).ok(), Some(NaiveDate::from_ymd(0, 1, 1)));
assert_eq!(from_str(r#""-0001-12-31""#).ok(), Some(NaiveDate::from_ymd(-1, 12, 31)));
assert_eq!(from_str(r#""-262144-01-01""#).ok(), Some(MIN));
assert_eq!(from_str(r#""+262143-12-31""#).ok(), Some(MAX));
assert_eq!(from_str(r#""-262144-01-01""#).ok(), Some(MIN_DATE));
assert_eq!(from_str(r#""+262143-12-31""#).ok(), Some(MAX_DATE));
// bad formats
assert!(from_str(r#""""#).is_err());
@ -1562,7 +1562,7 @@ mod rustc_serialize {
mod serde {
use std::fmt;
use super::NaiveDate;
use serde::{ser, de};
use serdelib::{ser, de};
// TODO not very optimized for space (binary formats would want something better)
@ -1638,8 +1638,8 @@ mod serde {
#[cfg(test)]
mod tests {
use super::NaiveDate;
use super::{MIN, MIN_YEAR, MIN_DAYS_FROM_YEAR_0};
use super::{MAX, MAX_YEAR, MAX_DAYS_FROM_YEAR_0};
use super::{MIN_DATE, MIN_YEAR, MIN_DAYS_FROM_YEAR_0};
use super::{MAX_DATE, MAX_YEAR, MAX_DAYS_FROM_YEAR_0};
use {Datelike, Weekday};
use std::{i32, u32};
use oldtime::Duration;
@ -1778,10 +1778,10 @@ mod tests {
assert_eq!(from_ndays_from_ce(days).map(|d| d.num_days_from_ce()), Some(days));
}
assert_eq!(from_ndays_from_ce(MIN.num_days_from_ce()), Some(MIN));
assert_eq!(from_ndays_from_ce(MIN.num_days_from_ce() - 1), None);
assert_eq!(from_ndays_from_ce(MAX.num_days_from_ce()), Some(MAX));
assert_eq!(from_ndays_from_ce(MAX.num_days_from_ce() + 1), None);
assert_eq!(from_ndays_from_ce(MIN_DATE.num_days_from_ce()), Some(MIN_DATE));
assert_eq!(from_ndays_from_ce(MIN_DATE.num_days_from_ce() - 1), None);
assert_eq!(from_ndays_from_ce(MAX_DATE.num_days_from_ce()), Some(MAX_DATE));
assert_eq!(from_ndays_from_ce(MAX_DATE.num_days_from_ce() + 1), None);
}
#[test]
@ -1887,7 +1887,7 @@ mod tests {
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);
assert_eq!(ymd(MAX_DATE.year(), 12, 31).succ_opt(), None);
}
#[test]
@ -1897,7 +1897,7 @@ mod tests {
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);
assert_eq!(ymd(MIN_DATE.year(), 1, 1).pred_opt(), None);
}
#[test]

118
src/naive/datetime.rs
View File

@ -10,8 +10,7 @@ use oldtime::Duration as OldDuration;
use {Weekday, Timelike, Datelike};
use div::div_mod_floor;
use naive::time::NaiveTime;
use naive::date::NaiveDate;
use naive::{NaiveTime, NaiveDate};
use format::{Item, Numeric, Pad, Fixed};
use format::{parse, Parsed, ParseError, ParseResult, DelayedFormat, StrftimeItems};
@ -27,7 +26,7 @@ const MAX_SECS_BITS: usize = 44;
///
/// # Example
///
/// `NaiveDateTime` is commonly created from [`NaiveDate`](../date/struct.NaiveDate.html).
/// `NaiveDateTime` is commonly created from [`NaiveDate`](./struct.NaiveDate.html).
///
/// ~~~~
/// use chrono::{NaiveDate, NaiveDateTime};
@ -74,7 +73,7 @@ impl Deref for TsSeconds {
impl NaiveDateTime {
/// Makes a new `NaiveDateTime` from date and time components.
/// Equivalent to [`date.and_time(time)`](../date/struct.NaiveDate.html#method.and_time)
/// Equivalent to [`date.and_time(time)`](./struct.NaiveDate.html#method.and_time)
/// and many other helper constructors on `NaiveDate`.
///
/// # Example
@ -103,7 +102,7 @@ impl NaiveDateTime {
/// [`TimeZone::timestamp`](../../offset/trait.TimeZone.html#method.timestamp).
///
/// The nanosecond part can exceed 1,000,000,000 in order to represent the
/// [leap second](../time/index.html#leap-second-handling). (The true "UNIX
/// [leap second](./struct.NaiveTime.html#leap-second-handling). (The true "UNIX
/// timestamp" cannot represent a leap second unambiguously.)
///
/// Panics on the out-of-range number of seconds and/or invalid nanosecond.
@ -131,7 +130,7 @@ impl NaiveDateTime {
/// and the number of nanoseconds since the last whole non-leap second.
///
/// The nanosecond part can exceed 1,000,000,000
/// in order to represent the [leap second](../time/index.html#leap-second-handling).
/// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
/// (The true "UNIX timestamp" cannot represent a leap second unambiguously.)
///
/// Returns `None` on the out-of-range number of seconds and/or invalid nanosecond.
@ -285,7 +284,7 @@ impl NaiveDateTime {
/// Returns the number of milliseconds since the last whole non-leap second.
///
/// The return value ranges from 0 to 999,
/// or for [leap seconds](../time/index.html#leap-second-handling), to 1,999.
/// or for [leap seconds](./struct.NaiveTime.html#leap-second-handling), to 1,999.
///
/// # Example
///
@ -306,7 +305,7 @@ impl NaiveDateTime {
/// Returns the number of microseconds since the last whole non-leap second.
///
/// The return value ranges from 0 to 999,999,
/// or for [leap seconds](../time/index.html#leap-second-handling), to 1,999,999.
/// or for [leap seconds](./struct.NaiveTime.html#leap-second-handling), to 1,999,999.
///
/// # Example
///
@ -327,7 +326,7 @@ impl NaiveDateTime {
/// Returns the number of nanoseconds since the last whole non-leap second.
///
/// The return value ranges from 0 to 999,999,999,
/// or for [leap seconds](../time/index.html#leap-second-handling), to 1,999,999,999.
/// or for [leap seconds](./struct.NaiveTime.html#leap-second-handling), to 1,999,999,999.
///
/// # Example
///
@ -347,7 +346,7 @@ impl NaiveDateTime {
/// Adds given `Duration` to the current date and time.
///
/// As a part of Chrono's [leap second handling](../time/index.html#leap-second-handling),
/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
/// the addition assumes that **there is no leap second ever**,
/// except when the `NaiveDateTime` itself represents a leap second
/// in which case the assumption becomes that **there is exactly a single leap second ever**.
@ -433,7 +432,7 @@ impl NaiveDateTime {
/// Subtracts given `Duration` from the current date and time.
///
/// As a part of Chrono's [leap second handling](../time/index.html#leap-second-handling),
/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
/// the subtraction assumes that **there is no leap second ever**,
/// except when the `NaiveDateTime` itself represents a leap second
/// in which case the assumption becomes that **there is exactly a single leap second ever**.
@ -516,7 +515,7 @@ impl NaiveDateTime {
/// Subtracts another `NaiveDateTime` from the current date and time.
/// This does not overflow or underflow at all.
///
/// As a part of Chrono's [leap second handling](../time/index.html#leap-second-handling),
/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
/// the subtraction assumes that **there is no leap second ever**,
/// except when any of the `NaiveDateTime`s themselves represents a leap second
/// in which case the assumption becomes that
@ -635,7 +634,7 @@ impl NaiveDateTime {
impl Datelike for NaiveDateTime {
/// Returns the year number in the [calendar date](./index.html#calendar-date).
///
/// See also the [`NaiveDate::year`](../date/struct.NaiveDate.html#method.year) method.
/// See also the [`NaiveDate::year`](./struct.NaiveDate.html#method.year) method.
///
/// # Example
///
@ -654,7 +653,7 @@ impl Datelike for NaiveDateTime {
///
/// The return value ranges from 1 to 12.
///
/// See also the [`NaiveDate::month`](../date/struct.NaiveDate.html#method.month) method.
/// See also the [`NaiveDate::month`](./struct.NaiveDate.html#method.month) method.
///
/// # Example
///
@ -673,7 +672,7 @@ impl Datelike for NaiveDateTime {
///
/// The return value ranges from 0 to 11.
///
/// See also the [`NaiveDate::month0`](../date/struct.NaiveDate.html#method.month0) method.
/// See also the [`NaiveDate::month0`](./struct.NaiveDate.html#method.month0) method.
///
/// # Example
///
@ -692,7 +691,7 @@ impl Datelike for NaiveDateTime {
///
/// The return value ranges from 1 to 31. (The last day of month differs by months.)
///
/// See also the [`NaiveDate::day`](../date/struct.NaiveDate.html#method.day) method.
/// See also the [`NaiveDate::day`](./struct.NaiveDate.html#method.day) method.
///
/// # Example
///
@ -711,7 +710,7 @@ impl Datelike for NaiveDateTime {
///
/// The return value ranges from 0 to 30. (The last day of month differs by months.)
///
/// See also the [`NaiveDate::day0`](../date/struct.NaiveDate.html#method.day0) method.
/// See also the [`NaiveDate::day0`](./struct.NaiveDate.html#method.day0) method.
///
/// # Example
///
@ -730,7 +729,7 @@ impl Datelike for NaiveDateTime {
///
/// The return value ranges from 1 to 366. (The last day of year differs by years.)
///
/// See also the [`NaiveDate::ordinal`](../date/struct.NaiveDate.html#method.ordinal) method.
/// See also the [`NaiveDate::ordinal`](./struct.NaiveDate.html#method.ordinal) method.
///
/// # Example
///
@ -749,7 +748,7 @@ impl Datelike for NaiveDateTime {
///
/// The return value ranges from 0 to 365. (The last day of year differs by years.)
///
/// See also the [`NaiveDate::ordinal0`](../date/struct.NaiveDate.html#method.ordinal0) method.
/// See also the [`NaiveDate::ordinal0`](./struct.NaiveDate.html#method.ordinal0) method.
///
/// # Example
///
@ -766,7 +765,7 @@ impl Datelike for NaiveDateTime {
/// Returns the day of week.
///
/// See also the [`NaiveDate::weekday`](../date/struct.NaiveDate.html#method.weekday) method.
/// See also the [`NaiveDate::weekday`](./struct.NaiveDate.html#method.weekday) method.
///
/// # Example
///
@ -791,7 +790,7 @@ impl Datelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveDate::with_year`](../date/struct.NaiveDate.html#method.with_year) method.
/// [`NaiveDate::with_year`](./struct.NaiveDate.html#method.with_year) method.
///
/// # Example
///
@ -812,7 +811,7 @@ impl Datelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveDate::with_month`](../date/struct.NaiveDate.html#method.with_month) method.
/// [`NaiveDate::with_month`](./struct.NaiveDate.html#method.with_month) method.
///
/// # Example
///
@ -834,7 +833,7 @@ impl Datelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveDate::with_month0`](../date/struct.NaiveDate.html#method.with_month0) method.
/// [`NaiveDate::with_month0`](./struct.NaiveDate.html#method.with_month0) method.
///
/// # Example
///
@ -856,7 +855,7 @@ impl Datelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveDate::with_day`](../date/struct.NaiveDate.html#method.with_day) method.
/// [`NaiveDate::with_day`](./struct.NaiveDate.html#method.with_day) method.
///
/// # Example
///
@ -877,7 +876,7 @@ impl Datelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveDate::with_day0`](../date/struct.NaiveDate.html#method.with_day0) method.
/// [`NaiveDate::with_day0`](./struct.NaiveDate.html#method.with_day0) method.
///
/// # Example
///
@ -898,7 +897,7 @@ impl Datelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveDate::with_ordinal`](../date/struct.NaiveDate.html#method.with_ordinal) method.
/// [`NaiveDate::with_ordinal`](./struct.NaiveDate.html#method.with_ordinal) method.
///
/// # Example
///
@ -926,7 +925,7 @@ impl Datelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveDate::with_ordinal0`](../date/struct.NaiveDate.html#method.with_ordinal0) method.
/// [`NaiveDate::with_ordinal0`](./struct.NaiveDate.html#method.with_ordinal0) method.
///
/// # Example
///
@ -953,7 +952,7 @@ impl Datelike for NaiveDateTime {
impl Timelike for NaiveDateTime {
/// Returns the hour number from 0 to 23.
///
/// See also the [`NaiveTime::hour`](../time/struct.NaiveTime.html#method.hour) method.
/// See also the [`NaiveTime::hour`](./struct.NaiveTime.html#method.hour) method.
///
/// # Example
///
@ -970,7 +969,7 @@ impl Timelike for NaiveDateTime {
/// Returns the minute number from 0 to 59.
///
/// See also the [`NaiveTime::minute`](../time/struct.NaiveTime.html#method.minute) method.
/// See also the [`NaiveTime::minute`](./struct.NaiveTime.html#method.minute) method.
///
/// # Example
///
@ -987,7 +986,7 @@ impl Timelike for NaiveDateTime {
/// Returns the second number from 0 to 59.
///
/// See also the [`NaiveTime::second`](../time/struct.NaiveTime.html#method.second) method.
/// See also the [`NaiveTime::second`](./struct.NaiveTime.html#method.second) method.
///
/// # Example
///
@ -1004,10 +1003,10 @@ impl Timelike for NaiveDateTime {
/// Returns the number of nanoseconds since the whole non-leap second.
/// The range from 1,000,000,000 to 1,999,999,999 represents
/// the [leap second](./naive/time/index.html#leap-second-handling).
/// the [leap second](./struct.NaiveTime.html#leap-second-handling).
///
/// See also the
/// [`NaiveTime::nanosecond`](../time/struct.NaiveTime.html#method.nanosecond) method.
/// [`NaiveTime::nanosecond`](./struct.NaiveTime.html#method.nanosecond) method.
///
/// # Example
///
@ -1027,7 +1026,7 @@ impl Timelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveTime::with_hour`](../time/struct.NaiveTime.html#method.with_hour) method.
/// [`NaiveTime::with_hour`](./struct.NaiveTime.html#method.with_hour) method.
///
/// # Example
///
@ -1049,7 +1048,7 @@ impl Timelike for NaiveDateTime {
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
///
/// See also the
/// [`NaiveTime::with_minute`](../time/struct.NaiveTime.html#method.with_minute) method.
/// [`NaiveTime::with_minute`](./struct.NaiveTime.html#method.with_minute) method.
///
/// # Example
///
@ -1073,7 +1072,7 @@ impl Timelike for NaiveDateTime {
/// the input range is restricted to 0 through 59.
///
/// See also the
/// [`NaiveTime::with_second`](../time/struct.NaiveTime.html#method.with_second) method.
/// [`NaiveTime::with_second`](./struct.NaiveTime.html#method.with_second) method.
///
/// # Example
///
@ -1097,7 +1096,7 @@ impl Timelike for NaiveDateTime {
/// the input range can exceed 1,000,000,000 for leap seconds.
///
/// See also the
/// [`NaiveTime::with_nanosecond`](../time/struct.NaiveTime.html#method.with_nanosecond)
/// [`NaiveTime::with_nanosecond`](./struct.NaiveTime.html#method.with_nanosecond)
/// method.
///
/// # Example
@ -1131,7 +1130,7 @@ impl hash::Hash for NaiveDateTime {
/// An addition of `Duration` to `NaiveDateTime` yields another `NaiveDateTime`.
///
/// As a part of Chrono's [leap second handling](../time/index.html#leap-second-handling),
/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
/// the addition assumes that **there is no leap second ever**,
/// except when the `NaiveDateTime` itself represents a leap second
/// in which case the assumption becomes that **there is exactly a single leap second ever**.
@ -1196,7 +1195,7 @@ impl Add<OldDuration> for NaiveDateTime {
/// A subtraction of `Duration` from `NaiveDateTime` yields another `NaiveDateTime`.
/// It is same to the addition with a negated `Duration`.
///
/// As a part of Chrono's [leap second handling](../time/index.html#leap-second-handling),
/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
/// the addition assumes that **there is no leap second ever**,
/// except when the `NaiveDateTime` itself represents a leap second
/// in which case the assumption becomes that **there is exactly a single leap second ever**.
@ -1365,7 +1364,7 @@ impl str::FromStr for NaiveDateTime {
fn test_encodable_json<F, E>(to_string: F)
where F: Fn(&NaiveDateTime) -> Result<String, E>, E: ::std::fmt::Debug
{
use naive::date;
use naive::{MIN_DATE, MAX_DATE};
assert_eq!(
to_string(&NaiveDate::from_ymd(2016, 7, 8).and_hms_milli(9, 10, 48, 90)).ok(),
@ -1380,10 +1379,10 @@ fn test_encodable_json<F, E>(to_string: F)
to_string(&NaiveDate::from_ymd(-1, 12, 31).and_hms_nano(23, 59, 59, 7)).ok(),
Some(r#""-0001-12-31T23:59:59.000000007""#.into()));
assert_eq!(
to_string(&date::MIN.and_hms(0, 0, 0)).ok(),
to_string(&MIN_DATE.and_hms(0, 0, 0)).ok(),
Some(r#""-262144-01-01T00:00:00""#.into()));
assert_eq!(
to_string(&date::MAX.and_hms_nano(23, 59, 59, 1_999_999_999)).ok(),
to_string(&MAX_DATE.and_hms_nano(23, 59, 59, 1_999_999_999)).ok(),
Some(r#""+262143-12-31T23:59:60.999999999""#.into()));
}
@ -1391,7 +1390,7 @@ fn test_encodable_json<F, E>(to_string: F)
fn test_decodable_json<F, E>(from_str: F)
where F: Fn(&str) -> Result<NaiveDateTime, E>, E: ::std::fmt::Debug
{
use naive::date;
use naive::{MIN_DATE, MAX_DATE};
assert_eq!(
from_str(r#""2016-07-08T09:10:48.090""#).ok(),
@ -1413,13 +1412,13 @@ fn test_decodable_json<F, E>(from_str: F)
Some(NaiveDate::from_ymd(-1, 12, 31).and_hms_nano(23, 59, 59, 7)));
assert_eq!(
from_str(r#""-262144-01-01T00:00:00""#).ok(),
Some(date::MIN.and_hms(0, 0, 0)));
Some(MIN_DATE.and_hms(0, 0, 0)));
assert_eq!(
from_str(r#""+262143-12-31T23:59:60.999999999""#).ok(),
Some(date::MAX.and_hms_nano(23, 59, 59, 1_999_999_999)));
Some(MAX_DATE.and_hms_nano(23, 59, 59, 1_999_999_999)));
assert_eq!(
from_str(r#""+262143-12-31T23:59:60.9999999999997""#).ok(), // excess digits are ignored
Some(date::MAX.and_hms_nano(23, 59, 59, 1_999_999_999)));
Some(MAX_DATE.and_hms_nano(23, 59, 59, 1_999_999_999)));
// bad formats
assert!(from_str(r#""""#).is_err());
@ -1510,11 +1509,11 @@ mod rustc_serialize {
pub mod serde {
use std::fmt;
use super::{NaiveDateTime};
use serde::{ser, de};
use serdelib::{ser, de};
/// Serialize a NaiveDateTime as a string
///
/// See the [`ts_seconds`](./ts_seconds/index.html) module to serialize as
/// See the [`ts_seconds`](./serde/ts_seconds/index.html) module to serialize as
/// a timestamp.
impl ser::Serialize for NaiveDateTime {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@ -1573,7 +1572,7 @@ pub mod serde {
/// # extern crate serde;
/// # extern crate chrono;
/// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, UTC};
/// use chrono::naive::datetime::serde::ts_seconds;
/// use chrono::naive::serde::ts_seconds;
/// #[derive(Deserialize, Serialize)]
/// struct S {
/// #[serde(with = "ts_seconds")]
@ -1596,7 +1595,7 @@ pub mod serde {
/// ```
pub mod ts_seconds {
use std::fmt;
use serde::{ser, de};
use serdelib::{ser, de};
use NaiveDateTime;
@ -1617,7 +1616,7 @@ pub mod serde {
/// # extern crate chrono;
/// # use chrono::{NaiveDateTime, UTC};
/// # use serde::Deserialize;
/// use chrono::naive::datetime::serde::ts_seconds::deserialize as from_ts;
/// use chrono::naive::serde::ts_seconds::deserialize as from_ts;
/// #[derive(Deserialize)]
/// struct S {
/// #[serde(deserialize_with = "from_ts")]
@ -1653,7 +1652,7 @@ pub mod serde {
/// # extern crate chrono;
/// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, UTC};
/// # use serde::Serialize;
/// use chrono::naive::datetime::serde::ts_seconds::serialize as to_ts;
/// use chrono::naive::serde::ts_seconds::serialize as to_ts;
/// #[derive(Serialize)]
/// struct S {
/// #[serde(serialize_with = "to_ts")]
@ -1720,7 +1719,7 @@ pub mod serde {
fn test_serde_bincode() {
// Bincode is relevant to test separately from JSON because
// it is not self-describing.
use naive::date::NaiveDate;
use naive::NaiveDate;
use self::bincode::{Infinite, serialize, deserialize};
let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_milli(9, 10, 48, 90);
@ -1734,8 +1733,7 @@ pub mod serde {
mod tests {
use super::NaiveDateTime;
use Datelike;
use naive::date as naive_date;
use naive::date::NaiveDate;
use naive::{NaiveDate, MIN_DATE, MAX_DATE};
use std::i64;
use oldtime::Duration;
@ -1772,17 +1770,15 @@ mod tests {
// overflow check
// assumes that we have correct values for MAX/MIN_DAYS_FROM_YEAR_0 from `naive::date`.
// (they are private constants, but the equivalence is tested in that module.)
let max_days_from_year_0 =
naive_date::MAX.signed_duration_since(NaiveDate::from_ymd(0,1,1));
check((0,1,1, 0,0,0), max_days_from_year_0, Some((naive_date::MAX.year(),12,31, 0,0,0)));
let max_days_from_year_0 = MAX_DATE.signed_duration_since(NaiveDate::from_ymd(0,1,1));
check((0,1,1, 0,0,0), max_days_from_year_0, Some((MAX_DATE.year(),12,31, 0,0,0)));
check((0,1,1, 0,0,0), max_days_from_year_0 + Duration::seconds(86399),
Some((naive_date::MAX.year(),12,31, 23,59,59)));
Some((MAX_DATE.year(),12,31, 23,59,59)));
check((0,1,1, 0,0,0), max_days_from_year_0 + Duration::seconds(86400), None);
check((0,1,1, 0,0,0), Duration::max_value(), None);
let min_days_from_year_0 =
naive_date::MIN.signed_duration_since(NaiveDate::from_ymd(0,1,1));
check((0,1,1, 0,0,0), min_days_from_year_0, Some((naive_date::MIN.year(),1,1, 0,0,0)));
let min_days_from_year_0 = MIN_DATE.signed_duration_since(NaiveDate::from_ymd(0,1,1));
check((0,1,1, 0,0,0), min_days_from_year_0, Some((MIN_DATE.year(),1,1, 0,0,0)));
check((0,1,1, 0,0,0), min_days_from_year_0 - Duration::seconds(1), None);
check((0,1,1, 0,0,0), Duration::min_value(), None);
}

312
src/naive/time.rs
View File

@ -2,159 +2,6 @@
// See README.md and LICENSE.txt for details.
//! ISO 8601 time without timezone.
//!
//! # Leap Second Handling
//!
//! Since 1960s, the manmade atomic clock has been so accurate that
//! it is much more accurate than Earth's own motion.
//! It became desirable to define the civil time in terms of the atomic clock,
//! but that risks the desynchronization of the civil time from Earth.
//! To account for this, the designers of the Coordinated Universal Time (UTC)
//! made that the UTC should be kept within 0.9 seconds of the observed Earth-bound time.
//! When the mean solar day is longer than the ideal (86,400 seconds),
//! the error slowly accumulates and it is necessary to add a **leap second**
//! to slow the UTC down a bit.
//! (We may also remove a second to speed the UTC up a bit, but it never happened.)
//! The leap second, if any, follows 23:59:59 of June 30 or December 31 in the UTC.
//!
//! Fast forward to the 21st century,
//! we have seen 26 leap seconds from January 1972 to December 2015.
//! Yes, 26 seconds. Probably you can read this paragraph within 26 seconds.
//! But those 26 seconds, and possibly more in the future, are never predictable,
//! and whether to add a leap second or not is known only before 6 months.
//! Internet-based clocks (via NTP) do account for known leap seconds,
//! but the system API normally doesn't (and often can't, with no network connection)
//! and there is no reliable way to retrieve leap second information.
//!
//! Chrono does not try to accurately implement leap seconds; it is impossible.
//! Rather, **it allows for leap seconds but behaves as if there are *no other* leap seconds.**
//! Various operations will ignore any possible leap second(s)
//! except when any of the operands were actually leap seconds.
//!
//! If you cannot tolerate this behavior,
//! you must use a separate `TimeZone` for the International Atomic Time (TAI).
//! TAI is like UTC but has no leap seconds, and thus slightly differs from UTC.
//! Chrono 0.3 does not provide such implementation, but it is planned for 0.4.
//!
//! ## Representing Leap Seconds
//!
//! The leap second is indicated via fractional seconds more than 1 second.
//! This makes possible to treat a leap second as the prior non-leap second
//! if you don't care about sub-second accuracy.
//! You should use the proper formatting to get the raw leap second.
//!
//! All methods accepting fractional seconds will accept such values.
//!
//! ~~~~
//! use chrono::{NaiveDate, NaiveTime, UTC, TimeZone};
//!
//! let t = NaiveTime::from_hms_milli(8, 59, 59, 1_000);
//!
//! let dt1 = NaiveDate::from_ymd(2015, 7, 1).and_hms_micro(8, 59, 59, 1_000_000);
//!
//! let dt2 = UTC.ymd(2015, 6, 30).and_hms_nano(23, 59, 59, 1_000_000_000);
//! # let _ = (t, dt1, dt2);
//! ~~~~
//!
//! Note that the leap second can happen anytime given an appropriate time zone;
//! 2015-07-01 01:23:60 would be a proper leap second if UTC+01:24 had existed.
//! Practically speaking, though, by the time of the first leap second on 1972-06-30,
//! every time zone offset around the world has standardized to the 5-minute alignment.
//!
//! ## Date And Time Arithmetics
//!
//! As a concrete example, let's assume that `03:00:60` and `04:00:60` are leap seconds.
//! (In reality, of course, leap seconds are separated by at least 6 months.)
//!
//! `Time + Duration`:
//!
//! - `03:00:00 + 1s = 03:00:01`.
//! - `03:00:59 + 60s = 03:02:00`.
//! - `03:00:59 + 1s = 03:01:00`.
//! - `03:00:60 + 1s = 03:01:00`.
//! Note that the sum is identical to the previous.
//! - `03:00:60 + 60s = 03:01:59`.
//! - `03:00:60 + 61s = 03:02:00`.
//! - `03:00:60.1 + 0.8s = 03:00:60.9`.
//!
//! `Time - Duration`:
//!
//! - `03:00:00 - 1s = 02:59:59`.
//! - `03:01:00 - 1s = 03:00:59`.
//! - `03:01:00 - 60s = 03:00:00`.
//! - `03:00:60 - 60s = 03:00:00`.
//! Note that the result is identical to the previous.
//! - `03:00:60.7 - 0.4s = 03:00:60.3`.
//! - `03:00:60.7 - 0.9s = 03:00:59.8`.
//!
//! `Time - Time`:
//!
//! - `04:00:00 - 03:00:00 = 3600s`.
//! - `03:01:00 - 03:00:00 = 60s`.
//! - `03:00:60 - 03:00:00 = 60s`.
//! Note that the difference is identical to the previous.
//! - `03:00:60.6 - 03:00:59.4 = 1.2s`.
//! - `03:01:00 - 03:00:59.8 = 0.2s`.
//! - `03:01:00 - 03:00:60.5 = 0.5s`.
//! Note that the difference is larger than the previous,
//! even though the leap second clearly follows the previous whole second.
//! - `04:00:60.9 - 03:00:60.1 =
//! (04:00:60.9 - 04:00:00) + (04:00:00 - 03:01:00) + (03:01:00 - 03:00:60.1) =
//! 60.9s + 3540s + 0.9s = 3601.8s`.
//!
//! In general,
//!
//! - `Time + Duration` unconditionally equals to `Duration + Time`.
//!
//! - `Time - Duration` unconditionally equals to `Time + (-Duration)`.
//!
//! - `Time1 - Time2` unconditionally equals to `-(Time2 - Time1)`.
//!
//! - Associativity does not generally hold, because
//! `(Time + Duration1) - Duration2` no longer equals to `Time + (Duration1 - Duration2)`
//! for two positive durations.
//!
//! - As a special case, `(Time + Duration) - Duration` also does not equal to `Time`.
//!
//! - If you can assume that all durations have the same sign, however,
//! then the associativity holds:
//! `(Time + Duration1) + Duration2` equals to `Time + (Duration1 + Duration2)`
//! for two positive durations.
//!
//! ## Reading And Writing Leap Seconds
//!
//! The "typical" leap seconds on the minute boundary are
//! correctly handled both in the formatting and parsing.
//! The leap second in the human-readable representation
//! will be represented as the second part being 60, as required by ISO 8601.
//!
//! ~~~~
//! use chrono::{UTC, TimeZone};
//!
//! let dt = UTC.ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_000);
//! assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60Z");
//! ~~~~
//!
//! There are hypothetical leap seconds not on the minute boundary
//! nevertheless supported by Chrono.
//! They are allowed for the sake of completeness and consistency;
//! there were several "exotic" time zone offsets with fractional minutes prior to UTC after all.
//! For such cases the human-readable representation is ambiguous
//! and would be read back to the next non-leap second.
//!
//! ~~~~
//! use chrono::{DateTime, UTC, TimeZone};
//!
//! let dt = UTC.ymd(2015, 6, 30).and_hms_milli(23, 56, 4, 1_000);
//! assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z");
//!
//! let dt = UTC.ymd(2015, 6, 30).and_hms(23, 56, 5);
//! assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z");
//! assert_eq!(DateTime::parse_from_rfc3339("2015-06-30T23:56:05Z").unwrap(), dt);
//! ~~~~
//!
//! Since Chrono alone cannot determine any existence of leap seconds,
//! **there is absolutely no guarantee that the leap second read has actually happened**.
use std::{str, fmt, hash};
use std::ops::{Add, Sub};
@ -168,9 +15,158 @@ use format::{parse, Parsed, ParseError, ParseResult, DelayedFormat, StrftimeItem
/// ISO 8601 time without timezone.
/// Allows for the nanosecond precision and optional leap second representation.
///
/// <a name="leap-second-what?"></a>
/// Chrono has a notable policy on the [leap second handling](./index.html#leap-second-handling),
/// designed to be maximally useful for typical users.
/// # Leap Second Handling
///
/// Since 1960s, the manmade atomic clock has been so accurate that
/// it is much more accurate than Earth's own motion.
/// It became desirable to define the civil time in terms of the atomic clock,
/// but that risks the desynchronization of the civil time from Earth.
/// To account for this, the designers of the Coordinated Universal Time (UTC)
/// made that the UTC should be kept within 0.9 seconds of the observed Earth-bound time.
/// When the mean solar day is longer than the ideal (86,400 seconds),
/// the error slowly accumulates and it is necessary to add a **leap second**
/// to slow the UTC down a bit.
/// (We may also remove a second to speed the UTC up a bit, but it never happened.)
/// The leap second, if any, follows 23:59:59 of June 30 or December 31 in the UTC.
///
/// Fast forward to the 21st century,
/// we have seen 26 leap seconds from January 1972 to December 2015.
/// Yes, 26 seconds. Probably you can read this paragraph within 26 seconds.
/// But those 26 seconds, and possibly more in the future, are never predictable,
/// and whether to add a leap second or not is known only before 6 months.
/// Internet-based clocks (via NTP) do account for known leap seconds,
/// but the system API normally doesn't (and often can't, with no network connection)
/// and there is no reliable way to retrieve leap second information.
///
/// Chrono does not try to accurately implement leap seconds; it is impossible.
/// Rather, **it allows for leap seconds but behaves as if there are *no other* leap seconds.**
/// Various operations will ignore any possible leap second(s)
/// except when any of the operands were actually leap seconds.
///
/// If you cannot tolerate this behavior,
/// you must use a separate `TimeZone` for the International Atomic Time (TAI).
/// TAI is like UTC but has no leap seconds, and thus slightly differs from UTC.
/// Chrono 0.3 does not provide such implementation, but it is planned for 0.4.
///
/// ## Representing Leap Seconds
///
/// The leap second is indicated via fractional seconds more than 1 second.
/// This makes possible to treat a leap second as the prior non-leap second
/// if you don't care about sub-second accuracy.
/// You should use the proper formatting to get the raw leap second.
///
/// All methods accepting fractional seconds will accept such values.
///
/// ~~~~
/// use chrono::{NaiveDate, NaiveTime, UTC, TimeZone};
///
/// let t = NaiveTime::from_hms_milli(8, 59, 59, 1_000);
///
/// let dt1 = NaiveDate::from_ymd(2015, 7, 1).and_hms_micro(8, 59, 59, 1_000_000);
///
/// let dt2 = UTC.ymd(2015, 6, 30).and_hms_nano(23, 59, 59, 1_000_000_000);
/// # let _ = (t, dt1, dt2);
/// ~~~~
///
/// Note that the leap second can happen anytime given an appropriate time zone;
/// 2015-07-01 01:23:60 would be a proper leap second if UTC+01:24 had existed.
/// Practically speaking, though, by the time of the first leap second on 1972-06-30,
/// every time zone offset around the world has standardized to the 5-minute alignment.
///
/// ## Date And Time Arithmetics
///
/// As a concrete example, let's assume that `03:00:60` and `04:00:60` are leap seconds.
/// (In reality, of course, leap seconds are separated by at least 6 months.)
///
/// `Time + Duration`:
///
/// - `03:00:00 + 1s = 03:00:01`.
/// - `03:00:59 + 60s = 03:02:00`.
/// - `03:00:59 + 1s = 03:01:00`.
/// - `03:00:60 + 1s = 03:01:00`.
/// Note that the sum is identical to the previous.
/// - `03:00:60 + 60s = 03:01:59`.
/// - `03:00:60 + 61s = 03:02:00`.
/// - `03:00:60.1 + 0.8s = 03:00:60.9`.
///
/// `Time - Duration`:
///
/// - `03:00:00 - 1s = 02:59:59`.
/// - `03:01:00 - 1s = 03:00:59`.
/// - `03:01:00 - 60s = 03:00:00`.
/// - `03:00:60 - 60s = 03:00:00`.
/// Note that the result is identical to the previous.
/// - `03:00:60.7 - 0.4s = 03:00:60.3`.
/// - `03:00:60.7 - 0.9s = 03:00:59.8`.
///
/// `Time - Time`:
///
/// - `04:00:00 - 03:00:00 = 3600s`.
/// - `03:01:00 - 03:00:00 = 60s`.
/// - `03:00:60 - 03:00:00 = 60s`.
/// Note that the difference is identical to the previous.
/// - `03:00:60.6 - 03:00:59.4 = 1.2s`.
/// - `03:01:00 - 03:00:59.8 = 0.2s`.
/// - `03:01:00 - 03:00:60.5 = 0.5s`.
/// Note that the difference is larger than the previous,
/// even though the leap second clearly follows the previous whole second.
/// - `04:00:60.9 - 03:00:60.1 =
/// (04:00:60.9 - 04:00:00) + (04:00:00 - 03:01:00) + (03:01:00 - 03:00:60.1) =
/// 60.9s + 3540s + 0.9s = 3601.8s`.
///
/// In general,
///
/// - `Time + Duration` unconditionally equals to `Duration + Time`.
///
/// - `Time - Duration` unconditionally equals to `Time + (-Duration)`.
///
/// - `Time1 - Time2` unconditionally equals to `-(Time2 - Time1)`.
///
/// - Associativity does not generally hold, because
/// `(Time + Duration1) - Duration2` no longer equals to `Time + (Duration1 - Duration2)`
/// for two positive durations.
///
/// - As a special case, `(Time + Duration) - Duration` also does not equal to `Time`.
///
/// - If you can assume that all durations have the same sign, however,
/// then the associativity holds:
/// `(Time + Duration1) + Duration2` equals to `Time + (Duration1 + Duration2)`
/// for two positive durations.
///
/// ## Reading And Writing Leap Seconds
///
/// The "typical" leap seconds on the minute boundary are
/// correctly handled both in the formatting and parsing.
/// The leap second in the human-readable representation
/// will be represented as the second part being 60, as required by ISO 8601.
///
/// ~~~~
/// use chrono::{UTC, TimeZone};
///
/// let dt = UTC.ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_000);
/// assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60Z");
/// ~~~~
///
/// There are hypothetical leap seconds not on the minute boundary
/// nevertheless supported by Chrono.
/// They are allowed for the sake of completeness and consistency;
/// there were several "exotic" time zone offsets with fractional minutes prior to UTC after all.
/// For such cases the human-readable representation is ambiguous
/// and would be read back to the next non-leap second.
///
/// ~~~~
/// use chrono::{DateTime, UTC, TimeZone};
///
/// let dt = UTC.ymd(2015, 6, 30).and_hms_milli(23, 56, 4, 1_000);
/// assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z");
///
/// let dt = UTC.ymd(2015, 6, 30).and_hms(23, 56, 5);
/// assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z");
/// assert_eq!(DateTime::parse_from_rfc3339("2015-06-30T23:56:05Z").unwrap(), dt);
/// ~~~~
///
/// Since Chrono alone cannot determine any existence of leap seconds,
/// **there is absolutely no guarantee that the leap second read has actually happened**.
#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
pub struct NaiveTime {
secs: u32,
@ -834,7 +830,7 @@ impl Timelike for NaiveTime {
/// Returns the number of nanoseconds since the whole non-leap second.
/// The range from 1,000,000,000 to 1,999,999,999 represents
/// the [leap second](./naive/time/index.html#leap-second-handling).
/// the [leap second](#leap-second-handling).
///
/// # Example
///
@ -1337,7 +1333,7 @@ mod rustc_serialize {
mod serde {
use std::fmt;
use super::NaiveTime;
use serde::{ser, de};
use serdelib::{ser, de};
// TODO not very optimized for space (binary formats would want something better)
// TODO round-trip for general leap seconds (not just those with second = 60)

6
src/offset/fixed.rs
View File

@ -9,10 +9,8 @@ use oldtime::Duration as OldDuration;
use Timelike;
use div::div_mod_floor;
use naive::time::NaiveTime;
use naive::date::NaiveDate;
use naive::datetime::NaiveDateTime;
use datetime::DateTime;
use naive::{NaiveTime, NaiveDate, NaiveDateTime};
use DateTime;
use super::{TimeZone, Offset, LocalResult};
/// The time zone with fixed offset, from UTC-23:59:59 to UTC+23:59:59.

7
src/offset/local.rs
View File

@ -6,11 +6,8 @@
use oldtime;
use {Datelike, Timelike};
use naive::date::NaiveDate;
use naive::time::NaiveTime;
use naive::datetime::NaiveDateTime;
use date::Date;
use datetime::DateTime;
use naive::{NaiveDate, NaiveTime, NaiveDateTime};
use {Date, DateTime};
use super::{TimeZone, LocalResult};
use super::fixed::FixedOffset;

56
src/offset/mod.rs
View File

@ -1,35 +1,29 @@
// This is a part of Chrono.
// See README.md and LICENSE.txt for details.
/*!
* The time zone, which calculates offsets from the local time to UTC.
*
* There are four operations provided by the `TimeZone` trait:
*
* 1. Converting the local `NaiveDateTime` to `DateTime<Tz>`
* 2. Converting the UTC `NaiveDateTime` to `DateTime<Tz>`
* 3. Converting `DateTime<Tz>` to the local `NaiveDateTime`
* 4. Constructing `DateTime<Tz>` objects from various offsets
*
* 1 is used for constructors. 2 is used for the `with_timezone` method of date and time types.
* 3 is used for other methods, e.g. `year()` or `format()`, and provided by an associated type
* which implements `Offset` (which then passed to `TimeZone` for actual implementations).
* Technically speaking `TimeZone` has a total knowledge about given timescale,
* but `Offset` is used as a cache to avoid the repeated conversion
* and provides implementations for 1 and 3.
* An `TimeZone` instance can be reconstructed from the corresponding `Offset` instance.
*/
//! The time zone, which calculates offsets from the local time to UTC.
//!
//! There are four operations provided by the `TimeZone` trait:
//!
//! 1. Converting the local `NaiveDateTime` to `DateTime<Tz>`
//! 2. Converting the UTC `NaiveDateTime` to `DateTime<Tz>`
//! 3. Converting `DateTime<Tz>` to the local `NaiveDateTime`
//! 4. Constructing `DateTime<Tz>` objects from various offsets
//!
//! 1 is used for constructors. 2 is used for the `with_timezone` method of date and time types.
//! 3 is used for other methods, e.g. `year()` or `format()`, and provided by an associated type
//! which implements `Offset` (which then passed to `TimeZone` for actual implementations).
//! Technically speaking `TimeZone` has a total knowledge about given timescale,
//! but `Offset` is used as a cache to avoid the repeated conversion
//! and provides implementations for 1 and 3.
//! An `TimeZone` instance can be reconstructed from the corresponding `Offset` instance.
use std::fmt;
use Weekday;
use naive::date::NaiveDate;
use naive::time::NaiveTime;
use naive::datetime::NaiveDateTime;
use date::Date;
use datetime::DateTime;
use naive::{NaiveDate, NaiveTime, NaiveDateTime};
use {Date, DateTime};
use format::{parse, Parsed, ParseResult, StrftimeItems};
use self::fixed::FixedOffset;
/// The conversion result from the local time to the timezone-aware datetime types.
#[derive(Clone, PartialEq, Debug)]
@ -165,8 +159,8 @@ pub trait Offset: Sized + Clone + fmt::Debug {
/// The time zone.
///
/// The methods here are the primarily constructors for [`Date`](../date/struct.Date.html) and
/// [`DateTime`](../datetime/struct.DateTime.html) types.
/// The methods here are the primarily constructors for [`Date`](../struct.Date.html) and
/// [`DateTime`](../struct.DateTime.html) types.
pub trait TimeZone: Sized + Clone {
/// An associated offset type.
/// This type is used to store the actual offset in date and time types.
@ -373,7 +367,11 @@ pub trait TimeZone: Sized + Clone {
}
}
pub mod utc;
pub mod fixed;
pub mod local;
mod utc;
mod fixed;
mod local;
pub use self::utc::UTC;
pub use self::fixed::FixedOffset;
pub use self::local::Local;

9
src/offset/utc.rs
View File

@ -6,12 +6,9 @@
use std::fmt;
use oldtime;
use naive::date::NaiveDate;
use naive::datetime::NaiveDateTime;
use date::Date;
use datetime::DateTime;
use super::{TimeZone, Offset, LocalResult};
use super::fixed::FixedOffset;
use naive::{NaiveDate, NaiveDateTime};
use {Date, DateTime};
use super::{TimeZone, Offset, LocalResult, FixedOffset};
/// The UTC time zone. This is the most efficient time zone when you don't need the local time.
/// It is also used as an offset (which is also a dummy type).