use crate::algebra::AlgebraBuildError;
use crate::certificate::CertParseError;
use crate::derived_invariant::DerivedInvariantKind;
use crate::field::FieldError;
use crate::hochschild::HochschildError;
use crate::verify::VerifyError;
#[derive(Clone, Debug)]
pub enum DerivedAtlasError {
ParseLimit {
path: String,
used: usize,
limit: usize,
},
Syntax { byte: usize, message: String },
Schema { found: String },
Kind { found: String },
Engine { found: String },
NonCanonical,
FingerprintMismatch,
EmptyFamily,
Field(FieldError),
Certificate {
member: usize,
error: CertParseError,
},
FieldMismatch { member: usize, found: u64 },
Verify { member: usize, error: VerifyError },
Algebra {
member: usize,
error: AlgebraBuildError,
},
RowCount { rows: usize, members: usize },
CancelledReading { member: usize },
Invariant {
member: usize,
error: HochschildError,
},
ReadingMismatch {
member: usize,
kind: DerivedInvariantKind,
},
Partition,
SpanningTree { class: usize },
PairCoverage,
UnresolvedWalks { classes: (usize, usize) },
Walks,
Status,
Separation { classes: (usize, usize) },
Replay { source: usize, member: usize },
Isomorphism { source: usize, member: usize },
}
from_portable_error!(DerivedAtlasError, header);
display_error! { DerivedAtlasError {
Self::ParseLimit { path, used, limit } => "atlas field {path} needs {used} units, limit {limit}";
Self::Syntax { byte, message } => "invalid atlas JSON at byte {byte}: {message}";
Self::Schema { found } => "unsupported atlas schema {found:?}";
Self::Kind { found } => "unsupported atlas kind {found:?}";
Self::Engine { found } => "unsupported atlas engine {found:?}";
Self::NonCanonical => "atlas JSON is not canonical";
Self::FingerprintMismatch => "atlas fingerprint does not match its canonical fields";
Self::EmptyFamily => "the atlas family has no member";
Self::Field(error) => "atlas field is invalid: {error}";
Self::Certificate { member, error } => "certificate of member {member} is malformed: {error}";
Self::FieldMismatch { member, found } => "member {member} lives over GF({found})";
Self::Verify { member, error } => "certificate of member {member} failed verification: {error}";
Self::Algebra { member, error } => "member {member} did not rebuild: {error}";
Self::RowCount { rows, members } => "the atlas has {rows} invariant rows for {members} members";
Self::CancelledReading { member } => "a reading of member {member} was cancelled";
Self::Invariant { member, error } => "invariants of member {member} failed: {error}";
Self::ReadingMismatch { member, kind } => "the reading {kind:?} of member {member} differs from its recomputation";
Self::Partition => "the classes do not partition the family in representative order";
Self::SpanningTree { class } => "the merges of class {class} do not form a spanning tree";
Self::PairCoverage => "the pairs of classes are not each separated or unresolved exactly once";
Self::UnresolvedWalks { classes } => "the walks of unresolved classes {} and {} are not the walks from their members", classes.0, classes.1;
Self::Walks => "the walk records do not match the merges";
Self::Status => "the status does not match the unresolved pairs";
Self::Separation { classes } => "the separation of classes {} and {} does not hold", classes.0, classes.1;
Self::Replay { source, member } => "the recipe of the merge from member {source} to member {member} does not replay";
Self::Isomorphism { source, member } => "the isomorphism of the merge from member {source} to member {member} does not verify";
} }
error_source! { DerivedAtlasError {
Self::Field(error) => Some(error),
Self::Certificate { error, .. } => Some(error),
Self::Verify { error, .. } => Some(error),
Self::Algebra { error, .. } => Some(error),
Self::Invariant { error, .. } => Some(error),
_ => None,
} }