Enum DateFromFieldsError 

#[non_exhaustive]
pub enum DateFromFieldsError {
    InvalidDay {
        max: u8,
    },
    InvalidOrdinalMonth {
        max: u8,
    },
    MonthCodeInvalidSyntax,
    MonthNotInCalendar,
    MonthNotInYear,
    InvalidEra,
    InconsistentYear,
    InconsistentMonth,
    TooManyFields,
    NotEnoughFields,
    Overflow,
}

Error type for date creation via Date::try_from_fields.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

InvalidDay

The day is invalid for the given month.

Examples

use icu::calendar::error::DateFromFieldsError;
use icu::calendar::error::RangeError;
use icu::calendar::types::DateFields;
use icu::calendar::Date;
use icu::calendar::Iso;

let mut fields = DateFields::default();
fields.extended_year = Some(2000);
fields.ordinal_month = Some(11);
fields.day = Some(31);

let err = Date::try_from_fields(fields, Default::default(), Iso)
    .expect_err("no day 31 in November");

assert!(matches!(err, DateFromFieldsError::InvalidDay { max: 30 }));

Fields

max: u8

The maximum allowed value (the minimum is 1).

InvalidOrdinalMonth

The ordinal month is is invalid for the given year.

Examples

use icu::calendar::error::DateFromFieldsError;
use icu::calendar::error::RangeError;
use icu::calendar::types::DateFields;
use icu::calendar::Date;
use icu::calendar::Iso;

let mut fields = DateFields::default();
fields.extended_year = Some(2000);
fields.ordinal_month = Some(13);
fields.day = Some(1);

let err = Date::try_from_fields(fields, Default::default(), Iso)
    .expect_err("no month 13 in the ISO calendar");

assert!(matches!(
    err,
    DateFromFieldsError::InvalidOrdinalMonth { max: 12 }
));

Fields

max: u8

The maximum allowed value (the minimum is 1).

MonthCodeInvalidSyntax

The month code syntax is invalid.

Examples

use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::DateFields;
use icu::calendar::Date;
use icu::calendar::Iso;

let mut fields = DateFields::default();
fields.extended_year = Some(2000);
fields.month_code = Some(b"sep");
fields.day = Some(1);

let err = Date::try_from_fields(fields, Default::default(), Iso)
    .expect_err("month code is invalid");

assert_eq!(err, DateFromFieldsError::MonthCodeInvalidSyntax);

MonthNotInCalendar

The specified month does not exist in this calendar.

Examples

use icu::calendar::cal::Hebrew;
use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::{DateFields, Month};
use icu::calendar::Date;

let mut fields = DateFields::default();
fields.extended_year = Some(5783);
fields.month = Some(Month::new(13));
fields.day = Some(1);

let err = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect_err("no month M13 in Hebrew");
assert_eq!(err, DateFromFieldsError::MonthNotInCalendar);

MonthNotInYear

The specified month exists in this calendar, but not in the specified year.

Examples

use icu::calendar::cal::Hebrew;
use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::{DateFields, Month};
use icu::calendar::Date;

let mut fields = DateFields::default();
fields.extended_year = Some(5783);
fields.month = Some(Month::leap(5));
fields.day = Some(1);

let err = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect_err("no month M05L in Hebrew year 5783");
assert_eq!(err, DateFromFieldsError::MonthNotInYear);

InvalidEra

The era code is invalid for the calendar.

Examples

use icu::calendar::cal::Hebrew;
use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::DateFields;
use icu::calendar::Date;

let mut fields = DateFields::default();
fields.era = Some(b"ce"); // valid in Gregorian, but not Hebrew
fields.era_year = Some(1);
fields.ordinal_month = Some(1);
fields.day = Some(1);

let err = Date::try_from_fields(fields, Default::default(), Hebrew::new())
    .expect_err("era is unknown for Hebrew");

assert_eq!(err, DateFromFieldsError::InvalidEra);

InconsistentYear

The year was specified in multiple inconsistent ways.

Examples

use icu::calendar::cal::Japanese;
use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::DateFields;
use icu::calendar::Date;

let mut fields = DateFields::default();
fields.era = Some(b"reiwa");
fields.era_year = Some(6);
fields.ordinal_month = Some(1);
fields.day = Some(1);

Date::try_from_fields(fields, Default::default(), Japanese::new())
    .expect("a well-defined Japanese date");

fields.extended_year = Some(1900);

let err =
    Date::try_from_fields(fields, Default::default(), Japanese::new())
        .expect_err("year 1900 is not the same as 6 Reiwa");

assert_eq!(err, DateFromFieldsError::InconsistentYear);

InconsistentMonth

The month was specified in multiple inconsistent ways.

Examples

use icu::calendar::cal::Hebrew;
use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::{DateFields, Month};
use icu::calendar::Date;
use tinystr::tinystr;

let mut fields = DateFields::default();
fields.extended_year = Some(5783);
fields.month = Some(Month::new(6));
fields.ordinal_month = Some(6);
fields.day = Some(1);

Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect("a well-defined Hebrew date in a common year");

fields.extended_year = Some(5784);

let err = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect_err("month M06 is not the 6th month in leap year 5784");

assert_eq!(err, DateFromFieldsError::InconsistentMonth);

TooManyFields

Too many fields were specified to form a well-defined date.

Examples

use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::{DateFields, Month};
use icu::calendar::Date;
use icu::calendar::Iso;

let mut fields = DateFields::default();
fields.extended_year = Some(2000);
fields.month = Some(Month::new(1));
fields.month_code = Some(b"M01");
fields.day = Some(1);

let err = Date::try_from_fields(fields, Default::default(), Iso)
    .expect_err("cannot specify both month and month_code");

assert_eq!(err, DateFromFieldsError::TooManyFields);

NotEnoughFields

Not enough fields were specified to form a well-defined date.

Examples

use icu::calendar::cal::Hebrew;
use icu::calendar::error::DateFromFieldsError;
use icu::calendar::types::DateFields;
use icu::calendar::Date;
use tinystr::tinystr;

let mut fields = DateFields::default();

fields.ordinal_month = Some(3);

let err = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect_err("need more than just an ordinal month");
assert_eq!(err, DateFromFieldsError::NotEnoughFields);

fields.era_year = Some(5783);

let err = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect_err("need more than an ordinal month and an era year");
assert_eq!(err, DateFromFieldsError::NotEnoughFields);

fields.extended_year = Some(5783);

let err = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect_err("era year still needs an era");
assert_eq!(err, DateFromFieldsError::NotEnoughFields);

fields.era = Some(b"am");

let date = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect_err("still missing the day");
assert_eq!(err, DateFromFieldsError::NotEnoughFields);

fields.day = Some(1);
let date = Date::try_from_fields(fields, Default::default(), Hebrew)
    .expect("we have enough fields!");

Overflow

The date is out of range (see docs on Date for more information about Date’s fundamental range invariant).

Examples

use icu::calendar::error::DateFromFieldsError;
use icu::calendar::error::RangeError;
use icu::calendar::types::DateFields;
use icu::calendar::Date;
use icu::calendar::Iso;

let mut fields = DateFields::default();
fields.extended_year = Some(12345678);
fields.ordinal_month = Some(12);
fields.day = Some(31);

let err = Date::try_from_fields(fields, Default::default(), Iso)
    .expect_err("date out of range");

assert!(matches!(
    err,
    DateFromFieldsError::Overflow
));

Trait Implementations

impl Clone for DateFromFieldsError

fn clone(&self) -> DateFromFieldsError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DateFromFieldsError

impl Debug for DateFromFieldsError

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

Formats the value using the given formatter.

impl Display for DateFromFieldsError

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

Formats the value using the given formatter.

impl Error for DateFromFieldsError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<EcmaReferenceYearError> for DateFromFieldsError

fn from(value: EcmaReferenceYearError) -> DateFromFieldsError

Converts to this type from the input type.

impl From<MonthCodeParseError> for DateFromFieldsError

fn from(value: MonthCodeParseError) -> DateFromFieldsError

Converts to this type from the input type.

impl From<MonthError> for DateFromFieldsError

fn from(value: MonthError) -> DateFromFieldsError

Converts to this type from the input type.

impl From<UnknownEraError> for DateFromFieldsError

fn from(_value: UnknownEraError) -> DateFromFieldsError

Converts to this type from the input type.

impl PartialEq for DateFromFieldsError

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DateFromFieldsError