Enum ConsentDefect 

#[non_exhaustive]
pub enum ConsentDefect<'a> {
    NoTransfer,
    OutgoingAuthorisationMissing,
    NotAccepted,
    IncomingOperatorMismatch {
        expected: &'a str,
        found: &'a str,
    },
    OperationMismatch {
        edge_operation: &'a str,
        transfer_reason: &'a str,
    },
}

Why one derivation edge is not supported by a transfer of responsibility.

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.

NoTransfer

No transfer record corresponds to this predecessor at all, so the claim to have taken responsibility rests on this operator’s own assertion.

OutgoingAuthorisationMissing

The outgoing operator never authorised the handover.

The defect that matters most: without it there is no predecessor consent at all, and the edge is exactly the unilateral assertion the rule exists to catch.

NotAccepted

The handover was never completed — still pending, or rejected, or cancelled. An abandoned transfer does not support a live claim.

IncomingOperatorMismatch

The transfer hands responsibility to someone other than this passport’s operator, so it is not evidence that this operator took it on.

Fields

expected: &'a str

This passport’s operator.

found: &'a str

Who the transfer actually names.

OperationMismatch

A transfer exists but records a different operation than the edge claims.

Art. 77(7)’s four operations carry different legal consequences, so the two must name the same one.

Fields

edge_operation: &'a str

What the edge claims happened.

transfer_reason: &'a str

What the transfer records happened.

Trait Implementations

impl<'a> Clone for ConsentDefect<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for ConsentDefect<'a>

impl<'a> Debug for ConsentDefect<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for ConsentDefect<'a>

impl<'a> PartialEq for ConsentDefect<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for ConsentDefect<'a>