Struct AssessmentClock 

pub struct AssessmentClock {
    pub law_in_force_on: NaiveDate,
    pub computed_at: DateTime<Utc>,
}

The two dates a compliance computation needs. They are never the same field.

EU staged obligations attach at a regulated triggering event — for Regulation (EU) 2023/1542 Articles 7, 8 and 10 that is placing on the market or putting into service. Which law governs a given product is therefore fixed at that moment, and does not change when the product is reassessed years later. A battery lawfully placed on the market in 2030 does not acquire the 18 August 2031 minimums by being audited in 2033.

There is deliberately no AssessmentClock::now(). A wall-clock constructor is precisely the mistake this type exists to prevent: it would let every determination silently re-derive the governing law from whichever day the calculation happened to run.

Fields

law_in_force_on: NaiveDate

Which law applies. Derived from the regulated triggering event — never from today’s date.

computed_at: DateTime<Utc>

When this computation ran. Receipt provenance only; this never selects a ruleset.

Implementations

impl AssessmentClock

pub fn placed_on(law_in_force_on: NaiveDate) -> Self

Build a clock for a product whose governing law was fixed on law_in_force_on, computed now.

The wall clock supplies computed_at and nothing else. law_in_force_on must come from the product’s own record — the passport’s placing-on-market date — and never from Utc::now().

Examples found in repository

examples/calculate_metrics.rs (line 15)

fn main() {
    // The date the governing law attached to this product. In a real caller this
    // comes from the passport's placing-on-market date, never from the clock.
    let clock = AssessmentClock::placed_on(NaiveDate::from_ymd_opt(2026, 1, 1).unwrap());

    // Cradle-to-gate CO₂e for a small battery (materials + manufacturing energy).
    let footprint = co2e::calculate(
        &Co2eInputs {
            materials: vec![
                MaterialFootprint {
                    mass_kg: 0.5,
                    emission_factor_kg_co2e_per_kg: 8.0, // e.g. recycled aluminium
                },
                MaterialFootprint {
                    mass_kg: 0.2,
                    emission_factor_kg_co2e_per_kg: 3.0,
                },
            ],
            energy_kwh: 1.5,
            grid_factor_kg_co2e_per_kwh: 0.4,
        },
        &CradleToGateRuleset,
        clock,
    )
    .expect("valid inputs");

    println!(
        "CO₂e: {:.2} kg  (materials {:.2} + energy {:.2})  stages={:?}  receipt={}",
        footprint.total_co2e_kg,
        footprint.material_co2e_kg,
        footprint.energy_co2e_kg,
        footprint.declared_stages,
        footprint.receipt.receipt_id,
    );
    for (i, line) in footprint.material_breakdown.iter().enumerate() {
        println!(
            "  material[{i}]: {:.3} kg × {:.3} kg CO₂e/kg = {:.3} kg CO₂e",
            line.mass_kg, line.emission_factor_kg_co2e_per_kg, line.co2e_kg
        );
    }

    // Simplified repairability heuristic band (A–E) for a smartphone — not the
    // EU 2023/1669 regulatory class.
    let rep = repairability::calculate(
        &RepairabilityInputs {
            disassembly: 2,
            spare_parts: 2,
            repair_info: 1,
            diagnostic_tools: 1,
            software_updatability: 2,
            customer_support: 1,
        },
        &SimplifiedRepairabilityHeuristic,
        clock,
    )
    .expect("valid inputs");

    println!(
        "Repairability: {}  ({:.2}/10)  ruleset={}@{}",
        rep.class, rep.numeric_score, rep.receipt.ruleset_id, rep.receipt.ruleset_version,
    );
    let c = &rep.contributions;
    println!(
        "  disassembly={:.2} spare_parts={:.2} repair_info={:.2} \
         diagnostic={:.2} software={:.2} support={:.2}",
        c.disassembly,
        c.spare_parts,
        c.repair_info,
        c.diagnostic_tools,
        c.software_updatability,
        c.customer_support,
    );
}

pub const fn new(law_in_force_on: NaiveDate, computed_at: DateTime<Utc>) -> Self

Fully explicit constructor, pinning both dates.

Re-verifying a stored receipt needs this: reproducing a historical calculation means reproducing the computation timestamp too, not just the governing law.

Trait Implementations

impl Clone for AssessmentClock

fn clone(&self) -> AssessmentClock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AssessmentClock

impl Debug for AssessmentClock

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AssessmentClock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AssessmentClock

impl PartialEq for AssessmentClock

fn eq(&self, other: &AssessmentClock) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for AssessmentClock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AssessmentClock