[−][src]Struct chrono::naive::date::NaiveDate

pub struct NaiveDate { /* fields omitted */ }

ISO 8601 calendar date without timezone. Allows for every proleptic Gregorian date from Jan 1, 262145 BCE to Dec 31, 262143 CE. Also supports the conversion from ISO 8601 ordinal and week date.

Methods

`impl NaiveDate`
[src]

`pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate`
[src]

Makes a new NaiveDate from the calendar date (year, month and day).

Panics on the out-of-range date, invalid month and/or day.

Example

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

let d = NaiveDate::from_ymd(2015, 3, 14);
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.ordinal(), 73); // day of year
assert_eq!(d.isoweekdate(), (2015, 11, Weekday::Sat)); // ISO week and weekday
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE

`pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>`
[src]

Makes a new NaiveDate from the calendar date (year, month and day).

Returns None on the out-of-range date, invalid month and/or day.

Example

use chrono::NaiveDate;

let ymd = |y,m,d| NaiveDate::from_ymd_opt(y, m, d);
assert!(ymd(2015, 3, 14).is_some());
assert!(ymd(2015, 0, 14).is_none());
assert!(ymd(2015, 2, 29).is_none());
assert!(ymd(-4, 2, 29).is_some()); // 5 BCE is a leap year
assert!(ymd(400000, 1, 1).is_none());
assert!(ymd(-400000, 1, 1).is_none());

`pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate`
[src]

Makes a new NaiveDate from the ordinal date (year and day of the year).

Panics on the out-of-range date and/or invalid day of year.

Example

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

let d = NaiveDate::from_yo(2015, 73);
assert_eq!(d.ordinal(), 73);
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.isoweekdate(), (2015, 11, Weekday::Sat)); // ISO week and weekday
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE

`pub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>`
[src]

Makes a new NaiveDate from the ordinal date (year and day of the year).

Returns None on the out-of-range date and/or invalid day of year.

Example

use chrono::NaiveDate;

let yo = |y,o| NaiveDate::from_yo_opt(y, o);
assert!(yo(2015, 100).is_some());
assert!(yo(2015, 0).is_none());
assert!(yo(2015, 365).is_some());
assert!(yo(2015, 366).is_none());
assert!(yo(-4, 366).is_some()); // 5 BCE is a leap year
assert!(yo(400000, 1).is_none());
assert!(yo(-400000, 1).is_none());

`pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate`
[src]

Makes a new NaiveDate from the ISO week date (year, week number and day of the week). The resulting NaiveDate may have a different year from the input year.

Panics on the out-of-range date and/or invalid week number.

Example

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

let d = NaiveDate::from_isoywd(2015, 11, Weekday::Sat);
assert_eq!(d.isoweekdate(), (2015, 11, Weekday::Sat));
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.ordinal(), 73); // day of year
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE

`pub fn from_isoywd_opt( year: i32, week: u32, weekday: Weekday ) -> Option<NaiveDate>`
[src]

Makes a new NaiveDate from the ISO week date (year, week number and day of the week). The resulting NaiveDate may have a different year from the input year.

Returns None on the out-of-range date and/or invalid week number.

Example

use chrono::{NaiveDate, Weekday};

let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d);
let isoywd = |y,w,d| NaiveDate::from_isoywd_opt(y, w, d);

assert_eq!(isoywd(2015, 0, Weekday::Sun), None);
assert_eq!(isoywd(2015, 10, Weekday::Sun), Some(ymd(2015, 3, 8)));
assert_eq!(isoywd(2015, 30, Weekday::Mon), Some(ymd(2015, 7, 20)));
assert_eq!(isoywd(2015, 60, Weekday::Mon), None);

assert_eq!(isoywd(400000, 10, Weekday::Fri), None);
assert_eq!(isoywd(-400000, 10, Weekday::Sat), None);

The year number of ISO week date may differ from that of the calendar date.

//           Mo Tu We Th Fr Sa Su
// 2014-W52  22 23 24 25 26 27 28    has 4+ days of new year,
// 2015-W01  29 30 31  1  2  3  4 <- so this is the first week
assert_eq!(isoywd(2014, 52, Weekday::Sun), Some(ymd(2014, 12, 28)));
assert_eq!(isoywd(2014, 53, Weekday::Mon), None);
assert_eq!(isoywd(2015, 1, Weekday::Mon), Some(ymd(2014, 12, 29)));

// 2015-W52  21 22 23 24 25 26 27    has 4+ days of old year,
// 2015-W53  28 29 30 31  1  2  3 <- so this is the last week
// 2016-W01   4  5  6  7  8  9 10
assert_eq!(isoywd(2015, 52, Weekday::Sun), Some(ymd(2015, 12, 27)));
assert_eq!(isoywd(2015, 53, Weekday::Sun), Some(ymd(2016, 1, 3)));
assert_eq!(isoywd(2015, 54, Weekday::Mon), None);
assert_eq!(isoywd(2016, 1, Weekday::Mon), Some(ymd(2016, 1, 4)));

`pub fn from_num_days_from_ce(days: i32) -> NaiveDate`
[src]

Makes a new NaiveDate from the number of days since January 1, 1 (Day 1) in the proleptic Gregorian calendar.

Panics on the out-of-range date.

Example

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

let d = NaiveDate::from_num_days_from_ce(735671);
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.ordinal(), 73); // day of year
assert_eq!(d.isoweekdate(), (2015, 11, Weekday::Sat)); // ISO week and weekday

While not directly supported by Chrono, it is easy to convert from the Julian day number (January 1, 4713 BCE in the Julian calendar being Day 0) to Gregorian with this method. (Note that this panics when jd is out of range.)

use chrono::NaiveDate;

fn jd_to_date(jd: i32) -> NaiveDate {
    // keep in mind that the Julian day number is 0-based
    // while this method requires an 1-based number.
    NaiveDate::from_num_days_from_ce(jd - 1721425)
}

// January 1, 4713 BCE in Julian = November 24, 4714 BCE in Gregorian
assert_eq!(jd_to_date(0), NaiveDate::from_ymd(-4713, 11, 24));

assert_eq!(jd_to_date(1721426), NaiveDate::from_ymd(1, 1, 1));
assert_eq!(jd_to_date(2450000), NaiveDate::from_ymd(1995, 10, 9));
assert_eq!(jd_to_date(2451545), NaiveDate::from_ymd(2000, 1, 1));

`pub fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate>`
[src]

Makes a new NaiveDate from the number of days since January 1, 1 (Day 1) in the proleptic Gregorian calendar.

Returns None on the out-of-range date.

Example

use chrono::NaiveDate;

let days = |ndays| NaiveDate::from_num_days_from_ce_opt(ndays);
assert_eq!(days(730000),     Some(NaiveDate::from_ymd(1999, 9, 3)));
assert_eq!(days(1),          Some(NaiveDate::from_ymd(1, 1, 1)));
assert_eq!(days(0),          Some(NaiveDate::from_ymd(0, 12, 31)));
assert_eq!(days(-1),         Some(NaiveDate::from_ymd(0, 12, 30)));
assert_eq!(days(100000000),  None);
assert_eq!(days(-100000000), None);

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

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

Example

use chrono::NaiveDate;

assert_eq!(NaiveDate::parse_from_str("2015-09-05", "%Y-%m-%d"),
           Ok(NaiveDate::from_ymd(2015, 9, 5)));
assert_eq!(NaiveDate::parse_from_str("5sep2015", "%d%b%Y"),
           Ok(NaiveDate::from_ymd(2015, 9, 5)));

Time and offset is ignored for the purpose of parsing.

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

Out-of-bound dates or insufficient fields are errors.

assert!(NaiveDate::parse_from_str("2015/9", "%Y/%m").is_err());
assert!(NaiveDate::parse_from_str("2015/9/31", "%Y/%m/%d").is_err());

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

assert!(NaiveDate::parse_from_str("Sat, 09 Aug 2013", "%a, %d %b %Y").is_err());

`pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime`
[src]

Makes a new NaiveDateTime from the current date and given NaiveTime.

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 = d.and_time(t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);

`pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime`
[src]

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_* methods with a subsecond parameter instead.

Panics on invalid hour, minute and/or second.

Example

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

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms(12, 34, 56);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);

`pub fn and_hms_opt( &self, hour: u32, min: u32, sec: u32 ) -> Option<NaiveDateTime>`
[src]

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_*_opt methods with a subsecond parameter instead.

Returns None on invalid hour, minute and/or second.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_opt(12, 34, 56).is_some());
assert!(d.and_hms_opt(12, 34, 60).is_none()); // use `and_hms_milli_opt` instead
assert!(d.and_hms_opt(12, 60, 56).is_none());
assert!(d.and_hms_opt(24, 34, 56).is_none());

`pub fn and_hms_milli( &self, hour: u32, min: u32, sec: u32, milli: u32 ) -> NaiveDateTime`
[src]

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.

Panics on invalid hour, minute, second and/or millisecond.

Example

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

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms_milli(12, 34, 56, 789);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_000_000);

`pub fn and_hms_milli_opt( &self, hour: u32, min: u32, sec: u32, milli: u32 ) -> Option<NaiveDateTime>`
[src]

Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.

The millisecond part can exceed 1,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or millisecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_milli_opt(12, 34, 56,   789).is_some());
assert!(d.and_hms_milli_opt(12, 34, 59, 1_789).is_some()); // leap second
assert!(d.and_hms_milli_opt(12, 34, 59, 2_789).is_none());
assert!(d.and_hms_milli_opt(12, 34, 60,   789).is_none());
assert!(d.and_hms_milli_opt(12, 60, 56,   789).is_none());
assert!(d.and_hms_milli_opt(24, 34, 56,   789).is_none());

`pub fn and_hms_micro( &self, hour: u32, min: u32, sec: u32, micro: u32 ) -> NaiveDateTime`
[src]

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.

Panics on invalid hour, minute, second and/or microsecond.

Example

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

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms_micro(12, 34, 56, 789_012);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_000);

`pub fn and_hms_micro_opt( &self, hour: u32, min: u32, sec: u32, micro: u32 ) -> Option<NaiveDateTime>`
[src]

Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.

The microsecond part can exceed 1,000,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or microsecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_micro_opt(12, 34, 56,   789_012).is_some());
assert!(d.and_hms_micro_opt(12, 34, 59, 1_789_012).is_some()); // leap second
assert!(d.and_hms_micro_opt(12, 34, 59, 2_789_012).is_none());
assert!(d.and_hms_micro_opt(12, 34, 60,   789_012).is_none());
assert!(d.and_hms_micro_opt(12, 60, 56,   789_012).is_none());
assert!(d.and_hms_micro_opt(24, 34, 56,   789_012).is_none());

`pub fn and_hms_nano( &self, hour: u32, min: u32, sec: u32, nano: u32 ) -> NaiveDateTime`
[src]

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.

Panics on invalid hour, minute, second and/or nanosecond.

Example

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

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms_nano(12, 34, 56, 789_012_345);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_345);

`pub fn and_hms_nano_opt( &self, hour: u32, min: u32, sec: u32, nano: u32 ) -> Option<NaiveDateTime>`
[src]

Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.

The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or nanosecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_nano_opt(12, 34, 56,   789_012_345).is_some());
assert!(d.and_hms_nano_opt(12, 34, 59, 1_789_012_345).is_some()); // leap second
assert!(d.and_hms_nano_opt(12, 34, 59, 2_789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 34, 60,   789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 60, 56,   789_012_345).is_none());
assert!(d.and_hms_nano_opt(24, 34, 56,   789_012_345).is_none());

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

Makes a new NaiveDate for the next calendar date.

Panics when self is the last representable date.

Example

use chrono::NaiveDate;

assert_eq!(NaiveDate::from_ymd(2015,  6,  3).succ(), NaiveDate::from_ymd(2015, 6, 4));
assert_eq!(NaiveDate::from_ymd(2015,  6, 30).succ(), NaiveDate::from_ymd(2015, 7, 1));
assert_eq!(NaiveDate::from_ymd(2015, 12, 31).succ(), NaiveDate::from_ymd(2016, 1, 1));

`pub fn succ_opt(&self) -> Option<NaiveDate>`
[src]

Makes a new NaiveDate for the next calendar date.

Returns None when self is the last representable date.

Example

use chrono::NaiveDate;
use chrono::naive::date::MAX;

assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ_opt(),
           Some(NaiveDate::from_ymd(2015, 6, 4)));
assert_eq!(MAX.succ_opt(), None);

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

Makes a new NaiveDate for the previous calendar date.

Panics when self is the first representable date.

Example

use chrono::NaiveDate;

assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred(), NaiveDate::from_ymd(2015,  6,  2));
assert_eq!(NaiveDate::from_ymd(2015, 6, 1).pred(), NaiveDate::from_ymd(2015,  5, 31));
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).pred(), NaiveDate::from_ymd(2014, 12, 31));

`pub fn pred_opt(&self) -> Option<NaiveDate>`
[src]

Makes a new NaiveDate for the previous calendar date.

Returns None when self is the first representable date.

Example

use chrono::NaiveDate;
use chrono::naive::date::MIN;

assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred_opt(),
           Some(NaiveDate::from_ymd(2015, 6, 2)));
assert_eq!(MIN.pred_opt(), None);

`pub fn checked_add(self, rhs: Duration) -> Option<NaiveDate>`
[src]

Adds the days part of given Duration to the current date.

Returns None when it will result in overflow.

Example

use chrono::{NaiveDate, Duration};
use chrono::naive::date::MAX;

let d = NaiveDate::from_ymd(2015, 9, 5);
assert_eq!(d.checked_add(Duration::days(40)), Some(NaiveDate::from_ymd(2015, 10, 15)));
assert_eq!(d.checked_add(Duration::days(-40)), Some(NaiveDate::from_ymd(2015, 7, 27)));
assert_eq!(d.checked_add(Duration::days(1000_000_000)), None);
assert_eq!(d.checked_add(Duration::days(-1000_000_000)), None);
assert_eq!(MAX.checked_add(Duration::days(1)), None);

`pub fn checked_sub(self, rhs: Duration) -> Option<NaiveDate>`
[src]

Subtracts the days part of given Duration from the current date.

Returns None when it will result in overflow.

Example

use chrono::{NaiveDate, Duration};
use chrono::naive::date::MIN;

let d = NaiveDate::from_ymd(2015, 9, 5);
assert_eq!(d.checked_sub(Duration::days(40)), Some(NaiveDate::from_ymd(2015, 7, 27)));
assert_eq!(d.checked_sub(Duration::days(-40)), Some(NaiveDate::from_ymd(2015, 10, 15)));
assert_eq!(d.checked_sub(Duration::days(1000_000_000)), None);
assert_eq!(d.checked_sub(Duration::days(-1000_000_000)), None);
assert_eq!(MIN.checked_sub(Duration::days(1)), None);

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

Formats the date with the specified formatting items. Otherwise it is same to the ordinary format method.

The Iterator of items should be Cloneable, 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");
let d = NaiveDate::from_ymd(2015, 9, 5);
assert_eq!(d.format_with_items(fmt.clone()).to_string(), "2015-09-05");
assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05");

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

Formats the date 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 d = NaiveDate::from_ymd(2015, 9, 5);
assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05");
assert_eq!(d.format("%A, %-d %B, %C%y").to_string(), "Saturday, 5 September, 2015");

Trait Implementations

`impl Datelike for NaiveDate`
[src]

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

Returns the year number in the calendar date.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).year(), 2015);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).year(), -308); // 309 BCE

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

Returns the month number starting from 1.

The return value ranges from 1 to 12.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month(), 9);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month(), 3);

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

Returns the month number starting from 0.

The return value ranges from 0 to 11.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month0(), 8);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month0(), 2);

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

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day(), 8);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day(), 14);

Combined with NaiveDate::pred, one can determine the number of days in a particular month. (Note that this panics when year is out of range.)

use chrono::{NaiveDate, Datelike};

fn ndays_in_month(year: i32, month: u32) -> u32 {
    // the first day of the next month...
    let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) };
    let d = NaiveDate::from_ymd(y, m, 1);

    // ...is preceded by the last day of the original month
    d.pred().day()
}

assert_eq!(ndays_in_month(2015, 8), 31);
assert_eq!(ndays_in_month(2015, 9), 30);
assert_eq!(ndays_in_month(2015, 12), 31);
assert_eq!(ndays_in_month(2016, 2), 29);
assert_eq!(ndays_in_month(2017, 2), 28);

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

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day0(), 7);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day0(), 13);

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

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal(), 251);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal(), 74);

Combined with NaiveDate::pred, one can determine the number of days in a particular year. (Note that this panics when year is out of range.)

use chrono::{NaiveDate, Datelike};

fn ndays_in_year(year: i32) -> u32 {
    // the first day of the next year...
    let d = NaiveDate::from_ymd(year + 1, 1, 1);

    // ...is preceded by the last day of the original year
    d.pred().ordinal()
}

assert_eq!(ndays_in_year(2015), 365);
assert_eq!(ndays_in_year(2016), 366);
assert_eq!(ndays_in_year(2017), 365);
assert_eq!(ndays_in_year(2000), 366);
assert_eq!(ndays_in_year(2100), 365);

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

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal0(), 250);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal0(), 73);

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

Returns the day of week.

Example

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

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).weekday(), Weekday::Tue);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).weekday(), Weekday::Fri);

`fn isoweekdate(&self) -> (i32, u32, Weekday)`
[src]

Returns the ISO week date: an adjusted year, week number and day of week. The adjusted year may differ from that of the calendar date. Read more

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

Makes a new NaiveDate with the year number changed.

Returns None when the resulting NaiveDate would be invalid.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(2016),
           Some(NaiveDate::from_ymd(2016, 9, 8)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(-308),
           Some(NaiveDate::from_ymd(-308, 9, 8)));

A leap day (February 29) is a good example that this method can return None.

assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2015).is_none());
assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2020).is_some());

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

Makes a new NaiveDate with the month number (starting from 1) changed.

Returns None when the resulting NaiveDate would be invalid.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(10),
           Some(NaiveDate::from_ymd(2015, 10, 8)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(13), None); // no month 13
assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month(2), None); // no February 30

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

Makes a new NaiveDate with the month number (starting from 0) changed.

Returns None when the resulting NaiveDate would be invalid.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(9),
           Some(NaiveDate::from_ymd(2015, 10, 8)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(12), None); // no month 13
assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month0(1), None); // no February 30

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

Makes a new NaiveDate with the day of month (starting from 1) changed.

Returns None when the resulting NaiveDate would be invalid.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(30),
           Some(NaiveDate::from_ymd(2015, 9, 30)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(31),
           None); // no September 31

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

Makes a new NaiveDate with the day of month (starting from 0) changed.

Returns None when the resulting NaiveDate would be invalid.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(29),
           Some(NaiveDate::from_ymd(2015, 9, 30)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(30),
           None); // no September 31

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

Makes a new NaiveDate with the day of year (starting from 1) changed.

Returns None when the resulting NaiveDate would be invalid.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(60),
           Some(NaiveDate::from_ymd(2015, 3, 1)));
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(366),
           None); // 2015 had only 365 days

assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(60),
           Some(NaiveDate::from_ymd(2016, 2, 29)));
assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(366),
           Some(NaiveDate::from_ymd(2016, 12, 31)));

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

Makes a new NaiveDate with the day of year (starting from 0) changed.

Returns None when the resulting NaiveDate would be invalid.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(59),
           Some(NaiveDate::from_ymd(2015, 3, 1)));
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(365),
           None); // 2015 had only 365 days

assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(59),
           Some(NaiveDate::from_ymd(2016, 2, 29)));
assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(365),
           Some(NaiveDate::from_ymd(2016, 12, 31)));

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

Returns the number of days since January 1, 1 (Day 1) in the proleptic Gregorian calendar.

`impl Clone for NaiveDate`
[src]

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

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

`impl Copy for NaiveDate`
[src]

`impl Eq for NaiveDate`
[src]

`impl PartialOrd<NaiveDate> for NaiveDate`
[src]

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

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

`fn lt(&self, other: &NaiveDate) -> bool`
[src]

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

`fn le(&self, other: &NaiveDate) -> bool`
[src]

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

`fn gt(&self, other: &NaiveDate) -> bool`
[src]

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

`fn ge(&self, other: &NaiveDate) -> bool`
[src]

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

`impl PartialEq<NaiveDate> for NaiveDate`
[src]

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

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

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

This method tests for !=.

`impl Ord for NaiveDate`
[src]

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

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

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

Compares and returns the maximum of two values. Read more

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

Compares and returns the minimum of two values. Read more

`impl Hash for NaiveDate`
[src]

NaiveDate can be used as a key to the hash maps.

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

Feeds this value into the given [Hasher]. Read more

`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 Display for NaiveDate`
[src]

The Display output of the naive date d is same to d.format("%Y-%m-%d").

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

Example

use chrono::NaiveDate;

assert_eq!(format!("{}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
assert_eq!(format!("{}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");

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

Formats the value using the given formatter. Read more

`impl Debug for NaiveDate`
[src]

The Debug output of the naive date d is same to d.format("%Y-%m-%d").

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

Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");

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

Formats the value using the given formatter. Read more

`impl FromStr for NaiveDate`
[src]

Parsing a str into a NaiveDate uses the same format, %Y-%m-%d, as Debug and Display.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 9, 18);
assert_eq!(format!("{}", d).parse::<NaiveDate>(), Ok(d));

let d = NaiveDate::from_ymd(12345, 6, 7);
assert_eq!(format!("{}", d).parse::<NaiveDate>(), Ok(d));

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

`type Err = ParseError`

The associated error which can be returned from parsing.

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

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

`impl Add<Duration> for NaiveDate`
[src]

An addition of Duration to NaiveDate discards the fractional days, rounding to the closest integral number of days towards Duration::zero().

Panics on underflow or overflow. Use NaiveDate::checked_add to detect that.

Example

use chrono::{NaiveDate, Duration};

let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d);
assert_eq!(ymd(2014, 1, 1) + Duration::zero(),             ymd(2014, 1, 1));
assert_eq!(ymd(2014, 1, 1) + Duration::seconds(86399),     ymd(2014, 1, 1));
assert_eq!(ymd(2014, 1, 1) + Duration::seconds(-86399),    ymd(2014, 1, 1));
assert_eq!(ymd(2014, 1, 1) + Duration::days(1),            ymd(2014, 1, 2));
assert_eq!(ymd(2014, 1, 1) + Duration::days(-1),           ymd(2013, 12, 31));
assert_eq!(ymd(2014, 1, 1) + Duration::days(364),          ymd(2014, 12, 31));
assert_eq!(ymd(2014, 1, 1) + Duration::days(365*4 + 1),    ymd(2018, 1, 1));
assert_eq!(ymd(2014, 1, 1) + Duration::days(365*400 + 97), ymd(2414, 1, 1));

`type Output = NaiveDate`

The resulting type after applying the + operator.

`fn add(self, rhs: Duration) -> NaiveDate`
[src]

Performs the + operation.

`impl Sub<NaiveDate> for NaiveDate`
[src]

A subtraction of NaiveDate from NaiveDate yields a Duration of integral numbers.

This does not overflow or underflow at all, as all possible output fits in the range of Duration.

Example

use chrono::{NaiveDate, Duration};

let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d);
assert_eq!(ymd(2014, 1, 1) - ymd(2014, 1, 1),   Duration::zero());
assert_eq!(ymd(2014, 1, 1) - ymd(2013, 12, 31), Duration::days(1));
assert_eq!(ymd(2014, 1, 1) - ymd(2014, 1, 2),   Duration::days(-1));
assert_eq!(ymd(2014, 1, 1) - ymd(2013, 9, 23),  Duration::days(100));
assert_eq!(ymd(2014, 1, 1) - ymd(2013, 1, 1),   Duration::days(365));
assert_eq!(ymd(2014, 1, 1) - ymd(2010, 1, 1),   Duration::days(365*4 + 1));
assert_eq!(ymd(2014, 1, 1) - ymd(1614, 1, 1),   Duration::days(365*400 + 97));

`type Output = Duration`

The resulting type after applying the - operator.

`fn sub(self, rhs: NaiveDate) -> Duration`
[src]

Performs the - operation.

`impl Sub<Duration> for NaiveDate`
[src]

A subtraction of Duration from NaiveDate discards the fractional days, rounding to the closest integral number of days towards Duration::zero().

Panics on underflow or overflow. Use NaiveDate::checked_sub to detect that.

Example

use chrono::{NaiveDate, Duration};

let ymd = |y,m,d| NaiveDate::from_ymd(y, m, d);
assert_eq!(ymd(2014, 1, 1) - Duration::zero(),             ymd(2014, 1, 1));
assert_eq!(ymd(2014, 1, 1) - Duration::seconds(86399),     ymd(2014, 1, 1));
assert_eq!(ymd(2014, 1, 1) - Duration::seconds(-86399),    ymd(2014, 1, 1));
assert_eq!(ymd(2014, 1, 1) - Duration::days(1),            ymd(2013, 12, 31));
assert_eq!(ymd(2014, 1, 1) - Duration::days(-1),           ymd(2014, 1, 2));
assert_eq!(ymd(2014, 1, 1) - Duration::days(364),          ymd(2013, 1, 2));
assert_eq!(ymd(2014, 1, 1) - Duration::days(365*4 + 1),    ymd(2010, 1, 1));
assert_eq!(ymd(2014, 1, 1) - Duration::days(365*400 + 97), ymd(1614, 1, 1));

`type Output = NaiveDate`

The resulting type after applying the - operator.

`fn sub(self, rhs: Duration) -> NaiveDate`
[src]

Performs the - operation.

`impl Encodable for NaiveDate`
[src]

`fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>`
[src]

Serialize a value using an Encoder.

`impl Decodable for NaiveDate`
[src]

`fn decode<D: Decoder>(d: &mut D) -> Result<NaiveDate, D::Error>`
[src]

Deserialize a value using a Decoder.

Auto Trait Implementations

`impl Send for NaiveDate`

`impl Sync for NaiveDate`

Blanket Implementations

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Converts the given value to a String. Read more

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

`type Owned = T`

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

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

`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, U> TryFrom for T where T: From,`
[src]

`type Error = !`

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

The type returned in the event of a conversion error.

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

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

Performs the conversion.

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

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

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

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

`type Error = >::Error`

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

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`
[src]

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

Performs the conversion.

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

`fn get_type_id(&self) -> TypeId`
[src]

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

this method will likely be replaced by an associated static

Gets the TypeId of self. Read more

[−][src]Struct chrono::naive::date::NaiveDate

Methods

impl NaiveDate[src]

pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate[src]

pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>[src]

pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate[src]

pub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>[src]

pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate[src]

pub fn from_isoywd_opt( year: i32, week: u32, weekday: Weekday) -> Option<NaiveDate>[src]

pub fn from_num_days_from_ce(days: i32) -> NaiveDate[src]

pub fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate>[src]

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

pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime[src]

pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime[src]

pub fn and_hms_opt( &self, hour: u32, min: u32, sec: u32) -> Option<NaiveDateTime>[src]

pub fn and_hms_milli( &self, hour: u32, min: u32, sec: u32, milli: u32) -> NaiveDateTime[src]

pub fn and_hms_milli_opt( &self, hour: u32, min: u32, sec: u32, milli: u32) -> Option<NaiveDateTime>[src]

pub fn and_hms_micro( &self, hour: u32, min: u32, sec: u32, micro: u32) -> NaiveDateTime[src]

pub fn and_hms_micro_opt( &self, hour: u32, min: u32, sec: u32, micro: u32) -> Option<NaiveDateTime>[src]

pub fn and_hms_nano( &self, hour: u32, min: u32, sec: u32, nano: u32) -> NaiveDateTime[src]

pub fn and_hms_nano_opt( &self, hour: u32, min: u32, sec: u32, nano: u32) -> Option<NaiveDateTime>[src]

pub fn succ(&self) -> NaiveDate[src]

pub fn succ_opt(&self) -> Option<NaiveDate>[src]

pub fn pred(&self) -> NaiveDate[src]

pub fn pred_opt(&self) -> Option<NaiveDate>[src]

pub fn checked_add(self, rhs: Duration) -> Option<NaiveDate>[src]

pub fn checked_sub(self, rhs: Duration) -> Option<NaiveDate>[src]

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

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

Trait Implementations

impl Datelike for NaiveDate[src]

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

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

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

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

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

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

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

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

fn isoweekdate(&self) -> (i32, u32, Weekday)[src]

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

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

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

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

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

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

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

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

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

impl Clone for NaiveDate[src]

fn clone(&self) -> NaiveDate[src]

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

impl Copy for NaiveDate[src]

impl Eq for NaiveDate[src]

impl PartialOrd<NaiveDate> for NaiveDate[src]

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

fn lt(&self, other: &NaiveDate) -> bool[src]

fn le(&self, other: &NaiveDate) -> bool[src]

fn gt(&self, other: &NaiveDate) -> bool[src]

fn ge(&self, other: &NaiveDate) -> bool[src]

impl PartialEq<NaiveDate> for NaiveDate[src]

fn eq(&self, other: &NaiveDate) -> bool[src]

fn ne(&self, other: &NaiveDate) -> bool[src]

impl Ord for NaiveDate[src]

fn cmp(&self, other: &NaiveDate) -> Ordering[src]

fn max(self, other: Self) -> Self1.21.0[src]

fn min(self, other: Self) -> Self1.21.0[src]

impl Hash for NaiveDate[src]

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

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

impl Display for NaiveDate[src]

fn fmt(&self, f: &mut Formatter) -> Result[src]

impl Debug for NaiveDate[src]

fn fmt(&self, f: &mut Formatter) -> Result[src]

impl FromStr for NaiveDate[src]

type Err = ParseError

fn from_str(s: &str) -> ParseResult<NaiveDate>[src]

impl Add<Duration> for NaiveDate[src]

type Output = NaiveDate

fn add(self, rhs: Duration) -> NaiveDate[src]

`impl NaiveDate`
[src]

`pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate`
[src]

`pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>`
[src]

`pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate`
[src]

`pub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>`
[src]

`pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate`
[src]

`pub fn from_isoywd_opt( year: i32, week: u32, weekday: Weekday ) -> Option<NaiveDate>`
[src]

`pub fn from_num_days_from_ce(days: i32) -> NaiveDate`
[src]

`pub fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate>`
[src]

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

`pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime`
[src]

`pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime`
[src]

`pub fn and_hms_opt( &self, hour: u32, min: u32, sec: u32 ) -> Option<NaiveDateTime>`
[src]

`pub fn and_hms_milli( &self, hour: u32, min: u32, sec: u32, milli: u32 ) -> NaiveDateTime`
[src]

`pub fn and_hms_milli_opt( &self, hour: u32, min: u32, sec: u32, milli: u32 ) -> Option<NaiveDateTime>`
[src]

`pub fn and_hms_micro( &self, hour: u32, min: u32, sec: u32, micro: u32 ) -> NaiveDateTime`
[src]

`pub fn and_hms_micro_opt( &self, hour: u32, min: u32, sec: u32, micro: u32 ) -> Option<NaiveDateTime>`
[src]

`pub fn and_hms_nano( &self, hour: u32, min: u32, sec: u32, nano: u32 ) -> NaiveDateTime`
[src]

`pub fn and_hms_nano_opt( &self, hour: u32, min: u32, sec: u32, nano: u32 ) -> Option<NaiveDateTime>`
[src]

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

`pub fn succ_opt(&self) -> Option<NaiveDate>`
[src]

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

`pub fn pred_opt(&self) -> Option<NaiveDate>`
[src]

`pub fn checked_add(self, rhs: Duration) -> Option<NaiveDate>`
[src]

`pub fn checked_sub(self, rhs: Duration) -> Option<NaiveDate>`
[src]

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

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

`impl Datelike for NaiveDate`
[src]

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

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

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

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

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

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

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

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

`fn isoweekdate(&self) -> (i32, u32, Weekday)`
[src]

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

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

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

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

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

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

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

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

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

`impl Clone for NaiveDate`
[src]

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

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

`impl Copy for NaiveDate`
[src]

`impl Eq for NaiveDate`
[src]

`impl PartialOrd<NaiveDate> for NaiveDate`
[src]

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

`fn lt(&self, other: &NaiveDate) -> bool`
[src]

`fn le(&self, other: &NaiveDate) -> bool`
[src]

`fn gt(&self, other: &NaiveDate) -> bool`
[src]

`fn ge(&self, other: &NaiveDate) -> bool`
[src]

`impl PartialEq<NaiveDate> for NaiveDate`
[src]

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

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

`impl Ord for NaiveDate`
[src]

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

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

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

`impl Hash for NaiveDate`
[src]

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

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

`impl Display for NaiveDate`
[src]

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

`impl Debug for NaiveDate`
[src]

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

`impl FromStr for NaiveDate`
[src]

`type Err = ParseError`

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

`impl Add<Duration> for NaiveDate`
[src]

`type Output = NaiveDate`

`fn add(self, rhs: Duration) -> NaiveDate`
[src]

`impl Sub<NaiveDate> for NaiveDate`
[src]

`type Output = Duration`

`fn sub(self, rhs: NaiveDate) -> Duration`
[src]