Struct PassportBook 

pub struct PassportBook {
    pub country: String,
    pub number: String,
    pub issued: Option<NaiveDate>,
    pub expires: Option<NaiveDate>,
}

A passport book — country of issue, book number, and optional effective date range.

Passport data has three properties that make it a poor fit for the crate’s per-scheme Option<String> national-identifier pattern, and which this type captures explicitly:

1. Scheme-local provenance. A passport book number is only meaningful alongside its issuing country. The book number "AB123456" issued by the United Kingdom is a different identifier from "AB123456" issued by the United States; the matcher MUST NOT cross-match them. Provenance lives on the PassportBook::country field, not on the field name.
2. Multi-country. A single worker may hold passports from multiple countries simultaneously (dual / multiple citizenship). A Vec<PassportBook> lets a crate::Worker carry one entry per book without privileging any particular jurisdiction.
3. Time-varying. When a passport is renewed, the new book has a different number; the old book number is no longer current but the worker is unchanged. Worker records may carry the current book, prior books, or both. Matching treats any shared (country, number) pair across the two records as evidence that the records refer to the same worker, regardless of issue date.

Construction via PassportBook::new canonicalises both the country (trimmed, uppercased; must be exactly 2 ASCII letters) and the number (whitespace stripped, letters uppercased) so two records carrying different textual layouts of the same book canonicalise to the same (country, number) key. Date fields are optional metadata and are not used in matching — they exist for downstream display and audit. Per-country structural validation is intentionally not performed; passport formats vary widely and a case+whitespace canonical form is sufficient for matching.

Example

use worker_matcher::PassportBook;
use chrono::NaiveDate;

let book = PassportBook::new("gb", " 123 456 789 ")
    .expect("valid book")
    .with_issued(NaiveDate::from_ymd_opt(2020, 1, 1).unwrap())
    .with_expires(NaiveDate::from_ymd_opt(2030, 1, 1).unwrap());

assert_eq!(book.country, "GB");
assert_eq!(book.number,  "123456789");
assert!(book.issued.is_some());

// Rejection: country must be exactly 2 ASCII letters.
assert!(PassportBook::new("GBR", "123").is_none());
assert!(PassportBook::new("1A",  "123").is_none());
// Rejection: number must canonicalise to a non-empty string.
assert!(PassportBook::new("GB",  "   ").is_none());

Fields

country: String

ISO 3166-1 alpha-2 country code of issuance, uppercased.

number: String

Passport book number, whitespace-stripped and uppercased.

issued: Option<NaiveDate>

Optional issue date (not used in matching).

expires: Option<NaiveDate>

Optional expiry date (not used in matching).

Implementations

impl PassportBook

pub fn new(country: impl AsRef<str>, number: impl AsRef<str>) -> Option<Self>

Construct a passport book, validating and canonicalising the country code (trimmed + uppercased; must be exactly 2 ASCII letters) and the book number (whitespace stripped + uppercased; must be non-empty after stripping).

Returns None for an invalid country code or an empty canonical number.

use worker_matcher::PassportBook;
let b = PassportBook::new("us", "abc 123 456").unwrap();
assert_eq!(b.country, "US");
assert_eq!(b.number,  "ABC123456");

pub fn with_issued(self, date: NaiveDate) -> Self

Attach an issue date. The date is metadata only — it is NOT used in matching.

use worker_matcher::PassportBook;
use chrono::NaiveDate;
let b = PassportBook::new("GB", "123456789").unwrap()
    .with_issued(NaiveDate::from_ymd_opt(2020, 1, 1).unwrap());
assert!(b.issued.is_some());

pub fn with_expires(self, date: NaiveDate) -> Self

Attach an expiry date. The date is metadata only — it is NOT used in matching.

use worker_matcher::PassportBook;
use chrono::NaiveDate;
let b = PassportBook::new("GB", "123456789").unwrap()
    .with_expires(NaiveDate::from_ymd_opt(2030, 1, 1).unwrap());
assert!(b.expires.is_some());

Trait Implementations

impl Clone for PassportBook

fn clone(&self) -> PassportBook

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PassportBook

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PassportBook

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PassportBook

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PassportBook

impl StructuralPartialEq for PassportBook