Enum PredictionContractError 

#[non_exhaustive]
pub enum PredictionContractError {
    InvalidEngineContract(EngineContractError),
    DuplicateProductionRule(String),
    InvalidDependencyClosure(String),
    TextTooLong {
        field: &'static str,
        bytes: usize,
        limit: usize,
    },
    InvalidToken {
        field: &'static str,
        value: String,
    },
    NonFiniteNumber,
    InvalidMeasurementPointer(String),
    MeasurementPointerMissing(String),
    MeasurementPointerNotScalar(String),
    MeasurementValueMismatch(String),
    TooManyMeasurementPointerComponents {
        components: usize,
        limit: usize,
    },
    RawSourceDomainKeyMismatch,
    RawSourceRowNotFound,
    RawSourceFieldUnavailable(String),
    RawSourceValueMismatch,
    ExactSourceTimingCoverageMismatch,
    ExactSourceTimingClipPrefixMismatch,
    InvalidExactSourceTimingObservation(&'static str),
    ExactSourceTimingFieldUnavailable(String),
    ExactSourceTimingValueMismatch,
    TooManyBasisReferences {
        found: usize,
        limit: usize,
    },
    DuplicateBasisReference,
    AvailableBasisEmpty,
    AvailableHasReasons,
    AvailableResultMissing,
    UnavailableHasResult,
    InvalidMachineResult(&'static str),
    MachineResultRequiresRawSceneInventory,
    InvalidRawSceneAttachmentBinding,
    InvalidRawTransformPathInventory,
    InvalidProjectIntent(&'static str),
    RawSceneAttachmentBasisReferenceNotFound,
    RequiredUnavailableWithoutReason,
    DuplicateUnavailableReason(String),
    InvalidUnavailableReasonCode(String),
    TooManyUnavailableReasons {
        found: usize,
        limit: usize,
    },
    EmptyFacetList,
    TooManyFacets {
        found: usize,
        limit: usize,
    },
    DuplicateFacetScope,
    SourceFormatMismatch,
    SourceFormatNotAccepted,
    PrimaryInputMismatch,
    DependencyClosureCoverageMismatch,
    ProvenanceIdentityMismatch,
    UnknownProfileFact(String),
    UnknownResolvedSetting(String),
    UnknownPrimarySource(String),
    AvailableScopeNotEvaluatedExactlyOnce,
    InvalidFacetBudgetSummary,
    DuplicateFacetBudgetSummary,
    EngineAddressabilityInventoryReasonsMismatch,
    EngineAddressabilityFacetPrefixMismatch,
    EngineClipBoundaryFacetMismatch,
    EngineClipBoundaryFindingMismatch,
    EngineUnitScaleFacetMismatch,
    UnavailableScopeEvaluated,
    UnavailableScopeDuplicatedAsGap,
    FindingMissingPredictionScope,
    FindingScopeNotAvailable,
    IdentityMismatch {
        contract: &'static str,
    },
    InvalidSchema {
        field: &'static str,
        expected: &'static str,
        found: String,
    },
    NonCanonicalOrder(&'static str),
    InvalidConsumedContracts,
    TooMuchRetainedText {
        found: usize,
        limit: usize,
    },
    TooManyAggregateProvenanceRows {
        found: usize,
        limit: usize,
    },
    ArithmeticOverflow(&'static str),
}

A prediction/provenance value violated the immutable V1 contract.

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.

InvalidEngineContract(EngineContractError)

An embedded profile or settings value was invalid.

DuplicateProductionRule(String)

Catalog registration repeated one V2 production-rule id.

InvalidDependencyClosure(String)

An embedded dependency-closure wire was structurally valid but violated its immutable semantic contract.

TextTooLong

A retained string exceeded its per-value bound.

Fields

field: &'static str

Semantic field being retained.

bytes: usize

Actual UTF-8 byte count.

limit: usize

Contract limit.

InvalidToken

A stable token was empty, contained controls, or used invalid syntax.

Fields

field: &'static str

Semantic token field.

value: String

Rejected spelling.

NonFiniteNumber

A finite-number scalar contained NaN or infinity.

InvalidMeasurementPointer(String)

A measurement pointer was not a canonical measurements-root RFC 6901 pointer.

MeasurementPointerMissing(String)

A measurement pointer did not resolve in the validated contract.

MeasurementPointerNotScalar(String)

A measurement pointer resolved to an object or array rather than a scalar.

MeasurementValueMismatch(String)

A measurement pointer’s retained scalar disagreed with the validated contract.

TooManyMeasurementPointerComponents

A measurement pointer exceeded its component bound.

Fields

components: usize

Decoded component count.

limit: usize

Contract limit.

RawSourceDomainKeyMismatch

A raw-source domain and stable key identify different row kinds.

RawSourceRowNotFound

The stable raw-source row key was absent from the same-load facts.

RawSourceFieldUnavailable(String)

The field id does not name a scalar on the selected raw-source row.

RawSourceValueMismatch

The retained raw-source scalar disagrees with same-load facts.

ExactSourceTimingCoverageMismatch

Exact source timing and V1 source-clip coverage disagree.

ExactSourceTimingClipPrefixMismatch

Exact source clip rows were not a canonical zero-based retained prefix.

InvalidExactSourceTimingObservation(&'static str)

One exact source timing observation has an invalid state/disposition/provenance combination.

ExactSourceTimingFieldUnavailable(String)

An exact source timing basis reference names no scalar in the embedded binding.

ExactSourceTimingValueMismatch

An exact source timing basis scalar disagrees with the embedded binding.

TooManyBasisReferences

One facet exceeded the per-facet basis-reference bound.

Fields

found: usize

Supplied reference count.

limit: usize

Contract limit.

DuplicateBasisReference

Canonical basis rows contained an exact duplicate.

AvailableBasisEmpty

An available facet had no evidence basis.

AvailableHasReasons

An available facet carried an unavailable reason.

AvailableResultMissing

A V4 available facet omitted its mandatory machine result.

UnavailableHasResult

A V4 required-unavailable facet incorrectly carried a result.

InvalidMachineResult(&'static str)

A machine-result variant carried an incoherent field combination.

MachineResultRequiresRawSceneInventory

A result that consumes scene/attachment inventory lacked that authority.

InvalidRawSceneAttachmentBinding

Raw scene/attachment availability contradicted source format or identity.

InvalidRawTransformPathInventory

Raw transform-path inventory failed its immutable semantic validation.

InvalidProjectIntent(&'static str)

Effective root-motion project intent violated its immutable contract.

RawSceneAttachmentBasisReferenceNotFound

A V4 basis reference did not resolve in the bound raw scene inventory.

RequiredUnavailableWithoutReason

A required-unavailable facet carried no stable reason.

DuplicateUnavailableReason(String)

A reason list contained an exact duplicate.

InvalidUnavailableReasonCode(String)

A custom reason code was not a bounded namespaced ASCII code.

TooManyUnavailableReasons

One facet exceeded the unavailable-reason bound.

Fields

found: usize

Supplied reason count.

limit: usize

Contract limit.

EmptyFacetList

An engine prediction did not contain any facets.

TooManyFacets

One engine prediction exceeded the facet bound.

Fields

found: usize

Supplied facet count.

limit: usize

Contract limit.

DuplicateFacetScope

Canonical facets reused a scope.

SourceFormatMismatch

The profile, raw-source binding, and header source formats disagreed.

SourceFormatNotAccepted

The resolved profile does not accept the same-load source format.

PrimaryInputMismatch

Raw-source and dependency-closure primary identities disagreed.

DependencyClosureCoverageMismatch

Raw resource coverage and the same-load dependency closure disagreed.

ProvenanceIdentityMismatch

A prediction refers to a different file provenance identity.

UnknownProfileFact(String)

A basis profile-fact id is absent from the embedded profile.

UnknownResolvedSetting(String)

A basis setting location/id is absent or contradicts the profile descriptor.

UnknownPrimarySource(String)

A basis primary-source id is absent from the embedded profile.

AvailableScopeNotEvaluatedExactlyOnce

An available facet scope was absent or duplicated in completed scopes.

InvalidFacetBudgetSummary

A V2 shared-file budget summary was not the canonical unavailable summary facet for its owning production rule.

DuplicateFacetBudgetSummary

A V2 production rule emitted more than one shared-file budget summary.

EngineAddressabilityInventoryReasonsMismatch

The current engine-addressability inventory did not carry the exact raw/settings incompleteness reasons implied by its V2 provenance.

EngineAddressabilityFacetPrefixMismatch

The current engine-addressability available facets did not retain the canonical source-index prefix.

EngineClipBoundaryFacetMismatch

The current engine-clip-boundary facets did not match the exact timing rows, availability states, reasons, or canonical evidence bases implied by V3 provenance.

EngineClipBoundaryFindingMismatch

The current engine-clip-boundary findings did not identify exactly the available source-clip ends outside their exact frame lattice.

EngineUnitScaleFacetMismatch

The current engine-unit-scale facets did not match the exact profile, rule-input, raw-inventory, and measurement evidence embedded in V15.

UnavailableScopeEvaluated

A required-unavailable facet scope was also reported as completed.

UnavailableScopeDuplicatedAsGap

A required-unavailable facet was duplicated as an ordinary coverage gap.

FindingMissingPredictionScope

A prediction-bearing finding lacked its required facet binding.

FindingScopeNotAvailable

A finding scope did not name exactly one available facet.

IdentityMismatch

A canonical identity did not match its recomputed preimage.

Fields

contract: &'static str

Contract whose identity was rejected.

InvalidSchema

A schema field did not carry its immutable V1 identity.

Fields

field: &'static str

Field carrying the schema id.

expected: &'static str

Required identity.

found: String

Supplied identity.

NonCanonicalOrder(&'static str)

A canonical ordered collection was supplied out of order.

InvalidConsumedContracts

The exact derived consumed-contract inventory was changed.

TooMuchRetainedText

Aggregate retained text exceeded its file bound.

Fields

found: usize

Observed retained text.

limit: usize

Contract limit.

TooManyAggregateProvenanceRows

Aggregate embedded profile, settings, and raw-source rows exceeded the file bound.

Fields

found: usize

Observed aggregate retained row count.

limit: usize

Immutable V1 row limit.

ArithmeticOverflow(&'static str)

Checked accounting overflowed.

Trait Implementations

impl Clone for PredictionContractError

fn clone(&self) -> PredictionContractError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PredictionContractError

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

Formats the value using the given formatter.

impl Display for PredictionContractError

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

Formats the value using the given formatter.

impl Eq for PredictionContractError

impl Error for PredictionContractError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<EngineContractError> for PredictionContractError

fn from(source: EngineContractError) -> Self

Converts to this type from the input type.

impl From<PredictionContractError> for OutputContractError

fn from(source: PredictionContractError) -> Self

Converts to this type from the input type.

impl From<PredictionContractError> for EvaluationError

fn from(source: PredictionContractError) -> Self

Converts to this type from the input type.

impl PartialEq for PredictionContractError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PredictionContractError