Enum FormatDescriptionV3Inner 

#[non_exhaustive]
pub enum FormatDescriptionV3Inner<'a> {
    Day(Day),
    MonthShort(MonthShort),
    MonthLong(MonthLong),
    MonthNumerical(MonthNumerical),
    Ordinal(Ordinal),
    WeekdayShort(WeekdayShort),
    WeekdayLong(WeekdayLong),
    WeekdaySunday(WeekdaySunday),
    WeekdayMonday(WeekdayMonday),
    WeekNumberIso(WeekNumberIso),
    WeekNumberSunday(WeekNumberSunday),
    WeekNumberMonday(WeekNumberMonday),
    CalendarYearFullExtendedRange(CalendarYearFullExtendedRange),
    CalendarYearFullStandardRange(CalendarYearFullStandardRange),
    IsoYearFullExtendedRange(IsoYearFullExtendedRange),
    IsoYearFullStandardRange(IsoYearFullStandardRange),
    CalendarYearCenturyExtendedRange(CalendarYearCenturyExtendedRange),
    CalendarYearCenturyStandardRange(CalendarYearCenturyStandardRange),
    IsoYearCenturyExtendedRange(IsoYearCenturyExtendedRange),
    IsoYearCenturyStandardRange(IsoYearCenturyStandardRange),
    CalendarYearLastTwo(CalendarYearLastTwo),
    IsoYearLastTwo(IsoYearLastTwo),
    Hour12(Hour12),
    Hour24(Hour24),
    Minute(Minute),
    Period(Period),
    Second(Second),
    Subsecond(Subsecond),
    OffsetHour(OffsetHour),
    OffsetMinute(OffsetMinute),
    OffsetSecond(OffsetSecond),
    Ignore(Ignore),
    UnixTimestampSecond(UnixTimestampSecond),
    UnixTimestampMillisecond(UnixTimestampMillisecond),
    UnixTimestampMicrosecond(UnixTimestampMicrosecond),
    UnixTimestampNanosecond(UnixTimestampNanosecond),
    End(End),
    BorrowedLiteral(&'a str),
    BorrowedCompound(&'a [Self]),
    BorrowedOptional {
        format: bool,
        item: &'a Self,
    },
    BorrowedFirst(&'a [Self]),
    OwnedLiteral(Box<str>),
    OwnedCompound(Box<[Self]>),
    OwnedOptional {
        format: bool,
        item: Box<Self>,
    },
    OwnedFirst(Box<[Self]>),
}

The inner enum of a version 3 format description. Controls all business logic.

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.

Day(Day)

Day of the month.

MonthShort(MonthShort)

Month of the year in the abbreviated form (e.g. “Jan”).

MonthLong(MonthLong)

Month of the year in the full form (e.g. “January”).

MonthNumerical(MonthNumerical)

Month of the year in the numerical form (e.g. “1” for January).

Ordinal(Ordinal)

Ordinal day of the year.

WeekdayShort(WeekdayShort)

Weekday in the abbreviated form (e.g. “Mon”).

WeekdayLong(WeekdayLong)

Weekday in the full form (e.g. “Monday”).

WeekdaySunday(WeekdaySunday)

Weekday number where Sunday is either 0 or 1 depending on the modifier.

WeekdayMonday(WeekdayMonday)

Weekday number where Monday is either 0 or 1 depending on the modifier.

WeekNumberIso(WeekNumberIso)

Week number of the year, where week 1 starts is the week beginning on Monday that contains January 4.

WeekNumberSunday(WeekNumberSunday)

Week number of the year, where week 1 starts on the first Sunday of the calendar year.

WeekNumberMonday(WeekNumberMonday)

Week number of the year, where week 1 starts on the first Monday of the calendar year.

CalendarYearFullExtendedRange(CalendarYearFullExtendedRange)

The calendar year. Supports the extended range.

CalendarYearFullStandardRange(CalendarYearFullStandardRange)

The calendar year. Does not support the extended range.

IsoYearFullExtendedRange(IsoYearFullExtendedRange)

The ISO week-based year. Supports the extended range.

IsoYearFullStandardRange(IsoYearFullStandardRange)

The ISO week-based year. Does not support the extended range.

CalendarYearCenturyExtendedRange(CalendarYearCenturyExtendedRange)

The century of the calendar year. Supports the extended range.

CalendarYearCenturyStandardRange(CalendarYearCenturyStandardRange)

The century of the calendar year. Does not support the extended range.

IsoYearCenturyExtendedRange(IsoYearCenturyExtendedRange)

The century of the ISO week-based year. Supports the extended range.

IsoYearCenturyStandardRange(IsoYearCenturyStandardRange)

The century of the ISO week-based year. Does not support the extended range.

CalendarYearLastTwo(CalendarYearLastTwo)

The last two digits of the calendar year.

IsoYearLastTwo(IsoYearLastTwo)

The last two digits of the ISO week-based year.

Hour12(Hour12)

Hour of the day using the 12-hour clock.

Hour24(Hour24)

Hour of the day using the 24-hour clock.

Minute(Minute)

Minute within the hour.

Period(Period)

AM/PM part of the time.

Second(Second)

Second within the minute.

Subsecond(Subsecond)

Subsecond within the second.

OffsetHour(OffsetHour)

Hour of the UTC offset.

OffsetMinute(OffsetMinute)

Minute within the hour of the UTC offset.

OffsetSecond(OffsetSecond)

Second within the minute of the UTC offset.

Ignore(Ignore)

A number of bytes to ignore when parsing. This has no effect on formatting.

UnixTimestampSecond(UnixTimestampSecond)

A Unix timestamp in seconds.

UnixTimestampMillisecond(UnixTimestampMillisecond)

A Unix timestamp in milliseconds.

UnixTimestampMicrosecond(UnixTimestampMicrosecond)

A Unix timestamp in microseconds.

UnixTimestampNanosecond(UnixTimestampNanosecond)

A Unix timestamp in nanoseconds.

End(End)

The end of input. Parsing this component will fail if there is any input remaining. This component neither affects formatting nor consumes any input when parsing.

BorrowedLiteral(&'a str)

A string that is formatted as-is.

BorrowedCompound(&'a [Self])

A series of literals or components that collectively form a partial or complete description.

BorrowedOptional

An item that may or may not be present when parsing. If parsing fails, there will be no effect on the resulting struct.

Fields

format: bool

Whether the item should be formatted.

item: &'a Self

The item in question.

BorrowedFirst(&'a [Self])

A series of items where, when parsing, the first successful parse is used. When formatting, the first item is used. If no items are present, both formatting and parsing are no-ops.

OwnedLiteral(Box<str>)

A string that is formatted as-is.

OwnedCompound(Box<[Self]>)

A series of literals or components that collectively form a partial or complete description.

OwnedOptional

An item that may or may not be present when parsing. If parsing fails, there will be no effect on the resulting struct.

Fields

format: bool

Whether the item should be formatted.

item: Box<Self>

The item in question.

OwnedFirst(Box<[Self]>)

A series of items where, when parsing, the first successful parse is used. When formatting, the first item is used. If no items are present, both formatting and parsing are no-ops.

Implementations

impl<'a> FormatDescriptionV3Inner<'a>

fn make_owned_in_place(&mut self)

Recursively convert to an owned version, doing so in-place when possible.

pub(super) fn into_owned(self) -> FormatDescriptionV3Inner<'static>

Convert the format description to an owned version in place, replacing borrowed components with their owned equivalents.

pub const fn into_opaque(self) -> FormatDescriptionV3<'a>

Convert the inner enum to a FormatDescriptionV3.

const fn max_bytes_needed(&self) -> usize

Obtain the maximum number of bytes that are needed to format any value using this format description.

Trait Implementations

impl<'a> Clone for FormatDescriptionV3Inner<'a>

fn clone(&self) -> FormatDescriptionV3Inner<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComputeMetadata for FormatDescriptionV3Inner<'_>

fn compute_metadata(&self) -> Metadata

Compute the metadata for a format description.

impl Debug for FormatDescriptionV3Inner<'_>

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

Formats the value using the given formatter.

impl From<Component> for FormatDescriptionV3Inner<'_>

fn from(component: Component) -> Self

Converts to this type from the input type.

impl Sealed for FormatDescriptionV3Inner<'_>

fn format_into<V>( &self, output: &mut (impl Write + ?Sized), value: &V, state: &mut V::State, ) -> Result<usize, Format>

where V: ComponentProvider,

Format the item into the provided output, returning the number of bytes written.

fn format<V>(&self, value: &V, state: &mut V::State) -> Result<String, Format>

where V: ComponentProvider,

Format the item directly to a String.

impl TryFrom<AstComponent> for FormatDescriptionV3Inner<'_>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(component: AstComponent) -> Result<Self, Self::Error>

Performs the conversion.