ionic-rs 0.2.0

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use super::{Dtype, IonResult, Packing, PackingId, PackingInput};

pub(crate) static RAW: Raw = Raw;
pub(crate) struct Raw;

impl Packing for Raw {
    fn id(&self) -> PackingId {
        PackingId::Raw
    }

    fn supports(&self, _dtype: Dtype) -> bool {
        true
    }

    fn encode(&self, input: PackingInput<'_>, out: &mut Vec<u8>) -> IonResult<()> {
        match input {
            PackingInput::F64(values) => {
                out.extend(values.iter().flat_map(|v| v.to_le_bytes()))
            }
            PackingInput::F32(values) => {
                out.extend(values.iter().flat_map(|v| v.to_le_bytes()))
            }
        }
        Ok(())
    }

    fn decode(&self, input: &[u8], _dtype: Dtype, out: &mut Vec<u8>) -> IonResult<()> {
        out.extend_from_slice(input);
        Ok(())
    }
}

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

    #[test]
    fn encode_writes_f64_le_bytes() {
        let mut out = Vec::new();
        RAW.encode(PackingInput::F64(&[1.0, 2.0]), &mut out)
            .unwrap();
        let mut expected = Vec::new();
        expected.extend_from_slice(&1.0f64.to_le_bytes());
        expected.extend_from_slice(&2.0f64.to_le_bytes());
        assert_eq!(out, expected);
    }

    #[test]
    fn encode_writes_f32_le_bytes() {
        let mut out = Vec::new();
        RAW.encode(PackingInput::F32(&[1.0, 2.0]), &mut out)
            .unwrap();
        let mut expected = Vec::new();
        expected.extend_from_slice(&1.0f32.to_le_bytes());
        expected.extend_from_slice(&2.0f32.to_le_bytes());
        assert_eq!(out, expected);
    }

    #[test]
    fn decode_copies_bytes() {
        let mut out = Vec::new();
        RAW.decode(&[5, 6, 7, 8], Dtype::F64, &mut out).unwrap();
        assert_eq!(out, [5, 6, 7, 8]);
    }

    #[test]
    fn decode_empty_input_produces_no_output() {
        let mut out = Vec::new();
        RAW.decode(&[], Dtype::F64, &mut out).unwrap();
        assert!(out.is_empty());
    }

    #[test]
    fn f64_roundtrip() {
        let input = [1.5f64, -2.25, 3.0];
        let mut enc = Vec::new();
        RAW.encode(PackingInput::F64(&input), &mut enc).unwrap();
        let mut dec = Vec::new();
        RAW.decode(&enc, Dtype::F64, &mut dec).unwrap();
        let got: Vec<f64> = dec
            .as_chunks::<8>()
            .0
            .iter()
            .map(|c| f64::from_le_bytes(*c))
            .collect();
        assert_eq!(got, input);
    }
}