Struct Century 

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

A year that falls exactly on a century boundary (divisible by 100).

Used with TwoDigitYearExpansion::Always to express that all two-digit values should map into a specific century. For example, Century::new(1800) means 00 → 1800, 34 → 1834, 99 → 1899.

Construction

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

use partial_date::models::Century;

// Known-valid — panics if the value is not a century boundary.
let century = Century::new(1800);

// Dynamic input — returns Result.
let century = Century::try_new(2000).unwrap();

// Via TryFrom.
let century: Century = 2000_i32.try_into().unwrap();

Implementations

impl Century

pub fn new(year: i32) -> Self

Create a new Century.

Panics

Panics if year is not divisible by 100. Use Century::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 313)

fn example_11_year_two_digit_always_2000s() {
    println!("1️⃣1️⃣  TWO-DIGIT YEAR: Always(Century(2000))");
    println!("   Input: '25/12/99'");
    println!("   Config: Two-digit expansion = Always(Century(2000)) (all become 2000-2099)\n");

    let input = Input {
        utterance: "25/12/99".to_string(),
        config: Some(Config {
            component_order: ComponentOrder {
                first: DateComponent::Day,
                second: DateComponent::Month,
                third: DateComponent::Year,
            },
            year: YearConfig {
                expected: IsExpected::Yes,
                two_digit_expansion: TwoDigitYearExpansion::Always(Century::new(2000)),
                ..Default::default()
            },
            ..Default::default()
        }),
    };

    let result = extract(input);
    println!("   ✓ Input '99' expands to: {:?}", result.year.value);
    println!("   (Note: normally 99 → 1999, here → 2099)\n");
}

examples/console_entry_config.rs (line 145)

    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(year: i32) -> Result<Self, CenturyError>

Create a new Century, returning Err if year is not divisible by 100.

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

Trait Implementations

impl Clone for Century

fn clone(&self) -> Century

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Century

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

Formats the value using the given formatter.

impl From<Century> for i32

fn from(century: Century) -> i32

Converts to this type from the input type.

impl PartialEq for Century

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

type Error = CenturyError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for Century

impl Eq for Century

impl StructuralPartialEq for Century