Struct icu_calendar::Date

pub struct Date<A: AsCalendar> { /* private fields */ }

A date for a given calendar

This can work with wrappers around Calendar types, e.g. Rc<C>, via the AsCalendar trait

Implementations

impl Date<Buddhist>

pub fn new_buddhist_date(
    year: i32,
    month: u8,
    day: u8
) -> Result<Date<Buddhist>, DateTimeError>

Construct a new Buddhist Date.

Years are specified as BE years.

use icu::calendar::Date;
use std::convert::TryFrom;

let date_buddhist = Date::new_buddhist_date(1970, 1, 2).unwrap();

assert_eq!(date_buddhist.year().number, 1970);
assert_eq!(date_buddhist.month().number, 1);
assert_eq!(date_buddhist.day_of_month().0, 2);

impl Date<Coptic>

pub fn new_coptic_date(
    year: i32,
    month: u8,
    day: u8
) -> Result<Date<Coptic>, DateTimeError>

Construct new Coptic Date.

use icu::calendar::Date;

let date_coptic = Date::new_coptic_date(1686, 5, 6).unwrap();

assert_eq!(date_coptic.year().number, 1686);
assert_eq!(date_coptic.month().number, 5);
assert_eq!(date_coptic.day_of_month().0, 6);

impl<A: AsCalendar> Date<A>

pub fn new_from_iso(iso: Date<Iso>, calendar: A) -> Self

Construct a date from an ISO date and some calendar representation

pub fn to_iso(&self) -> Date<Iso>

Convert the Date to an ISO Date

pub fn to_calendar<A2: AsCalendar>(&self, calendar: A2) -> Date<A2>

Convert the Date to a date in a different calendar

pub fn months_in_year(&self) -> u8

The number of months in the year of this date

pub fn days_in_year(&self) -> u32

The number of days in the year of this date

pub fn days_in_month(&self) -> u8

The number of days in the month of this date

pub fn day_of_week(&self) -> IsoWeekday

The day of the week for this date

Monday is 1, Sunday is 7, according to ISO

pub fn add(&mut self, duration: DateDuration<A::Calendar>)

Add a duration to this date, mutating it

pub fn added(self, duration: DateDuration<A::Calendar>) -> Self

Add a duration to this date, returning the new one

pub fn until<B: AsCalendar<Calendar = A::Calendar>>(
    &self,
    other: &Date<B>,
    largest_unit: DateDurationUnit,
    smallest_unit: DateDurationUnit
) -> DateDuration<A::Calendar>

Calculating the duration between other - self

pub fn year(&self) -> Year

The calendar-specific year represented by self

pub fn month(&self) -> Month

The calendar-specific month represented by self

pub fn day_of_month(&self) -> DayOfMonth

The calendar-specific day-of-month represented by self

pub fn day_of_year_info(&self) -> DayOfYearInfo

The calendar-specific day-of-month represented by self

pub fn from_raw(
    inner: <A::Calendar as Calendar>::DateInner,
    calendar: A
) -> Self

Construct a date from raw values for a given calendar. This does not check any invariants for the date and calendar, and should only be called by calendar implementations.

Calling this outside of calendar implementations is sound, but calendar implementations are not expected to do anything sensible with such invalid dates.

AnyCalendar will panic if AnyCalendar Date objects with mismatching date and calendar types are constructed

pub fn inner(&self) -> &<A::Calendar as Calendar>::DateInner

Get the inner date implementation. Should not be called outside of calendar implementations

pub fn calendar(&self) -> &A::Calendar

Get a reference to the contained calendar

impl<C: IncludedInAnyCalendar, A: AsCalendar<Calendar = C>> Date<A>

pub fn to_any(&self) -> Date<AnyCalendar>

Type-erase the date, converting it to a date for AnyCalendar

impl<C: Calendar> Date<C>

pub fn wrap_calendar_in_rc(self) -> Date<Rc<C>>

Wrap the calendar type in Rc<T>

Useful when paired with Self::to_any() to obtain a Date<Rc<AnyCalendar>>

impl Date<Ethiopic>

pub fn new_ethiopic_date(
    year: i32,
    month: u8,
    day: u8
) -> Result<Date<Ethiopic>, DateTimeError>

Construct new Ethiopic Date.

use icu::calendar::Date;

let date_ethiopic = Date::new_ethiopic_date(2014, 8, 25).unwrap();

assert_eq!(date_ethiopic.year().number, 2014);
assert_eq!(date_ethiopic.month().number, 8);
assert_eq!(date_ethiopic.day_of_month().0, 25);

pub fn set_amete_alem(&mut self, value: bool)

impl Date<Gregorian>

pub fn new_gregorian_date(
    year: IsoYear,
    month: IsoMonth,
    day: IsoDay
) -> Result<Date<Gregorian>, DateTimeError>

Construct a new Gregorian Date.

Years are specified as ISO years.

use icu::calendar::{Date,
                    iso::IsoYear,
                    iso::IsoMonth,
                    iso::IsoDay};
use std::convert::TryFrom;

let iso_year = IsoYear(1970);
let iso_month = IsoMonth::try_from(1).unwrap();
let iso_day = IsoDay::try_from(2).unwrap();

// Conversion from ISO to Gregorian
let date_gregorian = Date::new_gregorian_date(iso_year, iso_month, iso_day).unwrap();

assert_eq!(date_gregorian.year().number, 1970);
assert_eq!(date_gregorian.month().number, 1);
assert_eq!(date_gregorian.day_of_month().0, 2);

impl Date<Indian>

pub fn new_indian_date(
    year: i32,
    month: u8,
    day: u8
) -> Result<Date<Indian>, DateTimeError>

Construct new Indian Date.

use icu::calendar::Date;

let date_indian = Date::new_indian_date(1891, 10, 12).unwrap();

assert_eq!(date_indian.year().number, 1891);
assert_eq!(date_indian.month().number, 10);
assert_eq!(date_indian.day_of_month().0, 12);

impl Date<Iso>

pub fn new_iso_date(
    year: IsoYear,
    month: IsoMonth,
    day: IsoDay
) -> Result<Date<Iso>, DateTimeError>

Construct a new ISO Date.

use icu::calendar::{Date,
                    iso::IsoYear,
                    iso::IsoMonth,
                    iso::IsoDay};
use std::convert::TryFrom;

let iso_year = IsoYear(1996);
let iso_month = IsoMonth::try_from(2).unwrap();
let iso_day = IsoDay::try_from(3).unwrap();

// Creation of ISO date
let date_iso = Date::new_iso_date(iso_year, iso_month, iso_day).unwrap();

assert_eq!(date_iso.year().number, 1996);
assert_eq!(date_iso.month().number, 2);
assert_eq!(date_iso.day_of_month().0, 3);

pub fn new_iso_date_from_integers(
    year: i32,
    month: u8,
    day: u8
) -> Result<Date<Iso>, DateTimeError>

Construct a new ISO date from integers.

use icu::calendar::Date;

let date_iso = Date::new_iso_date_from_integers(1970, 1, 2).unwrap();

assert_eq!(date_iso.year().number, 1970);
assert_eq!(date_iso.month().number, 1);
assert_eq!(date_iso.day_of_month().0, 2);

impl Date<Julian>

pub fn new_julian_date(
    year: i32,
    month: u8,
    day: u8
) -> Result<Date<Julian>, DateTimeError>

Construct new Julian Date.

use icu::calendar::Date;

let date_julian = Date::new_julian_date(1969, 12, 20).unwrap();

assert_eq!(date_julian.year().number, 1969);
assert_eq!(date_julian.month().number, 12);
assert_eq!(date_julian.day_of_month().0, 20);

Trait Implementations

impl<A: AsCalendar + Clone> Clone for Date<A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: AsCalendar> Debug for Date<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C, A, B> PartialEq<Date<B>> for Date<A> where
    C: Calendar,
    A: AsCalendar<Calendar = C>,
    B: AsCalendar<Calendar = C>, 

fn eq(&self, other: &Date<B>) -> 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<A: AsCalendar> Eq for Date<A>