2014-07-29 07:14:46 +00:00
|
|
|
// This is a part of rust-chrono.
|
2015-01-04 06:08:19 +00:00
|
|
|
// Copyright (c) 2014-2015, Kang Seonghoon.
|
2014-07-29 07:14:46 +00:00
|
|
|
// See README.md and LICENSE.txt for details.
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
//! ISO 8601 date and time without timezone.
|
2014-07-29 07:14:46 +00:00
|
|
|
|
2015-02-18 14:27:12 +00:00
|
|
|
use std::{str, fmt, hash};
|
2015-01-03 22:45:07 +00:00
|
|
|
use std::ops::{Add, Sub};
|
2015-04-24 07:07:34 +00:00
|
|
|
use num::traits::ToPrimitive;
|
2014-07-29 07:14:46 +00:00
|
|
|
|
|
|
|
use {Weekday, Timelike, Datelike};
|
2014-11-24 05:49:13 +00:00
|
|
|
use div::div_mod_floor;
|
2014-07-29 07:14:46 +00:00
|
|
|
use duration::Duration;
|
|
|
|
use naive::time::NaiveTime;
|
|
|
|
use naive::date::NaiveDate;
|
2015-02-18 14:27:12 +00:00
|
|
|
use format::{Item, Numeric, Pad, Fixed};
|
|
|
|
use format::{parse, Parsed, ParseError, ParseResult, DelayedFormat, StrftimeItems};
|
2014-07-29 07:14:46 +00:00
|
|
|
|
|
|
|
/// ISO 8601 combined date and time without timezone.
|
2015-01-09 18:27:24 +00:00
|
|
|
#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
|
2015-04-28 09:42:18 +00:00
|
|
|
#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
|
2014-07-29 07:14:46 +00:00
|
|
|
pub struct NaiveDateTime {
|
|
|
|
date: NaiveDate,
|
|
|
|
time: NaiveTime,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl NaiveDateTime {
|
|
|
|
/// Makes a new `NaiveDateTime` from date and time components.
|
|
|
|
/// Equivalent to `date.and_time(time)` and many other helper constructors on `NaiveDate`.
|
|
|
|
#[inline]
|
|
|
|
pub fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime {
|
|
|
|
NaiveDateTime { date: date, time: time }
|
|
|
|
}
|
|
|
|
|
2014-07-31 01:09:54 +00:00
|
|
|
/// Makes a new `NaiveDateTime` from the number of non-leap seconds
|
2016-07-31 18:23:46 +00:00
|
|
|
/// since the midnight UTC on January 1, 1970 (aka "UNIX timestamp")
|
2015-02-18 17:45:29 +00:00
|
|
|
/// and the number of nanoseconds since the last whole non-leap second.
|
2014-07-31 01:09:54 +00:00
|
|
|
///
|
2015-09-11 17:41:38 +00:00
|
|
|
/// Panics on the out-of-range number of seconds and/or invalid nanosecond.
|
2014-07-31 01:09:54 +00:00
|
|
|
#[inline]
|
2015-02-18 17:45:29 +00:00
|
|
|
pub fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime {
|
|
|
|
let datetime = NaiveDateTime::from_timestamp_opt(secs, nsecs);
|
2014-07-31 01:09:54 +00:00
|
|
|
datetime.expect("invalid or out-of-range datetime")
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Makes a new `NaiveDateTime` from the number of non-leap seconds
|
2016-07-31 18:23:46 +00:00
|
|
|
/// since the midnight UTC on January 1, 1970 (aka "UNIX timestamp")
|
2015-02-18 17:45:29 +00:00
|
|
|
/// and the number of nanoseconds since the last whole non-leap second.
|
2014-07-31 01:09:54 +00:00
|
|
|
///
|
|
|
|
/// Returns `None` on the out-of-range number of seconds and/or invalid nanosecond.
|
|
|
|
#[inline]
|
2015-02-18 17:45:29 +00:00
|
|
|
pub fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime> {
|
2014-11-24 05:49:13 +00:00
|
|
|
let (days, secs) = div_mod_floor(secs, 86400);
|
2014-11-19 01:59:32 +00:00
|
|
|
let date = days.to_i32().and_then(|days| days.checked_add(719163))
|
2014-07-31 01:09:54 +00:00
|
|
|
.and_then(|days_ce| NaiveDate::from_num_days_from_ce_opt(days_ce));
|
|
|
|
let time = NaiveTime::from_num_seconds_from_midnight_opt(secs as u32, nsecs);
|
|
|
|
match (date, time) {
|
|
|
|
(Some(date), Some(time)) => Some(NaiveDateTime { date: date, time: time }),
|
|
|
|
(_, _) => None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// *Deprecated:* Same to [`NaiveDateTime::from_timestamp`](#method.from_timestamp).
|
2015-02-18 17:45:29 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn from_num_seconds_from_unix_epoch(secs: i64, nsecs: u32) -> NaiveDateTime {
|
|
|
|
NaiveDateTime::from_timestamp(secs, nsecs)
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// *Deprecated:* Same to [`NaiveDateTime::from_timestamp_opt`](#method.from_timestamp_opt).
|
2015-02-18 17:45:29 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn from_num_seconds_from_unix_epoch_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime> {
|
|
|
|
NaiveDateTime::from_timestamp_opt(secs, nsecs)
|
|
|
|
}
|
|
|
|
|
2015-02-04 17:16:35 +00:00
|
|
|
/// Parses a string with the specified format string and returns a new `NaiveDateTime`.
|
2015-09-06 12:30:09 +00:00
|
|
|
/// See the [`format::strftime` module](../../format/strftime/index.html)
|
|
|
|
/// on the supported escape sequences.
|
2015-02-15 12:26:11 +00:00
|
|
|
pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDateTime> {
|
2015-02-04 17:16:35 +00:00
|
|
|
let mut parsed = Parsed::new();
|
|
|
|
try!(parse(&mut parsed, s, StrftimeItems::new(fmt)));
|
|
|
|
parsed.to_naive_datetime_with_offset(0) // no offset adjustment
|
|
|
|
}
|
|
|
|
|
2014-07-29 07:14:46 +00:00
|
|
|
/// Retrieves a date component.
|
|
|
|
#[inline]
|
|
|
|
pub fn date(&self) -> NaiveDate {
|
|
|
|
self.date
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Retrieves a time component.
|
|
|
|
#[inline]
|
|
|
|
pub fn time(&self) -> NaiveTime {
|
|
|
|
self.time
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Returns the number of non-leap seconds since the midnight on January 1, 1970.
|
|
|
|
///
|
2014-07-29 07:14:46 +00:00
|
|
|
/// Note that this does *not* account for the timezone!
|
2016-07-31 18:23:46 +00:00
|
|
|
/// The true "UNIX timestamp" would count seconds since the midnight *UTC* on the epoch.
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
2015-02-18 17:45:29 +00:00
|
|
|
pub fn timestamp(&self) -> i64 {
|
2014-07-29 07:14:46 +00:00
|
|
|
let ndays = self.date.num_days_from_ce() as i64;
|
|
|
|
let nseconds = self.time.num_seconds_from_midnight() as i64;
|
|
|
|
(ndays - 719163) * 86400 + nseconds
|
|
|
|
}
|
2014-07-31 19:08:19 +00:00
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Returns the number of milliseconds since the last whole non-leap second.
|
2016-07-16 05:19:34 +00:00
|
|
|
///
|
2016-07-31 18:23:46 +00:00
|
|
|
/// The return value ranges from 0 to 999,
|
|
|
|
/// or for [leap seconds](../time/index.html#leap-second-handling), to 1,999.
|
2016-07-16 05:19:34 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn timestamp_subsec_millis(&self) -> u32 {
|
|
|
|
self.timestamp_subsec_nanos() / 1_000_000
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Returns the number of microseconds since the last whole non-leap second.
|
2016-07-16 05:19:34 +00:00
|
|
|
///
|
2016-07-31 18:23:46 +00:00
|
|
|
/// The return value ranges from 0 to 999,999,
|
|
|
|
/// or for [leap seconds](../time/index.html#leap-second-handling), to 1,999,999.
|
2016-07-16 05:19:34 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn timestamp_subsec_micros(&self) -> u32 {
|
|
|
|
self.timestamp_subsec_nanos() / 1_000
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Returns the number of nanoseconds since the last whole non-leap second.
|
2016-07-16 05:19:34 +00:00
|
|
|
///
|
2016-07-31 18:23:46 +00:00
|
|
|
/// 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.
|
2016-07-16 05:19:34 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn timestamp_subsec_nanos(&self) -> u32 {
|
|
|
|
self.time.nanosecond()
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// *Deprecated:* Same to [`NaiveDateTime::timestamp`](#method.timestamp).
|
2015-02-18 17:45:29 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn num_seconds_from_unix_epoch(&self) -> i64 {
|
|
|
|
self.timestamp()
|
|
|
|
}
|
|
|
|
|
2015-01-28 17:31:18 +00:00
|
|
|
/// Adds given `Duration` to the current date and time.
|
|
|
|
///
|
|
|
|
/// Returns `None` when it will result in overflow.
|
|
|
|
pub fn checked_add(self, rhs: Duration) -> Option<NaiveDateTime> {
|
|
|
|
// Duration does not directly give its parts, so we need some additional calculations.
|
|
|
|
let days = rhs.num_days();
|
|
|
|
let nanos = (rhs - Duration::days(days)).num_nanoseconds().unwrap();
|
|
|
|
debug_assert!(Duration::days(days) + Duration::nanoseconds(nanos) == rhs);
|
|
|
|
debug_assert!(-86400_000_000_000 < nanos && nanos < 86400_000_000_000);
|
|
|
|
|
|
|
|
let mut date = try_opt!(self.date.checked_add(Duration::days(days)));
|
|
|
|
let time = self.time + Duration::nanoseconds(nanos);
|
|
|
|
|
|
|
|
// time always wraps around, but date needs to be adjusted for overflow.
|
|
|
|
if nanos < 0 && time > self.time {
|
|
|
|
date = try_opt!(date.pred_opt());
|
|
|
|
} else if nanos > 0 && time < self.time {
|
|
|
|
date = try_opt!(date.succ_opt());
|
|
|
|
}
|
|
|
|
Some(NaiveDateTime { date: date, time: time })
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Subtracts given `Duration` from the current date and time.
|
|
|
|
///
|
|
|
|
/// Returns `None` when it will result in overflow.
|
|
|
|
pub fn checked_sub(self, rhs: Duration) -> Option<NaiveDateTime> {
|
|
|
|
// Duration does not directly give its parts, so we need some additional calculations.
|
|
|
|
let days = rhs.num_days();
|
|
|
|
let nanos = (rhs - Duration::days(days)).num_nanoseconds().unwrap();
|
|
|
|
debug_assert!(Duration::days(days) + Duration::nanoseconds(nanos) == rhs);
|
|
|
|
debug_assert!(-86400_000_000_000 < nanos && nanos < 86400_000_000_000);
|
|
|
|
|
|
|
|
let mut date = try_opt!(self.date.checked_sub(Duration::days(days)));
|
|
|
|
let time = self.time - Duration::nanoseconds(nanos);
|
|
|
|
|
|
|
|
// time always wraps around, but date needs to be adjusted for overflow.
|
|
|
|
if nanos > 0 && time > self.time {
|
|
|
|
date = try_opt!(date.pred_opt());
|
|
|
|
} else if nanos < 0 && time < self.time {
|
|
|
|
date = try_opt!(date.succ_opt());
|
|
|
|
}
|
|
|
|
Some(NaiveDateTime { date: date, time: time })
|
|
|
|
}
|
|
|
|
|
2015-02-14 03:33:12 +00:00
|
|
|
/// Formats the combined date and time with the specified formatting items.
|
|
|
|
#[inline]
|
2015-02-21 09:14:09 +00:00
|
|
|
pub fn format_with_items<'a, I>(&self, items: I) -> DelayedFormat<I>
|
2015-02-14 03:33:12 +00:00
|
|
|
where I: Iterator<Item=Item<'a>> + Clone {
|
|
|
|
DelayedFormat::new(Some(self.date.clone()), Some(self.time.clone()), items)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Formats the combined date and time with the specified format string.
|
2015-09-06 12:30:09 +00:00
|
|
|
/// See the [`format::strftime` module](../../format/strftime/index.html)
|
|
|
|
/// on the supported escape sequences.
|
2014-07-31 19:08:19 +00:00
|
|
|
#[inline]
|
2015-02-21 09:14:09 +00:00
|
|
|
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
|
2015-02-14 03:33:12 +00:00
|
|
|
self.format_with_items(StrftimeItems::new(fmt))
|
2014-07-31 19:08:19 +00:00
|
|
|
}
|
2014-07-29 07:14:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Datelike for NaiveDateTime {
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Returns the year number in the [calendar date](./index.html#calendar-date).
|
|
|
|
///
|
|
|
|
/// See also the [`NaiveDate::year`](../date/struct.NaiveDate.html#method.year) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.year(), 2015);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn year(&self) -> i32 {
|
|
|
|
self.date.year()
|
|
|
|
}
|
2014-07-29 07:14:46 +00:00
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Returns the month number starting from 1.
|
|
|
|
///
|
|
|
|
/// The return value ranges from 1 to 12.
|
|
|
|
///
|
|
|
|
/// See also the [`NaiveDate::month`](../date/struct.NaiveDate.html#method.month) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.month(), 9);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn month(&self) -> u32 {
|
|
|
|
self.date.month()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the month number starting from 0.
|
|
|
|
///
|
|
|
|
/// The return value ranges from 0 to 11.
|
|
|
|
///
|
|
|
|
/// See also the [`NaiveDate::month0`](../date/struct.NaiveDate.html#method.month0) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.month0(), 8);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn month0(&self) -> u32 {
|
|
|
|
self.date.month0()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the day of month starting from 1.
|
|
|
|
///
|
|
|
|
/// 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.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.day(), 25);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn day(&self) -> u32 {
|
|
|
|
self.date.day()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the day of month starting from 0.
|
|
|
|
///
|
|
|
|
/// 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.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.day0(), 24);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn day0(&self) -> u32 {
|
|
|
|
self.date.day0()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the day of year starting from 1.
|
|
|
|
///
|
|
|
|
/// 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.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.ordinal(), 268);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn ordinal(&self) -> u32 {
|
|
|
|
self.date.ordinal()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the day of year starting from 0.
|
|
|
|
///
|
|
|
|
/// 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.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.ordinal0(), 267);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn ordinal0(&self) -> u32 {
|
|
|
|
self.date.ordinal0()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the day of week.
|
|
|
|
///
|
|
|
|
/// See also the [`NaiveDate::weekday`](../date/struct.NaiveDate.html#method.weekday) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike, Weekday};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.weekday(), Weekday::Fri);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn weekday(&self) -> Weekday {
|
|
|
|
self.date.weekday()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn isoweekdate(&self) -> (i32, u32, Weekday) {
|
|
|
|
self.date.isoweekdate()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Makes a new `NaiveDateTime` with the year number changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveDate::with_year`](../date/struct.NaiveDate.html#method.with_year) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_year(2016), Some(NaiveDate::from_ymd(2016, 9, 25).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_year(-308), Some(NaiveDate::from_ymd(-308, 9, 25).and_hms(12, 34, 56)));
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_year(&self, year: i32) -> Option<NaiveDateTime> {
|
|
|
|
self.date.with_year(year).map(|d| NaiveDateTime { date: d, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the month number (starting from 1) changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveDate::with_month`](../date/struct.NaiveDate.html#method.with_month) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_month(10), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_month(13), None); // no month 13
|
|
|
|
/// assert_eq!(dt.with_month(2), None); // no February 30
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_month(&self, month: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.date.with_month(month).map(|d| NaiveDateTime { date: d, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the month number (starting from 0) changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveDate::with_month0`](../date/struct.NaiveDate.html#method.with_month0) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_month0(9), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_month0(12), None); // no month 13
|
|
|
|
/// assert_eq!(dt.with_month0(1), None); // no February 30
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_month0(&self, month0: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.date.with_month0(month0).map(|d| NaiveDateTime { date: d, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the day of month (starting from 1) changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveDate::with_day`](../date/struct.NaiveDate.html#method.with_day) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_day(30), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_day(31), None); // no September 31
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_day(&self, day: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.date.with_day(day).map(|d| NaiveDateTime { date: d, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the day of month (starting from 0) changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveDate::with_day0`](../date/struct.NaiveDate.html#method.with_day0) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_day0(29), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_day0(30), None); // no September 31
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_day0(&self, day0: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.date.with_day0(day0).map(|d| NaiveDateTime { date: d, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the day of year (starting from 1) changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveDate::with_ordinal`](../date/struct.NaiveDate.html#method.with_ordinal) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_ordinal(60),
|
|
|
|
/// Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_ordinal(366), None); // 2015 had only 365 days
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_ordinal(60),
|
|
|
|
/// Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_ordinal(366),
|
|
|
|
/// Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.date.with_ordinal(ordinal).map(|d| NaiveDateTime { date: d, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the day of year (starting from 0) changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveDate::with_ordinal0`](../date/struct.NaiveDate.html#method.with_ordinal0) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Datelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_ordinal0(59),
|
|
|
|
/// Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_ordinal0(365), None); // 2015 had only 365 days
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56);
|
|
|
|
/// assert_eq!(dt.with_ordinal0(59),
|
|
|
|
/// Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56)));
|
|
|
|
/// assert_eq!(dt.with_ordinal0(365),
|
|
|
|
/// Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.date.with_ordinal0(ordinal0).map(|d| NaiveDateTime { date: d, ..*self })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Timelike for NaiveDateTime {
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Returns the hour number from 0 to 23.
|
|
|
|
///
|
|
|
|
/// See also the [`NaiveTime::hour`](../time/struct.NaiveTime.html#method.hour) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.hour(), 12);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn hour(&self) -> u32 {
|
|
|
|
self.time.hour()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the minute number from 0 to 59.
|
|
|
|
///
|
|
|
|
/// See also the [`NaiveTime::minute`](../time/struct.NaiveTime.html#method.minute) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.minute(), 34);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn minute(&self) -> u32 {
|
|
|
|
self.time.minute()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the second number from 0 to 59.
|
|
|
|
///
|
|
|
|
/// See also the [`NaiveTime::second`](../time/struct.NaiveTime.html#method.second) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.second(), 56);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn second(&self) -> u32 {
|
|
|
|
self.time.second()
|
|
|
|
}
|
2014-07-29 07:14:46 +00:00
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// 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).
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveTime::nanosecond`](../time/struct.NaiveTime.html#method.nanosecond) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.nanosecond(), 789_000_000);
|
|
|
|
/// ~~~~
|
|
|
|
#[inline]
|
|
|
|
fn nanosecond(&self) -> u32 {
|
|
|
|
self.time.nanosecond()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Makes a new `NaiveDateTime` with the hour number changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveTime::with_hour`](../time/struct.NaiveTime.html#method.with_hour) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.with_hour(7),
|
|
|
|
/// Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(7, 34, 56, 789)));
|
|
|
|
/// assert_eq!(dt.with_hour(24), None);
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_hour(&self, hour: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.time.with_hour(hour).map(|t| NaiveDateTime { time: t, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the minute number changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveTime::with_minute`](../time/struct.NaiveTime.html#method.with_minute) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.with_minute(45),
|
|
|
|
/// Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 45, 56, 789)));
|
|
|
|
/// assert_eq!(dt.with_minute(60), None);
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_minute(&self, min: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.time.with_minute(min).map(|t| NaiveDateTime { time: t, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with the second number changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
/// As with the [`second`](#method.second) method,
|
|
|
|
/// the input range is restricted to 0 through 59.
|
|
|
|
///
|
|
|
|
/// See also the
|
|
|
|
/// [`NaiveTime::with_second`](../time/struct.NaiveTime.html#method.with_second) method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.with_second(17),
|
|
|
|
/// Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 17, 789)));
|
|
|
|
/// assert_eq!(dt.with_second(60), None);
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_second(&self, sec: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.time.with_second(sec).map(|t| NaiveDateTime { time: t, ..*self })
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// Makes a new `NaiveDateTime` with nanoseconds since the whole non-leap second changed.
|
|
|
|
///
|
|
|
|
/// Returns `None` when the resulting `NaiveDateTime` would be invalid.
|
|
|
|
/// As with the [`nanosecond`](#method.nanosecond) method,
|
|
|
|
/// 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)
|
|
|
|
/// method.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ~~~~
|
|
|
|
/// use chrono::{NaiveDate, NaiveDateTime, Timelike};
|
|
|
|
///
|
|
|
|
/// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
|
|
|
|
/// assert_eq!(dt.with_nanosecond(333_333_333),
|
|
|
|
/// Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 333_333_333)));
|
|
|
|
/// assert_eq!(dt.with_nanosecond(1_333_333_333), // leap second
|
|
|
|
/// Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 1_333_333_333)));
|
|
|
|
/// assert_eq!(dt.with_nanosecond(2_000_000_000), None);
|
|
|
|
/// ~~~~
|
2014-07-29 07:14:46 +00:00
|
|
|
#[inline]
|
|
|
|
fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime> {
|
|
|
|
self.time.with_nanosecond(nano).map(|t| NaiveDateTime { time: t, ..*self })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-31 18:23:46 +00:00
|
|
|
/// `NaiveDateTime` can be used as a key to the hash maps (in principle).
|
|
|
|
///
|
|
|
|
/// Practically this also takes account of fractional seconds, so it is not recommended.
|
|
|
|
/// (For the obvious reason this also distinguishes leap seconds from non-leap seconds.)
|
2015-02-21 09:14:09 +00:00
|
|
|
impl hash::Hash for NaiveDateTime {
|
|
|
|
fn hash<H: hash::Hasher>(&self, state: &mut H) {
|
|
|
|
self.date.hash(state);
|
|
|
|
self.time.hash(state);
|
|
|
|
}
|
2015-01-09 18:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-01-05 09:31:15 +00:00
|
|
|
impl Add<Duration> for NaiveDateTime {
|
|
|
|
type Output = NaiveDateTime;
|
|
|
|
|
2015-01-28 17:31:18 +00:00
|
|
|
#[inline]
|
2014-12-17 01:28:14 +00:00
|
|
|
fn add(self, rhs: Duration) -> NaiveDateTime {
|
2015-01-28 17:31:18 +00:00
|
|
|
self.checked_add(rhs).expect("`NaiveDateTime + Duration` overflowed")
|
2014-07-29 07:14:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-05 09:31:15 +00:00
|
|
|
impl Sub<NaiveDateTime> for NaiveDateTime {
|
|
|
|
type Output = Duration;
|
|
|
|
|
2014-12-17 01:28:14 +00:00
|
|
|
fn sub(self, rhs: NaiveDateTime) -> Duration {
|
2014-07-29 07:14:46 +00:00
|
|
|
(self.date - rhs.date) + (self.time - rhs.time)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-05 09:31:15 +00:00
|
|
|
impl Sub<Duration> for NaiveDateTime {
|
|
|
|
type Output = NaiveDateTime;
|
|
|
|
|
2014-11-28 14:53:22 +00:00
|
|
|
#[inline]
|
2015-01-28 17:31:18 +00:00
|
|
|
fn sub(self, rhs: Duration) -> NaiveDateTime {
|
|
|
|
self.checked_sub(rhs).expect("`NaiveDateTime - Duration` overflowed")
|
|
|
|
}
|
2014-11-28 14:53:22 +00:00
|
|
|
}
|
|
|
|
|
2015-01-24 08:45:12 +00:00
|
|
|
impl fmt::Debug for NaiveDateTime {
|
2014-07-29 07:14:46 +00:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2015-01-09 18:27:24 +00:00
|
|
|
write!(f, "{:?}T{:?}", self.date, self.time)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-24 08:45:12 +00:00
|
|
|
impl fmt::Display for NaiveDateTime {
|
2015-01-09 18:27:24 +00:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
write!(f, "{} {}", self.date, self.time)
|
2014-07-29 07:14:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-18 14:27:12 +00:00
|
|
|
impl str::FromStr for NaiveDateTime {
|
|
|
|
type Err = ParseError;
|
|
|
|
|
|
|
|
fn from_str(s: &str) -> ParseResult<NaiveDateTime> {
|
|
|
|
const ITEMS: &'static [Item<'static>] = &[
|
|
|
|
Item::Space(""), Item::Numeric(Numeric::Year, Pad::Zero),
|
|
|
|
Item::Space(""), Item::Literal("-"),
|
|
|
|
Item::Space(""), Item::Numeric(Numeric::Month, Pad::Zero),
|
|
|
|
Item::Space(""), Item::Literal("-"),
|
|
|
|
Item::Space(""), Item::Numeric(Numeric::Day, Pad::Zero),
|
|
|
|
Item::Space(""), Item::Literal("T"), // XXX shouldn't this be case-insensitive?
|
|
|
|
Item::Space(""), Item::Numeric(Numeric::Hour, Pad::Zero),
|
|
|
|
Item::Space(""), Item::Literal(":"),
|
|
|
|
Item::Space(""), Item::Numeric(Numeric::Minute, Pad::Zero),
|
|
|
|
Item::Space(""), Item::Literal(":"),
|
|
|
|
Item::Space(""), Item::Numeric(Numeric::Second, Pad::Zero),
|
|
|
|
Item::Fixed(Fixed::Nanosecond), Item::Space(""),
|
|
|
|
];
|
|
|
|
|
|
|
|
let mut parsed = Parsed::new();
|
|
|
|
try!(parse(&mut parsed, s, ITEMS.iter().cloned()));
|
|
|
|
parsed.to_naive_datetime_with_offset(0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-09 14:26:36 +00:00
|
|
|
#[cfg(feature = "serde")]
|
|
|
|
mod serde {
|
|
|
|
use super::NaiveDateTime;
|
|
|
|
use serde::{ser, de};
|
|
|
|
|
|
|
|
impl ser::Serialize for NaiveDateTime {
|
|
|
|
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
|
|
|
|
where S: ser::Serializer
|
|
|
|
{
|
2016-03-03 07:54:47 +00:00
|
|
|
serializer.serialize_str(&format!("{:?}", self))
|
2015-11-09 14:26:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct NaiveDateTimeVisitor;
|
|
|
|
|
|
|
|
impl de::Visitor for NaiveDateTimeVisitor {
|
|
|
|
type Value = NaiveDateTime;
|
|
|
|
|
|
|
|
fn visit_str<E>(&mut self, value: &str) -> Result<NaiveDateTime, E>
|
|
|
|
where E: de::Error
|
|
|
|
{
|
2016-03-03 07:54:47 +00:00
|
|
|
value.parse().map_err(|err| E::custom(format!("{}", err)))
|
2015-11-09 14:26:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl de::Deserialize for NaiveDateTime {
|
|
|
|
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
|
|
|
|
where D: de::Deserializer
|
|
|
|
{
|
2016-03-03 07:54:47 +00:00
|
|
|
deserializer.deserialize(NaiveDateTimeVisitor)
|
2015-11-09 14:26:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-29 07:14:46 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2014-07-31 01:09:54 +00:00
|
|
|
use super::NaiveDateTime;
|
2015-01-28 17:31:18 +00:00
|
|
|
use Datelike;
|
2014-07-29 07:14:46 +00:00
|
|
|
use duration::Duration;
|
2015-01-28 17:31:18 +00:00
|
|
|
use naive::date as naive_date;
|
2014-07-29 07:14:46 +00:00
|
|
|
use naive::date::NaiveDate;
|
2014-07-31 01:09:54 +00:00
|
|
|
use std::i64;
|
|
|
|
|
|
|
|
#[test]
|
2015-02-18 17:45:29 +00:00
|
|
|
fn test_datetime_from_timestamp() {
|
|
|
|
let from_timestamp = |secs| NaiveDateTime::from_timestamp_opt(secs, 0);
|
|
|
|
let ymdhms = |y,m,d,h,n,s| NaiveDate::from_ymd(y,m,d).and_hms(h,n,s);
|
2014-07-31 01:09:54 +00:00
|
|
|
assert_eq!(from_timestamp(-1), Some(ymdhms(1969, 12, 31, 23, 59, 59)));
|
|
|
|
assert_eq!(from_timestamp(0), Some(ymdhms(1970, 1, 1, 0, 0, 0)));
|
|
|
|
assert_eq!(from_timestamp(1), Some(ymdhms(1970, 1, 1, 0, 0, 1)));
|
|
|
|
assert_eq!(from_timestamp(1_000_000_000), Some(ymdhms(2001, 9, 9, 1, 46, 40)));
|
|
|
|
assert_eq!(from_timestamp(0x7fffffff), Some(ymdhms(2038, 1, 19, 3, 14, 7)));
|
|
|
|
assert_eq!(from_timestamp(i64::MIN), None);
|
|
|
|
assert_eq!(from_timestamp(i64::MAX), None);
|
|
|
|
}
|
2014-07-29 07:14:46 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_datetime_add() {
|
2015-01-28 17:31:18 +00:00
|
|
|
fn check((y,m,d,h,n,s): (i32,u32,u32,u32,u32,u32), rhs: Duration,
|
|
|
|
result: Option<(i32,u32,u32,u32,u32,u32)>) {
|
|
|
|
let lhs = NaiveDate::from_ymd(y, m, d).and_hms(h, n, s);
|
|
|
|
let sum = result.map(|(y,m,d,h,n,s)| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s));
|
|
|
|
assert_eq!(lhs.checked_add(rhs), sum);
|
|
|
|
assert_eq!(lhs.checked_sub(-rhs), sum);
|
|
|
|
};
|
|
|
|
|
|
|
|
check((2014,5,6, 7,8,9), Duration::seconds(3600 + 60 + 1), Some((2014,5,6, 8,9,10)));
|
|
|
|
check((2014,5,6, 7,8,9), Duration::seconds(-(3600 + 60 + 1)), Some((2014,5,6, 6,7,8)));
|
|
|
|
check((2014,5,6, 7,8,9), Duration::seconds(86399), Some((2014,5,7, 7,8,8)));
|
|
|
|
check((2014,5,6, 7,8,9), Duration::seconds(86400 * 10), Some((2014,5,16, 7,8,9)));
|
|
|
|
check((2014,5,6, 7,8,9), Duration::seconds(-86400 * 10), Some((2014,4,26, 7,8,9)));
|
|
|
|
check((2014,5,6, 7,8,9), Duration::seconds(86400 * 10), Some((2014,5,16, 7,8,9)));
|
|
|
|
|
|
|
|
// 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 - 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)));
|
|
|
|
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)));
|
|
|
|
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 - 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)));
|
|
|
|
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);
|
2014-07-29 07:14:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_datetime_sub() {
|
2015-03-02 11:50:03 +00:00
|
|
|
let ymdhms = |y,m,d,h,n,s| NaiveDate::from_ymd(y,m,d).and_hms(h,n,s);
|
2014-11-19 01:59:32 +00:00
|
|
|
assert_eq!(ymdhms(2014, 5, 6, 7, 8, 9) - ymdhms(2014, 5, 6, 7, 8, 9), Duration::zero());
|
2014-07-29 07:14:46 +00:00
|
|
|
assert_eq!(ymdhms(2014, 5, 6, 7, 8, 10) - ymdhms(2014, 5, 6, 7, 8, 9),
|
|
|
|
Duration::seconds(1));
|
|
|
|
assert_eq!(ymdhms(2014, 5, 6, 7, 8, 9) - ymdhms(2014, 5, 6, 7, 8, 10),
|
|
|
|
Duration::seconds(-1));
|
|
|
|
assert_eq!(ymdhms(2014, 5, 7, 7, 8, 9) - ymdhms(2014, 5, 6, 7, 8, 10),
|
|
|
|
Duration::seconds(86399));
|
|
|
|
assert_eq!(ymdhms(2001, 9, 9, 1, 46, 39) - ymdhms(1970, 1, 1, 0, 0, 0),
|
|
|
|
Duration::seconds(999_999_999));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2015-02-18 17:45:29 +00:00
|
|
|
fn test_datetime_timestamp() {
|
|
|
|
let to_timestamp = |y,m,d,h,n,s| NaiveDate::from_ymd(y,m,d).and_hms(h,n,s).timestamp();
|
2014-07-29 07:14:46 +00:00
|
|
|
assert_eq!(to_timestamp(1969, 12, 31, 23, 59, 59), -1);
|
|
|
|
assert_eq!(to_timestamp(1970, 1, 1, 0, 0, 0), 0);
|
|
|
|
assert_eq!(to_timestamp(1970, 1, 1, 0, 0, 1), 1);
|
|
|
|
assert_eq!(to_timestamp(2001, 9, 9, 1, 46, 40), 1_000_000_000);
|
|
|
|
assert_eq!(to_timestamp(2038, 1, 19, 3, 14, 7), 0x7fffffff);
|
|
|
|
}
|
2014-07-31 19:08:19 +00:00
|
|
|
|
2015-02-18 14:27:12 +00:00
|
|
|
#[test]
|
|
|
|
fn test_datetime_from_str() {
|
|
|
|
// valid cases
|
|
|
|
let valid = [
|
|
|
|
"2015-2-18T23:16:9.15",
|
|
|
|
"-77-02-18T23:16:09",
|
|
|
|
" +82701 - 05 - 6 T 15 : 9 : 60.898989898989 ",
|
|
|
|
];
|
|
|
|
for &s in &valid {
|
|
|
|
let d = match s.parse::<NaiveDateTime>() {
|
|
|
|
Ok(d) => d,
|
|
|
|
Err(e) => panic!("parsing `{}` has failed: {}", s, e)
|
|
|
|
};
|
|
|
|
let s_ = format!("{:?}", d);
|
|
|
|
// `s` and `s_` may differ, but `s.parse()` and `s_.parse()` must be same
|
|
|
|
let d_ = match s_.parse::<NaiveDateTime>() {
|
|
|
|
Ok(d) => d,
|
|
|
|
Err(e) => panic!("`{}` is parsed into `{:?}`, but reparsing that has failed: {}",
|
|
|
|
s, d, e)
|
|
|
|
};
|
|
|
|
assert!(d == d_, "`{}` is parsed into `{:?}`, but reparsed result \
|
|
|
|
`{:?}` does not match", s, d, d_);
|
|
|
|
}
|
|
|
|
|
|
|
|
// some invalid cases
|
|
|
|
// since `ParseErrorKind` is private, all we can do is to check if there was an error
|
|
|
|
assert!("".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("x".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("15".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("15:8:9".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("15-8-9".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("2015-15-15T15:15:15".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("2012-12-12T12:12:12x".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("2012-123-12T12:12:12".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("+ 82701-123-12T12:12:12".parse::<NaiveDateTime>().is_err());
|
|
|
|
assert!("+802701-123-12T12:12:12".parse::<NaiveDateTime>().is_err()); // out-of-bound
|
|
|
|
}
|
|
|
|
|
2015-02-04 17:16:35 +00:00
|
|
|
#[test]
|
2015-02-15 12:26:11 +00:00
|
|
|
fn test_datetime_parse_from_str() {
|
2015-03-02 11:50:03 +00:00
|
|
|
let ymdhms = |y,m,d,h,n,s| NaiveDate::from_ymd(y,m,d).and_hms(h,n,s);
|
2015-02-15 12:26:11 +00:00
|
|
|
assert_eq!(NaiveDateTime::parse_from_str("2014-5-7T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
|
2015-02-04 17:16:35 +00:00
|
|
|
Ok(ymdhms(2014, 5, 7, 12, 34, 56))); // ignore offset
|
2015-02-15 12:26:11 +00:00
|
|
|
assert_eq!(NaiveDateTime::parse_from_str("2015-W06-1 000000", "%G-W%V-%u%H%M%S"),
|
2015-02-04 17:16:35 +00:00
|
|
|
Ok(ymdhms(2015, 2, 2, 0, 0, 0)));
|
2015-02-15 12:26:11 +00:00
|
|
|
assert_eq!(NaiveDateTime::parse_from_str("Fri, 09 Aug 2013 23:54:35 GMT",
|
|
|
|
"%a, %d %b %Y %H:%M:%S GMT"),
|
2015-02-04 17:16:35 +00:00
|
|
|
Ok(ymdhms(2013, 8, 9, 23, 54, 35)));
|
2015-02-15 12:26:11 +00:00
|
|
|
assert!(NaiveDateTime::parse_from_str("Sat, 09 Aug 2013 23:54:35 GMT",
|
|
|
|
"%a, %d %b %Y %H:%M:%S GMT").is_err());
|
|
|
|
assert!(NaiveDateTime::parse_from_str("2014-5-7 12:3456", "%Y-%m-%d %H:%M:%S").is_err());
|
|
|
|
assert!(NaiveDateTime::parse_from_str("12:34:56", "%H:%M:%S").is_err()); // insufficient
|
2015-02-04 17:16:35 +00:00
|
|
|
}
|
|
|
|
|
2014-07-31 19:08:19 +00:00
|
|
|
#[test]
|
|
|
|
fn test_datetime_format() {
|
|
|
|
let dt = NaiveDate::from_ymd(2010, 9, 8).and_hms_milli(7, 6, 54, 321);
|
2015-01-09 18:27:24 +00:00
|
|
|
assert_eq!(dt.format("%c").to_string(), "Wed Sep 8 07:06:54 2010");
|
2015-01-26 12:14:50 +00:00
|
|
|
assert_eq!(dt.format("%s").to_string(), "1283929614");
|
2015-01-09 18:27:24 +00:00
|
|
|
assert_eq!(dt.format("%t%n%%%n%t").to_string(), "\t\n%\n\t");
|
2015-01-26 12:14:50 +00:00
|
|
|
|
|
|
|
// a horror of leap second: coming near to you.
|
|
|
|
let dt = NaiveDate::from_ymd(2012, 6, 30).and_hms_milli(23, 59, 59, 1_000);
|
|
|
|
assert_eq!(dt.format("%c").to_string(), "Sat Jun 30 23:59:60 2012");
|
|
|
|
assert_eq!(dt.format("%s").to_string(), "1341100799"); // not 1341100800, it's intentional.
|
2014-07-31 19:08:19 +00:00
|
|
|
}
|
2015-05-14 17:06:34 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_datetime_add_sub_invariant() { // issue #37
|
|
|
|
let base = NaiveDate::from_ymd(2000, 1, 1).and_hms(0, 0, 0);
|
|
|
|
let t = -946684799990000;
|
|
|
|
let time = base + Duration::microseconds(t);
|
|
|
|
assert_eq!(t, (time - base).num_microseconds().unwrap());
|
|
|
|
}
|
2015-11-09 14:26:36 +00:00
|
|
|
|
|
|
|
#[cfg(feature = "serde")]
|
|
|
|
extern crate serde_json;
|
|
|
|
|
|
|
|
#[cfg(feature = "serde")]
|
|
|
|
#[test]
|
|
|
|
fn test_serde_serialize() {
|
|
|
|
use self::serde_json::to_string;
|
|
|
|
|
|
|
|
let date = NaiveDate::from_ymd(2014, 7, 24).and_hms(12, 34, 6);
|
|
|
|
let serialized = to_string(&date).unwrap();
|
|
|
|
|
|
|
|
assert_eq!(serialized, "\"2014-07-24T12:34:06\"");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(feature = "serde")]
|
|
|
|
#[test]
|
|
|
|
fn test_serde_deserialize() {
|
|
|
|
use self::serde_json::from_str;
|
|
|
|
|
|
|
|
let date = NaiveDate::from_ymd(2014, 7, 24).and_hms(12, 34, 6);
|
|
|
|
let deserialized: NaiveDateTime = from_str("\"2014-07-24T12:34:06\"").unwrap();
|
|
|
|
|
|
|
|
assert_eq!(deserialized, date);
|
|
|
|
}
|
2014-07-29 07:14:46 +00:00
|
|
|
}
|