Struct SlidingWindowPivot 

pub struct SlidingWindowPivot(/* private fields */);

The pivot point for a TwoDigitYearExpansion::SlidingWindow.

A valid pivot is in the range 1–99. A pivot of p means two-digit values 0..(p-1) map to the upper (more recent) part of the window, and values p..99 map to the lower (earlier) part.

Construction

Use SlidingWindowPivot::new for known-valid static values (panics on invalid input) or SlidingWindowPivot::try_new when the value comes from dynamic input and you need to handle the error:

use partial_date::models::SlidingWindowPivot;

// Known-valid — panics if the value is invalid.
let pivot = SlidingWindowPivot::new(50);

// Dynamic input — returns Result.
let pivot = SlidingWindowPivot::try_new(50).unwrap();

// Via TryFrom.
let pivot: SlidingWindowPivot = 50_u8.try_into().unwrap();

Implementations

impl SlidingWindowPivot

pub fn new(pivot: u8) -> Self

Create a new SlidingWindowPivot.

Panics

Panics if pivot is 0 or greater than 99. Use SlidingWindowPivot::try_new when the value comes from dynamic input and you need to handle the error instead of panicking.

Examples found in repository

examples/all_examples.rs (line 664)

fn example_22_all_component_orders() {
    println!("2️⃣2️⃣  ALL COMPONENT ORDERS");
    println!("   Same input '01 06 24', different interpretations based on order\n");

    let input_str = "01 06 24";
    let orders = vec![
        (
            "DMY",
            ComponentOrder {
                first: DateComponent::Day,
                second: DateComponent::Month,
                third: DateComponent::Year,
            },
        ),
        (
            "MDY",
            ComponentOrder {
                first: DateComponent::Month,
                second: DateComponent::Day,
                third: DateComponent::Year,
            },
        ),
        (
            "YMD",
            ComponentOrder {
                first: DateComponent::Year,
                second: DateComponent::Month,
                third: DateComponent::Day,
            },
        ),
        (
            "YDM",
            ComponentOrder {
                first: DateComponent::Year,
                second: DateComponent::Day,
                third: DateComponent::Month,
            },
        ),
        (
            "MYD",
            ComponentOrder {
                first: DateComponent::Month,
                second: DateComponent::Year,
                third: DateComponent::Day,
            },
        ),
        (
            "DYM",
            ComponentOrder {
                first: DateComponent::Day,
                second: DateComponent::Year,
                third: DateComponent::Month,
            },
        ),
    ];

    for (order_name, order) in orders {
        let input = Input {
            utterance: input_str.to_string(),
            config: Some(Config {
                component_order: order,
                year: YearConfig {
                    expected: IsExpected::Yes,
                    two_digit_expansion: TwoDigitYearExpansion::SlidingWindow {
                        earliest_year: 1950,
                        pivot: SlidingWindowPivot::new(50),
                    },
                    ..Default::default()
                },
                ..Default::default()
            }),
        };

        let result = extract(input);
        println!(
            "   {} → Day: {:?}, Month: {:?}, Year: {:?}",
            order_name, result.day.value, result.month.number, result.year.value
        );
    }
    println!();
}

examples/console_entry_config.rs (line 126)

    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 try_new(pivot: u8) -> Result<Self, SlidingWindowPivotError>

Create a new SlidingWindowPivot, returning Err if pivot is 0 or greater than 99.

Use this when the pivot value comes from dynamic input (e.g. user configuration, a config file). For known-valid static values, prefer SlidingWindowPivot::new.

Trait Implementations

impl Clone for SlidingWindowPivot

fn clone(&self) -> SlidingWindowPivot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SlidingWindowPivot

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

Formats the value using the given formatter.

impl From<SlidingWindowPivot> for u8

fn from(pivot: SlidingWindowPivot) -> u8

Converts to this type from the input type.

impl PartialEq for SlidingWindowPivot

fn eq(&self, other: &SlidingWindowPivot) -> 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 TryFrom<u8> for SlidingWindowPivot

type Error = SlidingWindowPivotError

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for SlidingWindowPivot

impl Eq for SlidingWindowPivot

impl StructuralPartialEq for SlidingWindowPivot