nmr 0.1.3

NMR data tools for Rust
Documentation
use crate::acquisition::*;
use crate::axis::AxisCoordinates;
use crate::axis::AxisDomain;
use crate::axis::AxisQuantity;
use crate::axis::AxisUnit;
use crate::execution::CancellationToken;
use crate::execution::ExecutionError;
use sha2::{Digest, Sha256};

use super::CanonicalDigest;

pub(super) fn encode_axis(
    out: &mut Encoder<'_>,
    axis: &crate::raw::RawAxis,
) -> Result<(), ExecutionError> {
    match axis.kind() {
        RawAxisKind::Direct(DirectSamples::Real) => out.u8(0),
        RawAxisKind::Direct(DirectSamples::Complex) => out.u8(1),
        RawAxisKind::Indirect(IndirectComponents::Scalar) => out.u8(2),
        RawAxisKind::Indirect(IndirectComponents::Cartesian(evidence)) => {
            out.u8(3);
            encode_evidence(out, evidence.evidence())?;
        }
        RawAxisKind::Indirect(IndirectComponents::Encoded(transform)) => {
            out.u8(4);
            encode_transform(out, transform)?;
        }
        RawAxisKind::Parameter => out.u8(5),
        RawAxisKind::Indirect(IndirectComponents::SharedComplex {
            conjugated,
            evidence,
        }) => {
            out.u8(6);
            out.u8(u8::from(*conjugated));
            encode_evidence(out, evidence.evidence())?;
        }
    }
    out.u8(match axis.domain() {
        AxisDomain::Time => 0,
        AxisDomain::Frequency => 1,
        AxisDomain::Parameter => 2,
        AxisDomain::Unknown => 3,
    });
    out.option_u8(axis.unit().map(|value| match value {
        AxisUnit::Second => 0,
        AxisUnit::Hertz => 1,
        AxisUnit::Ppm => 2,
        AxisUnit::Tesla => 3,
        AxisUnit::TeslaPerMeter => 4,
    }));
    out.option_u8(axis.quantity().map(|value| match value {
        AxisQuantity::MagneticFieldGradientStrength => 0,
        AxisQuantity::TimeDelay => 1,
    }));
    out.usize(axis.points());
    match axis.coordinates() {
        AxisCoordinates::Unknown => out.u8(0),
        AxisCoordinates::Uniform { start, step } => {
            out.u8(1);
            out.f64(*start);
            out.f64(*step);
        }
        AxisCoordinates::Explicit(values) => {
            out.u8(2);
            out.usize(values.len());
            for &value in values {
                out.check()?;
                out.f64(value);
            }
        }
    }
    out.option_str(axis.nucleus());
    out.option_f64(axis.spectral_width_hz());
    match axis.frequency_evidence() {
        None => out.u8(0),
        Some(value) => {
            out.u8(1);
            out.option_f64(value.observe_frequency_mhz());
            out.option_f64(value.transmitter_offset_hz());
        }
    }
    match axis.chemical_shift_reference() {
        None => out.u8(0),
        Some(value) => {
            out.u8(1);
            out.f64(value.carrier_ppm());
            out.f64(value.reference_frequency_mhz());
            encode_evidence(out, value.evidence())?;
        }
    }
    match axis.group_delay() {
        GroupDelayState::NotApplicable => out.u8(0),
        GroupDelayState::Unknown => out.u8(1),
        GroupDelayState::Pending(value) => {
            out.u8(2);
            out.f64(value.delay_points());
            encode_evidence(out, value.evidence())?;
        }
    }
    out.check()
}

pub(super) fn encode_transform(
    out: &mut Encoder<'_>,
    value: &ResolvedComponentTransform,
) -> Result<(), ExecutionError> {
    let transform = value.transform();
    out.usize(transform.input_lanes());
    for &coefficient in transform.coefficients() {
        out.check()?;
        out.complex(coefficient);
    }
    let modulation = transform.modulation();
    out.usize(modulation.period());
    for &multiplier in modulation.multipliers() {
        out.check()?;
        out.complex(multiplier);
    }
    match modulation.domain() {
        ModulationIndexDomain::AbsoluteGridCoordinate(axis) => {
            out.u8(0);
            out.usize(axis.index());
        }
        ModulationIndexDomain::ObservationOrdinal => out.u8(1),
    }
    out.i64(modulation.origin());
    encode_evidence(out, value.evidence())?;
    out.check()
}

pub(super) fn encode_evidence(
    out: &mut Encoder<'_>,
    value: &NormalizationEvidence,
) -> Result<(), ExecutionError> {
    match value.authority() {
        ResolutionAuthority::FormatRule(id) => {
            out.u8(0);
            out.str(id.as_str());
        }
        ResolutionAuthority::CallerAssertion(id) => {
            out.u8(1);
            out.str(id.as_str());
        }
        ResolutionAuthority::UserConstructed => out.u8(2),
    }
    out.usize(value.facts().len());
    for fact in value.facts() {
        out.check()?;
        match fact {
            NormalizationFact::CanonicalLaneOrder { lanes } => {
                out.u8(0);
                out.usize(lanes.get());
            }
            NormalizationFact::PublicComplexConvention => out.u8(1),
            NormalizationFact::TraceMappingBijection => out.u8(2),
            NormalizationFact::SourceCoefficients { active, values } => {
                out.u8(3);
                out.u8(u8::from(*active));
                out.usize(*values);
            }
            NormalizationFact::PeriodicModulation { period, domain } => {
                out.u8(4);
                out.usize(period.get());
                match domain {
                    ModulationIndexDomain::AbsoluteGridCoordinate(axis) => {
                        out.u8(0);
                        out.usize(axis.index());
                    }
                    ModulationIndexDomain::ObservationOrdinal => out.u8(1),
                }
            }
            NormalizationFact::DirectSampleEncoding => out.u8(5),
            NormalizationFact::UserDefinedComponentTransform => out.u8(6),
            NormalizationFact::UserDefinedCartesianNormalization => out.u8(7),
            NormalizationFact::DigitalFilterDelay => out.u8(8),
            NormalizationFact::ChemicalShiftReference => out.u8(9),
        }
    }
    out.usize(value.derivation().len());
    for step in value.derivation() {
        out.check()?;
        out.str(step.as_str());
    }
    out.check()
}

pub(super) struct Encoder<'a> {
    hash: Sha256,
    cancellation: Option<&'a CancellationToken>,
}
impl<'a> Encoder<'a> {
    #[cfg(test)]
    pub(super) fn new(protocol: &[u8]) -> Self {
        Self::new_checked(protocol, None)
    }
    pub(super) fn new_checked(
        protocol: &[u8],
        cancellation: Option<&'a CancellationToken>,
    ) -> Self {
        let mut value = Self {
            hash: Sha256::new(),
            cancellation,
        };
        value.bytes(protocol);
        value
    }
    pub(super) fn finish(self) -> CanonicalDigest {
        CanonicalDigest::new(self.hash.finalize().into())
    }
    pub(super) fn check(&self) -> Result<(), ExecutionError> {
        self.cancellation.map_or(Ok(()), CancellationToken::check)
    }
    pub(super) fn finish_checked(self) -> Result<CanonicalDigest, ExecutionError> {
        self.check()?;
        Ok(self.finish())
    }
    pub(super) fn bytes(&mut self, value: &[u8]) {
        for chunk in value.chunks(32768) {
            if self.check().is_err() {
                return;
            }
            self.hash.update(chunk);
        }
    }
    pub(super) fn u8(&mut self, value: u8) {
        self.bytes(&[value]);
    }
    pub(super) fn u64(&mut self, value: u64) {
        self.bytes(&value.to_le_bytes());
    }
    pub(super) fn i64(&mut self, value: i64) {
        self.bytes(&value.to_le_bytes());
    }
    pub(super) fn usize(&mut self, value: usize) {
        self.u64(value as u64);
    }
    pub(super) fn f64(&mut self, value: f64) {
        self.u64(value.to_bits());
    }
    pub(super) fn complex(&mut self, value: crate::Complex64) {
        self.f64(value.re);
        self.f64(value.im);
    }
    pub(super) fn str(&mut self, value: &str) {
        self.usize(value.len());
        self.bytes(value.as_bytes());
    }
    pub(super) fn option_str(&mut self, value: Option<&str>) {
        match value {
            None => self.u8(0),
            Some(value) => {
                self.u8(1);
                self.str(value);
            }
        }
    }
    pub(super) fn option_f64(&mut self, value: Option<f64>) {
        match value {
            None => self.u8(0),
            Some(value) => {
                self.u8(1);
                self.f64(value);
            }
        }
    }
    pub(super) fn option_u64(&mut self, value: Option<u64>) {
        match value {
            None => self.u8(0),
            Some(value) => {
                self.u8(1);
                self.u64(value);
            }
        }
    }
    pub(super) fn option_u8(&mut self, value: Option<u8>) {
        match value {
            None => self.u8(0),
            Some(value) => {
                self.u8(1);
                self.u8(value);
            }
        }
    }
}