use std::num::NonZeroUsize;
use std::sync::Arc;
use thiserror::Error;
use super::{AssertionId, DerivationStepId, ModulationIndexDomain, RuleId};
use super::registry;
#[non_exhaustive]
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ResolutionAuthority {
FormatRule(RuleId),
CallerAssertion(AssertionId),
UserConstructed,
}
#[non_exhaustive]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TrustClass {
FormatResolved,
CallerAsserted,
UserProvided,
}
impl ResolutionAuthority {
pub const fn trust_class(&self) -> TrustClass {
match self {
Self::FormatRule(_) => TrustClass::FormatResolved,
Self::CallerAssertion(_) => TrustClass::CallerAsserted,
Self::UserConstructed => TrustClass::UserProvided,
}
}
}
#[non_exhaustive]
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum NormalizationFact {
CanonicalLaneOrder {
lanes: NonZeroUsize,
},
PublicComplexConvention,
TraceMappingBijection,
SourceCoefficients {
active: bool,
values: usize,
},
PeriodicModulation {
period: NonZeroUsize,
domain: ModulationIndexDomain,
},
DirectSampleEncoding,
UserDefinedComponentTransform,
UserDefinedCartesianNormalization,
DigitalFilterDelay,
ChemicalShiftReference,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct NormalizationEvidence {
authority: ResolutionAuthority,
facts: Arc<[NormalizationFact]>,
derivation: Arc<[DerivationStepId]>,
}
impl NormalizationEvidence {
pub(crate) fn from_format(
rule: RuleId,
facts: Vec<NormalizationFact>,
derivation: Vec<DerivationStepId>,
) -> Result<Self, EvidenceValidationError> {
Self::try_new(ResolutionAuthority::FormatRule(rule), facts, derivation)
}
pub(crate) fn from_assertion(
assertion: AssertionId,
facts: Vec<NormalizationFact>,
derivation: Vec<DerivationStepId>,
) -> Result<Self, EvidenceValidationError> {
Self::try_new(
ResolutionAuthority::CallerAssertion(assertion),
facts,
derivation,
)
}
pub fn user_constructed(
facts: Vec<NormalizationFact>,
) -> Result<Self, EvidenceValidationError> {
Self::try_new(
ResolutionAuthority::UserConstructed,
facts,
vec![registry::USER_CONSTRUCTION_V1],
)
}
fn try_new(
authority: ResolutionAuthority,
facts: Vec<NormalizationFact>,
derivation: Vec<DerivationStepId>,
) -> Result<Self, EvidenceValidationError> {
if facts.is_empty() {
return Err(EvidenceValidationError::MissingFact);
}
if derivation.is_empty() {
return Err(EvidenceValidationError::MissingDerivation);
}
Ok(Self {
authority,
facts: facts.into(),
derivation: derivation.into(),
})
}
pub fn authority(&self) -> &ResolutionAuthority {
&self.authority
}
pub fn trust_class(&self) -> TrustClass {
self.authority.trust_class()
}
pub fn facts(&self) -> &[NormalizationFact] {
&self.facts
}
pub fn derivation(&self) -> &[DerivationStepId] {
&self.derivation
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ComponentEvidence(NormalizationEvidence);
impl ComponentEvidence {
pub fn user_constructed() -> Self {
Self(
NormalizationEvidence::user_constructed(vec![
NormalizationFact::CanonicalLaneOrder {
lanes: NonZeroUsize::new(2).expect("two is nonzero"),
},
NormalizationFact::PublicComplexConvention,
NormalizationFact::UserDefinedCartesianNormalization,
])
.expect("built-in evidence is valid"),
)
}
pub(crate) fn resolved(evidence: NormalizationEvidence) -> Self {
Self(evidence)
}
pub fn evidence(&self) -> &NormalizationEvidence {
&self.0
}
}
#[non_exhaustive]
#[derive(Clone, Debug, Error, Eq, PartialEq)]
pub enum EvidenceValidationError {
#[error("evidence identifier must not be empty")]
EmptyIdentifier,
#[error("normalization evidence requires at least one typed fact")]
MissingFact,
#[error("normalization evidence requires a versioned derivation")]
MissingDerivation,
#[error("chemical-shift reference is invalid")]
InvalidChemicalShiftReference,
#[error("frequency offset is not finite")]
InvalidFrequencyOffset,
#[error("chemical-shift conversion result is not finite")]
InvalidChemicalShiftResult,
#[error("group delay must be finite and non-negative")]
InvalidGroupDelay,
#[error("trace permutation must be a nonempty bijection over 0..len")]
InvalidTracePermutation,
}
impl ComponentEvidence {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(&self) -> (&NormalizationEvidence,) {
(&self.0,)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (NormalizationEvidence,),
) -> Result<Self, crate::internal::ModelError> {
let (f0,) = parts;
let value = Self(f0);
Ok(value)
}
}
impl NormalizationEvidence {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&ResolutionAuthority,
&Arc<[NormalizationFact]>,
&Arc<[DerivationStepId]>,
) {
(&self.authority, &self.facts, &self.derivation)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
ResolutionAuthority,
Arc<[NormalizationFact]>,
Arc<[DerivationStepId]>,
),
) -> Result<Self, crate::internal::ModelError> {
let (authority, facts, derivation) = parts;
let value = Self {
authority,
facts,
derivation,
};
if value.facts.is_empty() || value.derivation.is_empty() {
return Err(crate::internal::ModelError::Structure);
}
Ok(value)
}
}