ionic-rs 0.2.0

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use crate::ion::{IonError, IonResult};

pub const HEADER_SIZE: usize = 1024;
pub const FILE_SIGNATURE: [u8; 8] = *b"IONIC\0\0\0";
pub const FILE_TRAILER: [u8; 8] = *b"\0\0\0CINOI";

pub use crate::ion::version_generated::{
    CURRENT_VERSION, MAX_SUPPORTED_VERSION, MIN_SUPPORTED_VERSION,
};

#[allow(clippy::absurd_extreme_comparisons)]
const _VERSION_POLICY_INVARIANTS: () = {
    assert!(
        MIN_SUPPORTED_VERSION <= CURRENT_VERSION,
        "CURRENT_VERSION must be supported"
    );
    assert!(
        CURRENT_VERSION <= MAX_SUPPORTED_VERSION,
        "CURRENT_VERSION must be supported"
    );
};

#[inline]
pub fn is_supported(version: u16) -> bool {
    (MIN_SUPPORTED_VERSION..=MAX_SUPPORTED_VERSION).contains(&version)
}

#[inline]
pub fn allow_version(version: u16) -> IonResult<()> {
    if is_supported(version) {
        Ok(())
    } else {
        Err(IonError::UnsupportedFormatVersion(version))
    }
}

pub const CODEC_NONE: u8 = 0;
pub const CODEC_ZSTD: u8 = 1;
pub const ZSTD_LEVEL_MIN: u8 = 1;
pub const ZSTD_LEVEL_MAX: u8 = 22;

#[inline]
pub fn allow_compression(codec: u8, level: u8) -> IonResult<()> {
    match codec {
        CODEC_NONE if level == 0 => Ok(()),
        CODEC_ZSTD if (ZSTD_LEVEL_MIN..=ZSTD_LEVEL_MAX).contains(&level) => Ok(()),
        CODEC_NONE | CODEC_ZSTD => Err(IonError::from(format!(
            "compression level {level} does not match codec {codec}"
        ))),
        other => Err(IonError::UnsupportedCodec(other)),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn current_version_is_supported() {
        assert!(is_supported(CURRENT_VERSION));
    }

    #[test]
    fn allow_decision_matches_is_supported_for_every_u16() {
        for version in 0u16..=u16::MAX {
            match allow_version(version) {
                Ok(()) => assert!(
                    is_supported(version),
                    "allow_version accepted {version} but is_supported says no"
                ),
                Err(IonError::UnsupportedFormatVersion(rejected)) => {
                    assert_eq!(rejected, version, "error must carry the rejected version");
                    assert!(
                        !is_supported(version),
                        "allow_version rejected {version} but is_supported says yes"
                    );
                }
                Err(other) => {
                    panic!("allow_version returned wrong error variant for {version}: {other:?}")
                }
            }
        }
    }

    #[test]
    fn signature_and_trailer_are_eight_bytes() {
        assert_eq!(FILE_SIGNATURE.len(), 8);
        assert_eq!(FILE_TRAILER.len(), 8);
    }

    #[test]
    fn allow_compression_accepts_matching_codec_and_level() {
        assert!(allow_compression(CODEC_NONE, 0).is_ok());
        assert!(allow_compression(CODEC_ZSTD, ZSTD_LEVEL_MIN).is_ok());
        assert!(allow_compression(CODEC_ZSTD, ZSTD_LEVEL_MAX).is_ok());
    }

    #[test]
    fn allow_compression_rejects_level_that_does_not_match_codec() {
        assert!(allow_compression(CODEC_NONE, 1).is_err());
        assert!(allow_compression(CODEC_ZSTD, 0).is_err());
        assert!(allow_compression(CODEC_ZSTD, ZSTD_LEVEL_MAX + 1).is_err());
    }

    #[test]
    fn allow_compression_rejects_unknown_codec() {
        match allow_compression(2, 0) {
            Err(IonError::UnsupportedCodec(2)) => {}
            other => panic!("expected UnsupportedCodec(2), got {other:?}"),
        }
    }
}