# Struct chrono::naive::NaiveDateTime [−] [src]

    pub struct NaiveDateTime { /* fields omitted */ }

ISO 8601 combined date and time without timezone.

# Example

`NaiveDateTime` is commonly created from `NaiveDate`.

    use chrono::{NaiveDate, NaiveDateTime};

    let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);

You can use typical date-like and time-like methods, provided that relevant traits are in the scope.

    use chrono::{Datelike, Timelike, Weekday};

    assert_eq!(dt.weekday(), Weekday::Fri);
    assert_eq!(dt.num_seconds_from_midnight(), 33011);

## Implementations

### `impl NaiveDateTime` [src]

#### `pub fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime` [src]

Makes a new `NaiveDateTime` from date and time components. Equivalent to `date.and_time(time)` and many other helper constructors on `NaiveDate`.

# Example

    use chrono::{NaiveDate, NaiveTime, NaiveDateTime};

    let d = NaiveDate::from_ymd(2015, 6, 3);
    let t = NaiveTime::from_hms_milli(12, 34, 56, 789);

    let dt = NaiveDateTime::new(d, t);
    assert_eq!(dt.date(), d);
    assert_eq!(dt.time(), t);

#### `pub fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime` [src]

Makes a new `NaiveDateTime` corresponding to a UTC date and time, from the number of non-leap seconds since the midnight UTC on January 1, 1970 (aka “UNIX timestamp”) and the number of nanoseconds since the last whole non-leap second.

For a non-naive version of this function see `TimeZone::timestamp`.

The nanosecond part can exceed 1,000,000,000 in order to represent the leap second. (The true “UNIX timestamp” cannot represent a leap second unambiguously.)

Panics on the out-of-range number of seconds and/or invalid nanosecond.

# Example

    use chrono::{NaiveDateTime, NaiveDate};

    let dt = NaiveDateTime::from_timestamp(0, 42_000_000);
    assert_eq!(dt, NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 0, 42));

    let dt = NaiveDateTime::from_timestamp(1_000_000_000, 0);
    assert_eq!(dt, NaiveDate::from_ymd(2001, 9, 9).and_hms(1, 46, 40));

#### `pub fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime>` [src]

Makes a new `NaiveDateTime` corresponding to a UTC date and time, from the number of non-leap seconds since the midnight UTC on January 1, 1970 (aka “UNIX timestamp”) 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. (The true “UNIX timestamp” cannot represent a leap second unambiguously.)

Returns `None` on the out-of-range number of seconds and/or invalid nanosecond.

# Example

    use chrono::{NaiveDateTime, NaiveDate};
    use std::i64;

    let from_timestamp_opt = NaiveDateTime::from_timestamp_opt;

    assert!(from_timestamp_opt(0, 0).is_some());
    assert!(from_timestamp_opt(0, 999_999_999).is_some());
    assert!(from_timestamp_opt(0, 1_500_000_000).is_some()); // leap second
    assert!(from_timestamp_opt(0, 2_000_000_000).is_none());
    assert!(from_timestamp_opt(i64::MAX, 0).is_none());

#### `pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDateTime>` [src]

Parses a string with the specified format string and returns a new `NaiveDateTime`. See the `format::strftime` module on the supported escape sequences.

# Example

    use chrono::{NaiveDateTime, NaiveDate};

    let parse_from_str = NaiveDateTime::parse_from_str;

    assert_eq!(parse_from_str("2015-09-05 23:56:04", "%Y-%m-%d %H:%M:%S"),
               Ok(NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4)));
    assert_eq!(parse_from_str("5sep2015pm012345.6789", "%d%b%Y%p%I%M%S%.f"),
               Ok(NaiveDate::from_ymd(2015, 9, 5).and_hms_micro(13, 23, 45, 678_900)));

Offset is ignored for the purpose of parsing.

    assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
               Ok(NaiveDate::from_ymd(2014, 5, 17).and_hms(12, 34, 56)));

Leap seconds are correctly handled by treating any time of the form `hh:mm:60` as a leap second. (This equally applies to the formatting, so the round trip is possible.)

    assert_eq!(parse_from_str("2015-07-01 08:59:60.123", "%Y-%m-%d %H:%M:%S%.f"),
               Ok(NaiveDate::from_ymd(2015, 7, 1).and_hms_milli(8, 59, 59, 1_123)));

Missing seconds are assumed to be zero, but out-of-bound times or insufficient fields are errors otherwise.

    assert_eq!(parse_from_str("94/9/4 7:15", "%y/%m/%d %H:%M"),
               Ok(NaiveDate::from_ymd(1994, 9, 4).and_hms(7, 15, 0)));

    assert!(parse_from_str("04m33s", "%Mm%Ss").is_err());
    assert!(parse_from_str("94/9/4 12", "%y/%m/%d %H").is_err());
    assert!(parse_from_str("94/9/4 17:60", "%y/%m/%d %H:%M").is_err());
    assert!(parse_from_str("94/9/4 24:00:00", "%y/%m/%d %H:%M:%S").is_err());

All parsed fields should be consistent to each other, otherwise it’s an error.

    let fmt = "%Y-%m-%d %H:%M:%S = UNIX timestamp %s";
    assert!(parse_from_str("2001-09-09 01:46:39 = UNIX timestamp 999999999", fmt).is_ok());
    assert!(parse_from_str("1970-01-01 00:00:00 = UNIX timestamp 1", fmt).is_err());

#### `pub fn date(&self) -> NaiveDate` [src]

Retrieves a date component.

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
    assert_eq!(dt.date(), NaiveDate::from_ymd(2016, 7, 8));

#### `pub fn time(&self) -> NaiveTime` [src]

Retrieves a time component.

# Example

    use chrono::{NaiveDate, NaiveTime};

    let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
    assert_eq!(dt.time(), NaiveTime::from_hms(9, 10, 11));

#### `pub fn timestamp(&self) -> i64` [src]

Returns the number of non-leap seconds since the midnight on January 1, 1970.

Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 980);
    assert_eq!(dt.timestamp(), 1);

    let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms(1, 46, 40);
    assert_eq!(dt.timestamp(), 1_000_000_000);

    let dt = NaiveDate::from_ymd(1969, 12, 31).and_hms(23, 59, 59);
    assert_eq!(dt.timestamp(), -1);

    let dt = NaiveDate::from_ymd(-1, 1, 1).and_hms(0, 0, 0);
    assert_eq!(dt.timestamp(), -62198755200);

#### `pub fn timestamp_millis(&self) -> i64` [src]

Returns the number of non-leap milliseconds since midnight on January 1, 1970.

Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.

Note also that this does reduce the number of years that can be represented from ~584 Billion to ~584 Million. (If this is a problem, please file an issue to let me know what domain needs millisecond precision over billions of years, I’m curious.)

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 444);
    assert_eq!(dt.timestamp_millis(), 1_444);

    let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms_milli(1, 46, 40, 555);
    assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);

    let dt = NaiveDate::from_ymd(1969, 12, 31).and_hms_milli(23, 59, 59, 100);
    assert_eq!(dt.timestamp_millis(), -900);

#### `pub fn timestamp_nanos(&self) -> i64` [src]

Returns the number of non-leap nanoseconds since midnight on January 1, 1970.

Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.

# Panics

Note also that this does reduce the number of years that can be represented from ~584 Billion to ~584 years. The dates that can be represented as nanoseconds are between 1677-09-21T00:12:44.0 and 2262-04-11T23:47:16.854775804.

(If this is a problem, please file an issue to let me know what domain needs nanosecond precision over millennia, I’m curious.)

# Example

    use chrono::{NaiveDate, NaiveDateTime};

    let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_nano(0, 0, 1, 444);
    assert_eq!(dt.timestamp_nanos(), 1_000_000_444);

    let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms_nano(1, 46, 40, 555);

    const A_BILLION: i64 = 1_000_000_000;
    let nanos = dt.timestamp_nanos();
    assert_eq!(nanos, 1_000_000_000_000_000_555);
    assert_eq!(
        dt,
        NaiveDateTime::from_timestamp(nanos / A_BILLION, (nanos % A_BILLION) as u32)
    );

#### `pub fn timestamp_subsec_millis(&self) -> u32` [src]

Returns the number of milliseconds since the last whole non-leap second.

The return value ranges from 0 to 999, or for leap seconds, to 1,999.

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789);
    assert_eq!(dt.timestamp_subsec_millis(), 123);

    let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890);
    assert_eq!(dt.timestamp_subsec_millis(), 1_234);

#### `pub fn timestamp_subsec_micros(&self) -> u32` [src]

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, to 1,999,999.

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789);
    assert_eq!(dt.timestamp_subsec_micros(), 123_456);

    let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890);
    assert_eq!(dt.timestamp_subsec_micros(), 1_234_567);

#### `pub fn timestamp_subsec_nanos(&self) -> u32` [src]

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, to 1,999,999,999.

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789);
    assert_eq!(dt.timestamp_subsec_nanos(), 123_456_789);

    let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890);
    assert_eq!(dt.timestamp_subsec_nanos(), 1_234_567_890);

#### `pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDateTime>` [src]

Adds given `Duration` to the current date and time.

As a part of Chrono’s 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.

Returns `None` when it will result in overflow.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    let hms = |h, m, s| d.and_hms(h, m, s);
    assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::zero()),
               Some(hms(3, 5, 7)));
    assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(1)),
               Some(hms(3, 5, 8)));
    assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(-1)),
               Some(hms(3, 5, 6)));
    assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(3600 + 60)),
               Some(hms(4, 6, 7)));
    assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(86_400)),
               Some(from_ymd(2016, 7, 9).and_hms(3, 5, 7)));

    let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
    assert_eq!(hmsm(3, 5, 7, 980).checked_add_signed(Duration::milliseconds(450)),
               Some(hmsm(3, 5, 8, 430)));

Overflow returns `None`.

    assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::days(1_000_000_000)), None);

Leap seconds are handled, but the addition assumes that it is the only leap second happened.

    let leap = hmsm(3, 5, 59, 1_300);
    assert_eq!(leap.checked_add_signed(Duration::zero()),
               Some(hmsm(3, 5, 59, 1_300)));
    assert_eq!(leap.checked_add_signed(Duration::milliseconds(-500)),
               Some(hmsm(3, 5, 59, 800)));
    assert_eq!(leap.checked_add_signed(Duration::milliseconds(500)),
               Some(hmsm(3, 5, 59, 1_800)));
    assert_eq!(leap.checked_add_signed(Duration::milliseconds(800)),
               Some(hmsm(3, 6, 0, 100)));
    assert_eq!(leap.checked_add_signed(Duration::seconds(10)),
               Some(hmsm(3, 6, 9, 300)));
    assert_eq!(leap.checked_add_signed(Duration::seconds(-10)),
               Some(hmsm(3, 5, 50, 300)));
    assert_eq!(leap.checked_add_signed(Duration::days(1)),
               Some(from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300)));

#### `pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDateTime>` [src]

Subtracts given `Duration` from the current date and time.

As a part of Chrono’s 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.

Returns `None` when it will result in overflow.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    let hms = |h, m, s| d.and_hms(h, m, s);
    assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::zero()),
               Some(hms(3, 5, 7)));
    assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(1)),
               Some(hms(3, 5, 6)));
    assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(-1)),
               Some(hms(3, 5, 8)));
    assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(3600 + 60)),
               Some(hms(2, 4, 7)));
    assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(86_400)),
               Some(from_ymd(2016, 7, 7).and_hms(3, 5, 7)));

    let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
    assert_eq!(hmsm(3, 5, 7, 450).checked_sub_signed(Duration::milliseconds(670)),
               Some(hmsm(3, 5, 6, 780)));

Overflow returns `None`.

    assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::days(1_000_000_000)), None);

Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.

    let leap = hmsm(3, 5, 59, 1_300);
    assert_eq!(leap.checked_sub_signed(Duration::zero()),
               Some(hmsm(3, 5, 59, 1_300)));
    assert_eq!(leap.checked_sub_signed(Duration::milliseconds(200)),
               Some(hmsm(3, 5, 59, 1_100)));
    assert_eq!(leap.checked_sub_signed(Duration::milliseconds(500)),
               Some(hmsm(3, 5, 59, 800)));
    assert_eq!(leap.checked_sub_signed(Duration::seconds(60)),
               Some(hmsm(3, 5, 0, 300)));
    assert_eq!(leap.checked_sub_signed(Duration::days(1)),
               Some(from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300)));

#### `pub fn signed_duration_since(self, rhs: NaiveDateTime) -> OldDuration` [src]

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, 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 there are exactly one (or two) leap second(s) ever.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    assert_eq!(d.and_hms(3, 5, 7).signed_duration_since(d.and_hms(2, 4, 6)),
               Duration::seconds(3600 + 60 + 1));

    // July 8 is 190th day in the year 2016
    let d0 = from_ymd(2016, 1, 1);
    assert_eq!(d.and_hms_milli(0, 7, 6, 500).signed_duration_since(d0.and_hms(0, 0, 0)),
               Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));

Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.

    let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
    assert_eq!(leap.signed_duration_since(from_ymd(2015, 6, 30).and_hms(23, 0, 0)),
               Duration::seconds(3600) + Duration::milliseconds(500));
    assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0).signed_duration_since(leap),
               Duration::seconds(3600) - Duration::milliseconds(500));

#### `pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>,` [src]

Formats the combined date and time with the specified formatting items. Otherwise it is the same as the ordinary `format` method.

The `Iterator` of items should be `Clone`able, since the resulting `DelayedFormat` value may be formatted multiple times.

# Example

    use chrono::NaiveDate;
    use chrono::format::strftime::StrftimeItems;

    let fmt = StrftimeItems::new("%Y-%m-%d %H:%M:%S");
    let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4);
    assert_eq!(dt.format_with_items(fmt.clone()).to_string(), "2015-09-05 23:56:04");
    assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(),    "2015-09-05 23:56:04");

The resulting `DelayedFormat` can be formatted directly via the `Display` trait.

    assert_eq!(format!("{}", dt.format_with_items(fmt)), "2015-09-05 23:56:04");

#### `pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>` [src]

Formats the combined date and time with the specified format string. See the `format::strftime` module on the supported escape sequences.

This returns a `DelayedFormat`, which gets converted to a string only when actual formatting happens. You may use the `to_string` method to get a `String`, or just feed it into `print!` and other formatting macros. (In this way it avoids the redundant memory allocation.)

A wrong format string does not issue an error immediately. Rather, converting or formatting the `DelayedFormat` fails. You are recommended to immediately use `DelayedFormat` for this reason.

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4);
    assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04");
    assert_eq!(dt.format("around %l %p on %b %-d").to_string(), "around 11 PM on Sep 5");

The resulting `DelayedFormat` can be formatted directly via the `Display` trait.

    assert_eq!(format!("{}", dt.format("%Y-%m-%d %H:%M:%S")), "2015-09-05 23:56:04");
    assert_eq!(format!("{}", dt.format("around %l %p on %b %-d")), "around 11 PM on Sep 5");

## Trait Implementations

### `impl Add<Duration> for NaiveDateTime` [src]

An addition of `Duration` to `NaiveDateTime` yields another `NaiveDateTime`.

As a part of Chrono’s 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.

Panics on underflow or overflow. Use `NaiveDateTime::checked_add_signed` to detect that.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    let hms = |h, m, s| d.and_hms(h, m, s);
    assert_eq!(hms(3, 5, 7) + Duration::zero(),             hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(1),         hms(3, 5, 8));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(-1),        hms(3, 5, 6));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(3600 + 60), hms(4, 6, 7));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(86_400),
               from_ymd(2016, 7, 9).and_hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) + Duration::days(365),
               from_ymd(2017, 7, 8).and_hms(3, 5, 7));

    let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
    assert_eq!(hmsm(3, 5, 7, 980) + Duration::milliseconds(450), hmsm(3, 5, 8, 430));

Leap seconds are handled, but the addition assumes that it is the only leap second happened.

    let leap = hmsm(3, 5, 59, 1_300);
    assert_eq!(leap + Duration::zero(),             hmsm(3, 5, 59, 1_300));
    assert_eq!(leap + Duration::milliseconds(-500), hmsm(3, 5, 59, 800));
    assert_eq!(leap + Duration::milliseconds(500),  hmsm(3, 5, 59, 1_800));
    assert_eq!(leap + Duration::milliseconds(800),  hmsm(3, 6, 0, 100));
    assert_eq!(leap + Duration::seconds(10),        hmsm(3, 6, 9, 300));
    assert_eq!(leap + Duration::seconds(-10),       hmsm(3, 5, 50, 300));
    assert_eq!(leap + Duration::days(1),
               from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300));

#### `type Output = NaiveDateTime`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: OldDuration) -> NaiveDateTime` [src]

Performs the `+` operation. Read more

### `impl Add<FixedOffset> for NaiveDateTime` [src]

#### `type Output = NaiveDateTime`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: FixedOffset) -> NaiveDateTime` [src]

Performs the `+` operation. Read more

### `impl AddAssign<Duration> for NaiveDateTime` [src]

#### `fn add_assign(&mut self, rhs: OldDuration)` [src]

Performs the `+=` operation. Read more

### `impl Clone for NaiveDateTime` [src]

#### `fn clone(&self) -> NaiveDateTime` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Copy for NaiveDateTime` [src]

### `impl Datelike for NaiveDateTime` [src]

#### `fn year(&self) -> i32` [src]

Returns the year number in the calendar date.

See also the `NaiveDate::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);

#### `fn month(&self) -> u32` [src]

Returns the month number starting from 1.

The return value ranges from 1 to 12.

See also the `NaiveDate::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);

#### `fn month0(&self) -> u32` [src]

Returns the month number starting from 0.

The return value ranges from 0 to 11.

See also the `NaiveDate::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);

#### `fn day(&self) -> u32` [src]

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` 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);

#### `fn day0(&self) -> u32` [src]

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` 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);

#### `fn ordinal(&self) -> u32` [src]

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` 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);

#### `fn ordinal0(&self) -> u32` [src]

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` 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);

#### `fn weekday(&self) -> Weekday` [src]

Returns the day of week.

See also the `NaiveDate::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);

#### `fn iso_week(&self) -> IsoWeek` [src]

Returns the ISO week.

#### `fn with_year(&self, year: i32) -> Option<NaiveDateTime>` [src]

Makes a new `NaiveDateTime` with the year number changed.

Returns `None` when the resulting `NaiveDateTime` would be invalid.

See also the `NaiveDate::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)));

#### `fn with_month(&self, month: u32) -> Option<NaiveDateTime>` [src]

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` 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

#### `fn with_month0(&self, month0: u32) -> Option<NaiveDateTime>` [src]

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` 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

#### `fn with_day(&self, day: u32) -> Option<NaiveDateTime>` [src]

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` 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

#### `fn with_day0(&self, day0: u32) -> Option<NaiveDateTime>` [src]

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` 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

#### `fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime>` [src]

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` 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)));

#### `fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime>` [src]

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` 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)));

#### `fn year_ce(&self) -> (bool, u32)` [src]

Returns the absolute year number starting from 1 with a boolean flag, which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD). Read more

#### `fn num_days_from_ce(&self) -> i32` [src]

Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1. Read more

### `impl Debug for NaiveDateTime` [src]

The `Debug` output of the naive date and time `dt` is the same as `dt.format("%Y-%m-%dT%H:%M:%S%.f")`.

The string printed can be readily parsed via the `parse` method on `str`.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (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.)

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
    assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");

Leap seconds may also be used.

    let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
    assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Display for NaiveDateTime` [src]

The `Display` output of the naive date and time `dt` is the same as `dt.format("%Y-%m-%d %H:%M:%S%.f")`.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (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.)

# Example

    use chrono::NaiveDate;

    let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
    assert_eq!(format!("{}", dt), "2016-11-15 07:39:24");

Leap seconds may also be used.

    let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
    assert_eq!(format!("{}", dt), "2015-06-30 23:59:60.500");

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Eq for NaiveDateTime` [src]

### `impl FromStr for NaiveDateTime` [src]

Parsing a `str` into a `NaiveDateTime` uses the same format, `%Y-%m-%dT%H:%M:%S%.f`, as in `Debug`.

# Example

    use chrono::{NaiveDateTime, NaiveDate};

    let dt = NaiveDate::from_ymd(2015, 9, 18).and_hms(23, 56, 4);
    assert_eq!("2015-09-18T23:56:04".parse::<NaiveDateTime>(), Ok(dt));

    let dt = NaiveDate::from_ymd(12345, 6, 7).and_hms_milli(7, 59, 59, 1_500); // leap second
    assert_eq!("+12345-6-7T7:59:60.5".parse::<NaiveDateTime>(), Ok(dt));

    assert!("foo".parse::<NaiveDateTime>().is_err());

#### `type Err = ParseError`

The associated error which can be returned from parsing.

#### `fn from_str(s: &str) -> ParseResult<NaiveDateTime>` [src]

Parses a string `s` to return a value of this type. Read more

### `impl Hash for NaiveDateTime` [src]

`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.)

#### `fn hash<H: Hasher>(&self, state: &mut H)` [src]

Feeds this value into the given `Hasher`. Read more

#### `pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0 [src]

Feeds a slice of this type into the given `Hasher`. Read more

### `impl Ord for NaiveDateTime` [src]

#### `fn cmp(&self, other: &NaiveDateTime) -> Ordering` [src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `#[must_use]pub fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]pub fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self` 1.50.0 [src]

Restrict a value to a certain interval. Read more

### `impl PartialEq<NaiveDateTime> for NaiveDateTime` [src]

#### `fn eq(&self, other: &NaiveDateTime) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &NaiveDateTime) -> bool` [src]

This method tests for `!=`.

### `impl PartialOrd<NaiveDateTime> for NaiveDateTime` [src]

#### `fn partial_cmp(&self, other: &NaiveDateTime) -> Option<Ordering>` [src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use]pub fn lt(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use]pub fn le(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use]pub fn gt(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use]pub fn ge(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl StructuralEq for NaiveDateTime` [src]

### `impl StructuralPartialEq for NaiveDateTime` [src]

### `impl Sub<Duration> for NaiveDateTime` [src]

A subtraction of `Duration` from `NaiveDateTime` yields another `NaiveDateTime`. It is the same as the addition with a negated `Duration`.

As a part of Chrono’s 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.

Panics on underflow or overflow. Use `NaiveDateTime::checked_sub_signed` to detect that.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    let hms = |h, m, s| d.and_hms(h, m, s);
    assert_eq!(hms(3, 5, 7) - Duration::zero(),             hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(1),         hms(3, 5, 6));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(-1),        hms(3, 5, 8));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(3600 + 60), hms(2, 4, 7));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(86_400),
               from_ymd(2016, 7, 7).and_hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) - Duration::days(365),
               from_ymd(2015, 7, 9).and_hms(3, 5, 7));

    let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
    assert_eq!(hmsm(3, 5, 7, 450) - Duration::milliseconds(670), hmsm(3, 5, 6, 780));

Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.

    let leap = hmsm(3, 5, 59, 1_300);
    assert_eq!(leap - Duration::zero(),            hmsm(3, 5, 59, 1_300));
    assert_eq!(leap - Duration::milliseconds(200), hmsm(3, 5, 59, 1_100));
    assert_eq!(leap - Duration::milliseconds(500), hmsm(3, 5, 59, 800));
    assert_eq!(leap - Duration::seconds(60),       hmsm(3, 5, 0, 300));
    assert_eq!(leap - Duration::days(1),
               from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300));

#### `type Output = NaiveDateTime`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: OldDuration) -> NaiveDateTime` [src]

Performs the `-` operation. Read more

### `impl Sub<FixedOffset> for NaiveDateTime` [src]

#### `type Output = NaiveDateTime`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: FixedOffset) -> NaiveDateTime` [src]

Performs the `-` operation. Read more

### `impl Sub<NaiveDateTime> for NaiveDateTime` [src]

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, 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 there are exactly one (or two) leap second(s) ever.

The implementation is a wrapper around `NaiveDateTime::signed_duration_since`.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    assert_eq!(d.and_hms(3, 5, 7) - d.and_hms(2, 4, 6), Duration::seconds(3600 + 60 + 1));

    // July 8 is 190th day in the year 2016
    let d0 = from_ymd(2016, 1, 1);
    assert_eq!(d.and_hms_milli(0, 7, 6, 500) - d0.and_hms(0, 0, 0),
               Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));

Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.

    let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
    assert_eq!(leap - from_ymd(2015, 6, 30).and_hms(23, 0, 0),
               Duration::seconds(3600) + Duration::milliseconds(500));
    assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0) - leap,
               Duration::seconds(3600) - Duration::milliseconds(500));

#### `type Output = OldDuration`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: NaiveDateTime) -> OldDuration` [src]

Performs the `-` operation. Read more

### `impl SubAssign<Duration> for NaiveDateTime` [src]

#### `fn sub_assign(&mut self, rhs: OldDuration)` [src]

Performs the `-=` operation. Read more

### `impl Timelike for NaiveDateTime` [src]

#### `fn hour(&self) -> u32` [src]

Returns the hour number from 0 to 23.

See also the `NaiveTime::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);

#### `fn minute(&self) -> u32` [src]

Returns the minute number from 0 to 59.

See also the `NaiveTime::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);

#### `fn second(&self) -> u32` [src]

Returns the second number from 0 to 59.

See also the `NaiveTime::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);

#### `fn nanosecond(&self) -> u32` [src]

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.

See also the `NaiveTime::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);

#### `fn with_hour(&self, hour: u32) -> Option<NaiveDateTime>` [src]

Makes a new `NaiveDateTime` with the hour number changed.

Returns `None` when the resulting `NaiveDateTime` would be invalid.

See also the `NaiveTime::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);

#### `fn with_minute(&self, min: u32) -> Option<NaiveDateTime>` [src]

Makes a new `NaiveDateTime` with the minute number changed.

Returns `None` when the resulting `NaiveDateTime` would be invalid.

See also the `NaiveTime::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);

#### `fn with_second(&self, sec: u32) -> Option<NaiveDateTime>` [src]

Makes a new `NaiveDateTime` with the second number changed.

Returns `None` when the resulting `NaiveDateTime` would be invalid. As with the `second` method, the input range is restricted to 0 through 59.

See also the `NaiveTime::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);

#### `fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime>` [src]

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, the input range can exceed 1,000,000,000 for leap seconds.

See also the `NaiveTime::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);

#### `fn hour12(&self) -> (bool, u32)` [src]

Returns the hour number from 1 to 12 with a boolean flag, which is false for AM and true for PM. Read more

#### `fn num_seconds_from_midnight(&self) -> u32` [src]

Returns the number of non-leap seconds past the last midnight.

## Auto Trait Implementations

### `impl RefUnwindSafe for NaiveDateTime`

### `impl Send for NaiveDateTime`

### `impl Sync for NaiveDateTime`

### `impl Unpin for NaiveDateTime`

### `impl UnwindSafe for NaiveDateTime`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.