Struct ComponentOrder 

pub struct ComponentOrder {
    pub first: DateComponent,
    pub second: DateComponent,
    pub third: DateComponent,
}

The expected ordering of date components in positional (numeric) input.

For example, 01/06/24 is ambiguous — a ComponentOrder of [Day, Month, Year] interprets it as 1 June 2024, while [Month, Day, Year] gives 6 January 2024.

For unambiguous inputs (e.g. 31/06/24) the correct interpretation can always be determined regardless of this setting.

All three components must be present and each must appear exactly once. Construct with ComponentOrder::new to enforce this invariant, or use ComponentOrder::default for the standard Day/Month/Year order.

Fields

first: DateComponent

The component expected in the first position.

second: DateComponent

The component expected in the second position.

third: DateComponent

The component expected in the third position.

Implementations

impl ComponentOrder

pub fn new( first: DateComponent, second: DateComponent, third: DateComponent, ) -> Result<Self, ComponentOrderError>

Create a new ComponentOrder, returning Err if any component is duplicated (which also implies another is missing).

Examples found in repository

examples/console_entry_config.rs (lines 96-100)

    pub fn get_config(&self) -> Config {
        match self {
            // Strictly day-first numeric dates with all three components
            // required. Letter-O substitution is disabled since this scenario
            // expects clean numeric input only.
            PreDefinedConfigs::StrictDMY => Config::default()
                .with_day(
                    DayConfig::default()
                        .with_expected(IsExpected::Yes),
                )
                .with_month(
                    MonthConfig::default()
                        .with_expected(IsExpected::Yes)
                )
                .with_year(
                    YearConfig::default()
                        .with_range(1, 3000)
                        .with_expected(IsExpected::Yes)
                        .with_two_digit_expansion(TwoDigitYearExpansion::Literal),
                )
                .with_component_order(
                    ComponentOrder::new(
                        DateComponent::Day,
                        DateComponent::Month,
                        DateComponent::Year,
                    )
                    .unwrap(),
                )
                .with_letter_o_substitution(false),

            // Wide ranging historical dates that cannot use 2-digit year
            // expansion as there is no way to know which centuries the dates
            // will be from. Minimal assumptions about the data when there is
            // a lot of uncertainty.
            PreDefinedConfigs::AllHistoricalDates => Config::default().with_year(
                YearConfig::default()
                    .with_range(1, 3000)
                    .with_expected(IsExpected::Yes)
                    .with_two_digit_expansion(TwoDigitYearExpansion::Literal),
            ),

            // Constrains the year range to the Industrial Revolution period and
            // uses a sliding window for 2-digit years centred on 1800.
            // Component order matches Great Britain's common DD/MM/YYYY format.
            PreDefinedConfigs::IndustrialRevolutionDates => Config::default()
                .with_year(
                    YearConfig::default()
                        .with_range(1760, 1840)
                        .with_expected(IsExpected::Yes)
                        .with_two_digit_expansion(TwoDigitYearExpansion::SlidingWindow {
                            earliest_year: 1750,
                            pivot: SlidingWindowPivot::new(50),
                        }),
                )
                .with_component_order(
                    ComponentOrder::new(
                        DateComponent::Day,
                        DateComponent::Month,
                        DateComponent::Year,
                    )
                    .unwrap(),
                ),

            // Children under 18 — birth years must be in the 2000s and not in
            // the future. Always(Century(2000)) maps all 2-digit values to the
            // 2000s; the max of 2026 rejects future years.
            PreDefinedConfigs::ChildrenBirthdays => Config::default().with_year(
                YearConfig::default()
                    .with_range(2000, 2026)
                    .with_expected(IsExpected::Yes)
                    .with_two_digit_expansion(TwoDigitYearExpansion::Always(Century::new(2000)))
                    .with_single_digit_expansion(true),
            ),
        }
    }

Trait Implementations

impl Clone for ComponentOrder

fn clone(&self) -> ComponentOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComponentOrder

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

Formats the value using the given formatter.

impl Default for ComponentOrder

fn default() -> Self

The default order is Day → Month → Year (e.g. DD/MM/YYYY).

impl PartialEq for ComponentOrder

fn eq(&self, other: &ComponentOrder) -> 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 Copy for ComponentOrder

impl Eq for ComponentOrder

impl StructuralPartialEq for ComponentOrder