ionic-rs 0.2.2

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use std::{borrow::Cow, io::BufRead, str::from_utf8};

use quick_xml::{
    XmlVersion,
    events::{BytesStart, Event},
};

use crate::mzml::{
    schema::TagId,
    structs::{
        CvEntry, CvParam, ReferenceableParamGroupRef, SoftwareParam, SourceFileRef, UserParam,
    },
    utilities::{ParseError, ParsingWorkspace, normalize_tag},
};

#[inline]
pub fn xml_local_name(mut raw: &[u8]) -> &[u8] {
    if raw.first() == Some(&b'{')
        && let Some(end) = raw.iter().position(|&b| b == b'}')
    {
        raw = &raw[end + 1..];
    }
    if let Some(colon) = raw.iter().rposition(|&b| b == b':') {
        &raw[colon + 1..]
    } else {
        raw
    }
}

#[inline]
pub fn tag_id_from_bytes(raw: &[u8]) -> TagId {
    let local = from_utf8(xml_local_name(raw)).unwrap_or("");
    TagId::from_xml_tag(normalize_tag(local))
}

pub fn drain_until_close<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    closing_bytes: &[u8],
) -> Result<(), ParseError> {
    let mut depth = 1usize;
    loop {
        match ws.next_event()? {
            Event::Start(_) => depth += 1,
            Event::End(e) => {
                depth -= 1;
                if depth == 0 && e.name().as_ref() == closing_bytes {
                    break Ok(());
                }
            }
            Event::Eof => break Ok(()),
            _ => {}
        }
    }
}

pub fn read_element_text<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    closing_bytes: &[u8],
) -> Result<String, ParseError> {
    let mut text = String::new();
    loop {
        match ws.next_event()? {
            Event::Text(t) => text.push_str(&t.decode().map_err(quick_xml::Error::from)?),
            Event::CData(t) => text.push_str(&String::from_utf8_lossy(&t.into_inner())),
            Event::End(e) if e.name().as_ref() == closing_bytes => break,
            Event::Eof => break,
            _ => {}
        }
    }
    Ok(text)
}

pub fn read_base64_binary<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    closing_bytes: &[u8],
    out: &mut Vec<u8>,
) -> Result<(), ParseError> {
    out.clear();
    loop {
        match ws.next_event()? {
            Event::Text(t) => out.extend(
                t.as_ref()
                    .iter()
                    .copied()
                    .filter(|b| !b.is_ascii_whitespace()),
            ),
            Event::CData(t) => out.extend(
                t.into_inner()
                    .iter()
                    .copied()
                    .filter(|b| !b.is_ascii_whitespace()),
            ),
            Event::End(e) if e.name().as_ref() == closing_bytes => break,
            Event::Eof => break,
            _ => {}
        }
    }
    Ok(())
}

pub fn attr_any(element: &BytesStart, candidate_names: &[&[u8]]) -> Option<String> {
    for a in element.attributes().with_checks(false).flatten() {
        if candidate_names.iter().any(|n| *n == a.key.as_ref()) {
            return Some(
                a.normalized_value(XmlVersion::Implicit1_0)
                    .ok()?
                    .to_string(),
            );
        }
    }
    None
}

#[inline]
pub fn attr(e: &BytesStart, name: &[u8]) -> Option<String> {
    attr_any(e, &[name])
}

pub fn attr_str<'a>(element: &'a BytesStart, name: &[u8]) -> Option<Cow<'a, str>> {
    for a in element.attributes().with_checks(false).flatten() {
        if a.key.as_ref() == name {
            return a.normalized_value(XmlVersion::Implicit1_0).ok();
        }
    }
    None
}

#[inline]
pub fn attr_u32(e: &BytesStart, name: &[u8]) -> Option<u32> {
    attr_str(e, name).and_then(|s| s.parse().ok())
}
#[inline]
pub fn attr_usize(e: &BytesStart, name: &[u8]) -> Option<usize> {
    attr_str(e, name).and_then(|s| s.parse().ok())
}

pub const PREALLOC_CAP: usize = 1 << 16;

#[inline]
pub fn read_cv_param(e: &BytesStart) -> CvParam {
    CvParam {
        cv_ref: attr_any(e, &[b"cvRef", b"cvLabel"]),
        accession: attr(e, b"accession"),
        name: attr(e, b"name").unwrap_or_default(),
        value: attr(e, b"value"),
        unit_cv_ref: attr_any(e, &[b"unitCvRef", b"unitCvLabel"]),
        unit_name: attr(e, b"unitName"),
        unit_accession: attr(e, b"unitAccession"),
    }
}

#[inline]
pub fn read_user_param(e: &BytesStart) -> UserParam {
    UserParam {
        name: attr(e, b"name").unwrap_or_default(),
        r#type: attr(e, b"type"),
        unit_accession: attr(e, b"unitAccession"),
        unit_cv_ref: attr_any(e, &[b"unitCvRef", b"unitCvLabel"]),
        unit_name: attr(e, b"unitName"),
        value: attr(e, b"value"),
    }
}

#[inline]
pub fn read_software_param(e: &BytesStart) -> SoftwareParam {
    SoftwareParam {
        cv_ref: attr_any(e, &[b"cvRef", b"cvLabel"]),
        accession: attr(e, b"accession").unwrap_or_default(),
        name: attr(e, b"name").unwrap_or_default(),
        version: attr(e, b"version"),
    }
}

#[inline]
pub fn read_ref_group_ref(e: &BytesStart) -> ReferenceableParamGroupRef {
    ReferenceableParamGroupRef {
        r#ref: attr(e, b"ref").unwrap_or_default(),
    }
}
#[inline]
pub fn read_source_file_ref(e: &BytesStart) -> SourceFileRef {
    SourceFileRef {
        r#ref: attr(e, b"ref").unwrap_or_default(),
    }
}
#[inline]
pub fn read_cv_entry(e: &BytesStart) -> CvEntry {
    CvEntry {
        id: attr_any(e, &[b"id", b"cvLabel"]).unwrap_or_default(),
        full_name: attr(e, b"fullName"),
        version: attr(e, b"version"),
        uri: attr(e, b"URI"),
    }
}