Struct datetime::LocalDate

pub struct LocalDate {
    // some fields omitted
}

A local date is a day-long span on the timeline, without a time zone.

Methods

impl LocalDate

fn ymd(year: i64, month: Month, day: i8) -> Result<LocalDate, Error>

Creates a new local date instance from the given year, month, and day fields.

The values are checked for validity before instantiation, and passing in values out of range will return an error.

Examples

Instantiate the 20th of July 1969 based on its year, week-of-year, and weekday.

use datetime::{LocalDate, Month, DatePiece};

let date = LocalDate::ymd(1969, Month::July, 20).unwrap();
assert_eq!(date.year(), 1969);
assert_eq!(date.month(), Month::July);
assert_eq!(date.day(), 20);

assert!(LocalDate::ymd(2100, Month::February, 29).is_err());

fn yd(year: i64, yearday: i64) -> Result<LocalDate, Error>

Creates a new local date instance from the given year and day-of-year values.

The values are checked for validity before instantiation, and passing in values out of range will return an error.

Examples

Instantiate the 13th of September 2015 based on its year and day-of-year.

use datetime::{LocalDate, Weekday, Month, DatePiece};

let date = LocalDate::yd(2015, 0x100).unwrap();
assert_eq!(date.year(), 2015);
assert_eq!(date.month(), Month::September);
assert_eq!(date.day(), 13);

fn ywd(year: i64, week: i64, weekday: Weekday) -> Result<LocalDate, Error>

Creates a new local date instance from the given year, week-of-year, and weekday values.

The values are checked for validity before instantiation, and passing in values out of range will return an error.

Examples

Instantiate the 11th of September 2015 based on its year, week-of-year, and weekday.

use datetime::{LocalDate, Weekday, Month, DatePiece};

let date = LocalDate::ywd(2015, 37, Weekday::Friday).unwrap();
assert_eq!(date.year(), 2015);
assert_eq!(date.month(), Month::September);
assert_eq!(date.day(), 11);
assert_eq!(date.weekday(), Weekday::Friday);

Note that according to the ISO-8601 standard, the year will change when working with dates early in week 1, or late in week 53:

use datetime::{LocalDate, Weekday, Month, DatePiece};

let date = LocalDate::ywd(2009, 1, Weekday::Monday).unwrap();
assert_eq!(date.year(), 2008);
assert_eq!(date.month(), Month::December);
assert_eq!(date.day(), 29);
assert_eq!(date.weekday(), Weekday::Monday);

let date = LocalDate::ywd(2009, 53, Weekday::Sunday).unwrap();
assert_eq!(date.year(), 2010);
assert_eq!(date.month(), Month::January);
assert_eq!(date.day(), 3);
assert_eq!(date.weekday(), Weekday::Sunday);

unsafe fn _new_with_prefilled_values(year: i64, month: Month, day: i8, weekday: Weekday, yearday: i16) -> LocalDate

Creates a new datestamp instance with the given year, month, day, weekday, and yearday fields.

This function is unsafe because the values are not checked for validity! It’s possible to pass the wrong values in, such as having a wrong day value for a month, or having the yearday value out of step. Before using it, check that the values are all correct - or just use the date!() macro, which does this for you at compile-time.

For this reason, the function is marked as unsafe, even though it (technically) uses unsafe components.

Trait Implementations

impl Copy for LocalDate

impl Clone for LocalDate

fn clone(&self) -> LocalDate

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Eq for LocalDate

impl DatePiece for LocalDate

fn year(&self) -> i64

The year, in absolute terms. This is in human-readable format, so the year 2014 actually has a year value of 2014, rather than 14 or 114 or anything like that.

fn month(&self) -> Month

The month of the year.

fn day(&self) -> i8

The day of the month, from 1 to 31.

fn yearday(&self) -> i16

The day of the year, from 1 to 366.

fn weekday(&self) -> Weekday

The day of the week.

fn year_of_century(&self) -> i64

The number of years into the century. This is the same as the last two digits of the year.

fn years_from_2000(&self) -> i64

The year number, relative to the year 2000. Internally, many routines use years relative the year 2000, rather than the year 0 (well, 1 BCE).

impl Debug for LocalDate

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

Formats the value using the given formatter.

impl PartialEq for LocalDate

fn eq(&self, other: &LocalDate) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd for LocalDate

fn partial_cmp(&self, other: &LocalDate) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

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

impl Ord for LocalDate

fn cmp(&self, other: &LocalDate) -> Ordering

This method returns an Ordering between self and other.

impl ISO for LocalDate

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

fn iso(&self) -> ISOString<Self>

impl FromStr for LocalDate

type Err = Error<DateTimeError>

The associated error which can be returned from parsing.

fn from_str(input: &str) -> Result<Self, Self::Err>

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

impl Today for LocalDate

fn today() -> LocalDate