Struct DayConfig 

pub struct DayConfig {
    pub min: u8,
    pub max: u8,
    pub expected: IsExpected,
    pub default: Option<u8>,
}

Configuration for day extraction.

Fields

min: u8

Minimum valid day value (inclusive). Default: 1.

max: u8

Maximum valid day value (inclusive). Default: 31.

expected: IsExpected

Whether a day component is expected in the input.

default: Option<u8>

Default day value to use when the day is not found, if any.

Implementations

impl DayConfig

pub fn try_as_day_candidate(&self, value: i16, digit_count: u8) -> Option<u8>

Return Some(value as u8) when value is a plausible day for this config, or None when it is not.

A value is a plausible day when:

• digit_count is not 4 (four-digit numbers cannot be days).
• The value is within the universal day range 1–31.
• The value falls within the caller-configured min/max bounds.

impl DayConfig

pub fn with_range(self, min: u8, max: u8) -> Self

Set the valid day range.

Panics

Panics if min > max. Use DayConfig::try_with_range when the values come from dynamic input and you need to handle the error.

use partial_date::models::DayConfig;

let config = DayConfig::default().with_range(1, 28);

pub fn try_with_range(self, min: u8, max: u8) -> Result<Self, ConfigRangeError>

Set the valid day range, returning Err if min > max.

Use this when the range values come from dynamic input. For known-valid static values, prefer DayConfig::with_range.

pub fn with_expected(self, expected: IsExpected) -> Self

Set whether a day component is expected in the input.

use partial_date::models::{DayConfig, IsExpected};

let config = DayConfig::default().with_expected(IsExpected::Yes);

Examples found in repository

examples/console_entry_config.rs (line 83)

    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),
            ),
        }
    }

pub fn with_default(self, default: u8) -> Self

Set the default day value to use when no day is found in the input.

use partial_date::models::DayConfig;

let config = DayConfig::default().with_default(1);

Trait Implementations

impl Clone for DayConfig

fn clone(&self) -> DayConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DayConfig

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

Formats the value using the given formatter.

impl Default for DayConfig

fn default() -> Self

Returns the “default value” for a type.