Enum Granularity 

#[non_exhaustive]
pub enum Granularity {
    Model,
    Batch,
    Item,
}

The level at which a passport describes a product: a model, a production batch, or one physical unit.

Why this lives in the catalog and not in a port

ESPR Art. 9(2)(d) makes the level a delegated-act decision — “whether the digital product passport is to be established at model, batch or item level”. It is therefore a property of the instrument that imposes the passport, and every consumer downstream is reading that decision rather than making one. The EU registry is one such consumer, which is why RegistrationGranularity exists and converts from this type rather than the other way round.

No Default, deliberately: an act that has not fixed a level is Option::None on the instrument, not a guess at item level. Defaulting here would silently answer a question only a delegated act can answer.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Model

One passport covering every unit sharing a model’s specifications.

Batch

One passport covering every unit made in one production run.

Item

One passport per physical unit.

Implementations

impl Granularity

pub fn most_granular(self, other: Self) -> Self

The more granular of two levels.

The ordering Model < Batch < Item is the derived Ord, and matches the rule the EU registry applies: where several levels are indicated for one product, the most granular wins (IR (EU) 2026/1778 Art. 8(3), and Art. 8(4)–(5) linking an item registration back up to batch and model).

This is why applicable instruments fold to a maximum rather than picking one: two acts naming different levels do not conflict, they compound.

pub const fn describes_a_type(self) -> bool

Whether a passport at this level describes a specification rather than manufactured things.

Model covers every unit sharing a model’s specifications, so it describes a type. Batch and Item both describe things that were made — one run, or one unit.

Why this is answered here

A projection that has to classify the asset it is describing needs it, and this enum is #[non_exhaustive], so a match from another crate must carry a wildcard. A wildcard would quietly file a future level as one answer or the other — and “not stated” is a distinction this type takes care to preserve elsewhere, so it should not be thrown away here. Authored beside the variants, the match is exhaustive.

Trait Implementations

impl Clone for Granularity

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Granularity

impl Debug for Granularity

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Granularity

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Granularity

impl From<Granularity> for RegistrationGranularity

fn from(granularity: Granularity) -> Self

The registry registers at the level the applicable act fixed.

Direction matters: Granularity is the act’s decision under ESPR Art. 9(2)(d), and this type is one consumer of it. A conversion the other way would let a registry default answer a question only a delegated act can answer, which is why none exists — and why this type’s #[default] of Item must never travel back up into the catalog.

impl Ord for Granularity

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Granularity

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Granularity

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Granularity

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 Granularity