Enum ExactSp3ValidationError 

#[non_exhaustive]
pub enum ExactSp3ValidationError {
    Parse(Error),
    Catalog(DataCatalogError),
    WrongProductFamily {
        actual: ProductType,
    },
    InvalidIssue {
        issue: String,
    },
    UnsupportedSpanToken {
        token: String,
    },
    UnsupportedSampleToken {
        token: String,
    },
    NonCanonicalSpanToken {
        token: String,
        canonical: String,
    },
    NonCanonicalSampleToken {
        token: String,
        canonical: String,
    },
    InvalidExpectedAgency {
        agency: String,
    },
    AgencyMismatch {
        expected: String,
        actual: String,
    },
    MissingEof,
    MalformedEofRecord {
        line_number: usize,
        record_length: usize,
    },
    TrailingContentAfterEof,
    MandatoryHeaderRecordCount {
        record: &'static str,
        expected: usize,
        actual: usize,
    },
    MissingDeclaredSatelliteCount,
    DeclaredSatelliteCountMismatch {
        declared: usize,
        tokens: usize,
    },
    DuplicateDeclaredSatellite {
        token: String,
        first_index: usize,
        duplicate_index: usize,
    },
    NoDeclaredSatellites,
    SatelliteRecordSequenceMismatch {
        record: &'static str,
        epoch_index: usize,
        expected: Vec<String>,
        actual: Vec<String>,
    },
    BodyRecordInterleavingMismatch {
        epoch_index: usize,
        expected: Vec<String>,
        actual: Vec<String>,
    },
    NonFiniteHeaderCadence,
    NonPositiveHeaderCadence {
        actual_s: f64,
    },
    UnsupportedHeaderCadence {
        actual_s: f64,
    },
    CadenceMismatch {
        requested_s: f64,
        header_s: f64,
    },
    DeclaredEpochCountMismatch {
        declared: u64,
        parsed: usize,
    },
    MissingDeclaredStart,
    DeclaredStartMismatch {
        requested_j2000_s: f64,
        declared_j2000_s: f64,
    },
    RequestBeforeGpsEpoch,
    NonFiniteHeaderStartMetadata {
        field: &'static str,
    },
    InvalidHeaderStartMetadata {
        field: &'static str,
        actual: f64,
    },
    HeaderStartMetadataMismatch {
        field: &'static str,
        requested: f64,
        actual: f64,
    },
    EmptyEpochGrid,
    FirstEpochMismatch {
        requested_j2000_s: f64,
        actual_j2000_s: f64,
    },
    IrregularEpochGrid {
        epoch_index: usize,
        requested_s: f64,
        actual_s: f64,
    },
    SpanNotMultipleOfCadence {
        span_s: u64,
        cadence_s: u64,
    },
    SpanMismatch {
        parsed: usize,
        half_open: usize,
        inclusive: usize,
    },
    FormatVersionMismatch {
        requested: String,
        actual: String,
    },
}

Integrity failure while parsing or validating an exact SP3 product.

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.

Parse(Error)

The bytes are not a parseable SP3 product.

Catalog(DataCatalogError)

The full catalog identity is invalid.

WrongProductFamily

A non-SP3 identity was supplied to the SP3 validator.

Fields

actual: ProductType

Supplied family.

InvalidIssue

The optional start/issue token is not a valid HHMM value.

Fields

issue: String

Supplied token; an absent issue is represented by midnight and is never invalid.

UnsupportedSpanToken

The requested span token is not a supported fixed-duration token.

Fields

token: String

Supplied token.

UnsupportedSampleToken

The requested sample token is not a supported positive SP3 interval.

Fields

token: String

Supplied token.

NonCanonicalSpanToken

A valid fixed-duration span token did not use the longest exact unit.

Fields

token: String

Supplied token.

canonical: String

Equivalent canonical token.

NonCanonicalSampleToken

A valid fixed-duration sample token did not use the longest exact unit.

Fields

token: String

Supplied token.

canonical: String

Equivalent canonical token.

InvalidExpectedAgency

An expected agency constraint is not a valid SP3 A4 producer code.

Fields

agency: String

Supplied agency code.

AgencyMismatch

Parsed SP3 producing agency differs from the exact request.

Fields

expected: String

Required agency code.

actual: String

Parsed header agency code.

MissingEof

The product omitted its terminal EOF record.

MalformedEofRecord

The product contained an EOF-like record that violated the accepted logical-record grammar.

Fields

line_number: usize

One-based logical-record line number.

record_length: usize

Length of the offending logical record in bytes.

TrailingContentAfterEof

Nonblank records appeared after the terminal EOF marker.

MandatoryHeaderRecordCount

A mandatory SP3 header record count is incomplete or inconsistent.

Fields

record: &'static str

Record prefix (+, ++, %c, %f, or %i).

expected: usize

Required exact or minimum count.

actual: usize

Parsed count.

MissingDeclaredSatelliteCount

The first + record does not carry a parseable declared satellite count.

DeclaredSatelliteCountMismatch

The line-3 count differs from the number of non-padding raw declaration tokens across all + records.

Fields

declared: usize

Count from line 3.

tokens: usize

Number of raw non-padding tokens.

DuplicateDeclaredSatellite

A satellite token appears more than once in the header declaration.

Fields

token: String

Duplicate raw satellite token.

first_index: usize

First declaration index.

duplicate_index: usize

Duplicate declaration index.

NoDeclaredSatellites

The header declares no satellites.

SatelliteRecordSequenceMismatch

One epoch’s raw P or V records do not exactly match the declared satellite count and order.

Fields

record: &'static str

Record type (P or V).

epoch_index: usize

Zero-based parsed epoch index.

expected: Vec<String>

Raw declared satellite order.

actual: Vec<String>

Raw record satellite order.

BodyRecordInterleavingMismatch

P/V records have the right per-type tokens but not the required body order (for a velocity product, P(sat), V(sat) pairs).

Fields

epoch_index: usize

Zero-based parsed epoch index.

expected: Vec<String>

Required tagged record sequence, such as PG01, VG01.

actual: Vec<String>

Parsed tagged record sequence.

NonFiniteHeaderCadence

The SP3 header declares a non-finite epoch interval.

NonPositiveHeaderCadence

The SP3 header declares a zero or negative epoch interval.

Fields

actual_s: f64

Declared interval.

UnsupportedHeaderCadence

The SP3 header interval is outside the range allowed by the format.

Fields

actual_s: f64

Declared interval.

CadenceMismatch

Header cadence does not equal the exact requested sample interval.

Fields

requested_s: f64

Cadence derived from the trusted request token.

header_s: f64

Cadence declared on SP3 header line 2.

DeclaredEpochCountMismatch

Header line 1’s declared number of epochs differs from the parsed grid.

Fields

declared: u64

Count from header line 1.

parsed: usize

Number of parsed epoch records.

MissingDeclaredStart

Header line 1 does not contain an interpretable start epoch.

DeclaredStartMismatch

Header line 1’s start does not equal the exact requested start.

Fields

requested_j2000_s: f64

Exact requested start, seconds since J2000.

declared_j2000_s: f64

Header line 1 start, seconds since J2000.

RequestBeforeGpsEpoch

The requested start predates the GPS week-numbering epoch that SP3 line 2 uses.

NonFiniteHeaderStartMetadata

A floating-point SP3 line-2 start field is not finite.

Fields

field: &'static str

SP3 header field name.

InvalidHeaderStartMetadata

An SP3 line-2 start field is outside its specified range.

Fields

field: &'static str

SP3 header field name.

actual: f64

Parsed field value.

HeaderStartMetadataMismatch

SP3 line-2 week/SOW or MJD metadata does not represent the trusted requested start.

Fields

field: &'static str

Logical SP3 header field (gps_week, seconds_of_week, or mjd).

requested: f64

Value derived from the trusted request.

actual: f64

Parsed header value.

EmptyEpochGrid

The product contains no parsed epoch records.

FirstEpochMismatch

The first parsed epoch does not equal the exact requested start.

Fields

requested_j2000_s: f64

Exact requested start, seconds since J2000.

actual_j2000_s: f64

First parsed epoch, seconds since J2000.

IrregularEpochGrid

Parsed epochs are not a strictly increasing regular requested-cadence grid.

Fields

epoch_index: usize

Index of the later epoch in the failing pair.

requested_s: f64

Exact requested cadence.

actual_s: f64

Difference between this epoch and its predecessor.

SpanNotMultipleOfCadence

The declared span is not an integer multiple of the requested cadence.

Fields

span_s: u64

Requested span.

cadence_s: u64

Requested cadence.

SpanMismatch

A regular grid does not represent either the half-open or inclusive form of the exact requested span.

Fields

parsed: usize

Parsed epoch count.

half_open: usize

Required count for half-open coverage.

inclusive: usize

Required count for inclusive coverage.

FormatVersionMismatch

A resolved identity constrained an SP3 content revision that does not match the parsed header.

Fields

requested: String

Requested revision string.

actual: String

Parsed revision string.

Trait Implementations

impl Clone for ExactSp3ValidationError

fn clone(&self) -> ExactSp3ValidationError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExactSp3ValidationError

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

Formats the value using the given formatter.

impl Display for ExactSp3ValidationError

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

Formats the value using the given formatter.

impl Error for ExactSp3ValidationError

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 PartialEq for ExactSp3ValidationError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ExactSp3ValidationError