ionic-rs 0.1.3

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
#[inline]
pub(crate) fn write_u32_le(buf: &mut Vec<u8>, v: u32) {
    buf.extend_from_slice(&v.to_le_bytes());
}

#[inline]
#[cfg(test)]
pub(crate) fn write_u64_le(buf: &mut Vec<u8>, v: u64) {
    buf.extend_from_slice(&v.to_le_bytes());
}

#[inline]
pub(crate) fn write_f32_le(buf: &mut Vec<u8>, v: f32) {
    buf.extend_from_slice(&v.to_le_bytes());
}

#[inline]
pub(crate) fn write_f64_le(buf: &mut Vec<u8>, v: f64) {
    buf.extend_from_slice(&v.to_le_bytes());
}

fn write_u16_le_scalar(buf: &mut Vec<u8>, v: u16) {
    buf.extend_from_slice(&v.to_le_bytes());
}

fn write_i16_le_scalar(buf: &mut Vec<u8>, v: i16) {
    buf.extend_from_slice(&v.to_le_bytes());
}

fn write_i32_le_scalar(buf: &mut Vec<u8>, v: i32) {
    buf.extend_from_slice(&v.to_le_bytes());
}

fn write_i64_le_scalar(buf: &mut Vec<u8>, v: i64) {
    buf.extend_from_slice(&v.to_le_bytes());
}

macro_rules! write_typed_slice_le {
    ($fn_name:ident, $elem_ty:ty, $scalar_writer:ident) => {
        pub(crate) fn $fn_name(buf: &mut Vec<u8>, values: &[$elem_ty]) {
            if cfg!(target_endian = "little") {
                buf.extend_from_slice(bytemuck::cast_slice::<$elem_ty, u8>(values));
            } else {
                for &v in values {
                    $scalar_writer(buf, v);
                }
            }
        }
    };
}

write_typed_slice_le!(write_u16_slice_le, u16, write_u16_le_scalar);
write_typed_slice_le!(write_i16_slice_le, i16, write_i16_le_scalar);
write_typed_slice_le!(write_i32_slice_le, i32, write_i32_le_scalar);
write_typed_slice_le!(write_i64_slice_le, i64, write_i64_le_scalar);
write_typed_slice_le!(write_u32_slice_le, u32, write_u32_le);
write_typed_slice_le!(write_f32_slice_le, f32, write_f32_le);
write_typed_slice_le!(write_f64_slice_le, f64, write_f64_le);

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

    #[test]
    fn write_u32_le_produces_little_endian() {
        let mut buf = Vec::new();
        write_u32_le(&mut buf, 0x04030201);
        assert_eq!(buf, [0x01, 0x02, 0x03, 0x04]);
    }

    #[test]
    fn write_u64_le_produces_little_endian() {
        let mut buf = Vec::new();
        write_u64_le(&mut buf, 0x0807060504030201);
        assert_eq!(buf, [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
    }

    #[test]
    fn write_f32_le_roundtrips() {
        let mut buf = Vec::new();
        write_f32_le(&mut buf, 1.0f32);
        assert_eq!(buf, 1.0f32.to_le_bytes());
    }

    #[test]
    fn write_f64_le_roundtrips() {
        let mut buf = Vec::new();
        write_f64_le(&mut buf, 1.0f64);
        assert_eq!(buf, 1.0f64.to_le_bytes());
    }

    #[test]
    fn write_u32_slice_le_matches_scalar() {
        let values = [1u32, 2, 3];
        let mut via_slice = Vec::new();
        let mut via_scalar = Vec::new();
        write_u32_slice_le(&mut via_slice, &values);
        for &v in &values {
            write_u32_le(&mut via_scalar, v);
        }
        assert_eq!(via_slice, via_scalar);
    }

    #[test]
    fn write_f64_slice_le_matches_scalar() {
        let values = [1.5f64, 2.5, 3.5];
        let mut via_slice = Vec::new();
        let mut via_scalar = Vec::new();
        write_f64_slice_le(&mut via_slice, &values);
        for &v in &values {
            write_f64_le(&mut via_scalar, v);
        }
        assert_eq!(via_slice, via_scalar);
    }

    #[test]
    fn write_i16_slice_le_matches_scalar() {
        let values = [-1i16, 0, 1, 32767];
        let mut via_slice = Vec::new();
        let mut via_scalar = Vec::new();
        write_i16_slice_le(&mut via_slice, &values);
        for &v in &values {
            write_i16_le_scalar(&mut via_scalar, v);
        }
        assert_eq!(via_slice, via_scalar);
    }

    #[test]
    fn write_empty_slice_is_noop() {
        let mut buf = Vec::new();
        write_u32_slice_le(&mut buf, &[]);
        assert!(buf.is_empty());
    }

    #[test]
    fn write_u16_slice_le_correct_byte_count() {
        let mut buf = Vec::new();
        write_u16_slice_le(&mut buf, &[1u16, 2, 3]);
        assert_eq!(buf.len(), 6);
    }

    #[test]
    fn write_i64_slice_le_correct_byte_count() {
        let mut buf = Vec::new();
        write_i64_slice_le(&mut buf, &[1i64, 2]);
        assert_eq!(buf.len(), 16);
    }
}