ionic-rs 0.2.0

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use std::io::BufRead;

use quick_xml::events::BytesStart;

use crate::mzml::{
    schema::TagId,
    structs::*,
    utilities::{
        PREALLOC_CAP, ParamCollector, ParseError, attr, attr_usize,
        parsing_workspace::ParsingWorkspace, read_cv_param, read_user_param,
    },
};

pub(crate) fn parse_precursor_list<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<PrecursorList, ParseError> {
    let count = attr_usize(start, b"count");
    let mut list = PrecursorList {
        count,
        precursors: Vec::with_capacity(count.unwrap_or(0).min(PREALLOC_CAP)),
        ..Default::default()
    };
    ws.for_each_child(start, |ws, event| {
        let (tag, element, is_open) = event.into_parts();
        match tag {
            TagId::CvParam => {
                list.receive_cv(read_cv_param(&element));
                Ok(true)
            }
            TagId::UserParam => {
                list.receive_user(read_user_param(&element));
                Ok(true)
            }
            TagId::Precursor if is_open => {
                list.precursors.push(parse_precursor(ws, &element)?);
                Ok(true)
            }
            TagId::Precursor => {
                list.precursors.push(Precursor {
                    spectrum_ref: attr(&element, b"spectrumRef"),
                    source_file_ref: attr(&element, b"sourceFileRef"),
                    external_spectrum_id: attr(&element, b"externalSpectrumID"),
                    ..Default::default()
                });
                Ok(true)
            }
            _ => Ok(false),
        }
    })?;
    Ok(list)
}

pub(crate) fn parse_precursor<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<Precursor, ParseError> {
    let mut precursor = Precursor {
        spectrum_ref: attr(start, b"spectrumRef"),
        source_file_ref: attr(start, b"sourceFileRef"),
        external_spectrum_id: attr(start, b"externalSpectrumID"),
        ..Default::default()
    };
    ws.for_each_child(start, |ws, event| {
        let (tag, element, is_open) = event.into_parts();
        match tag {
            TagId::IsolationWindow if is_open => {
                precursor.isolation_window = Some(parse_isolation_window(ws, &element)?);
                Ok(true)
            }
            TagId::SelectedIonList if is_open => {
                precursor.selected_ion_list = Some(parse_selected_ion_list(ws, &element)?);
                Ok(true)
            }
            TagId::Activation if is_open => {
                precursor.activation = Some(parse_activation(ws, &element)?);
                Ok(true)
            }
            TagId::SelectedIon if is_open => {
                push_selected_ion_onto_precursor(ws, &element, &mut precursor)?;
                Ok(true)
            }
            TagId::IsolationWindow => {
                precursor.isolation_window = Some(IsolationWindow::default());
                Ok(true)
            }
            TagId::SelectedIonList => {
                precursor.selected_ion_list = Some(SelectedIonList::default());
                Ok(true)
            }
            TagId::SelectedIon => {
                append_empty_selected_ion(&mut precursor);
                Ok(true)
            }
            _ => Ok(false),
        }
    })?;
    Ok(precursor)
}

pub(crate) fn parse_isolation_window<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<IsolationWindow, ParseError> {
    let mut window = IsolationWindow::default();
    ws.collect_params_into(start, &mut window)?;
    Ok(window)
}

fn parse_selected_ion_list<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<SelectedIonList, ParseError> {
    let mut list = SelectedIonList {
        count: attr_usize(start, b"count"),
        ..Default::default()
    };
    ws.for_each_child(start, |ws, event| {
        let (tag, element, is_open) = event.into_parts();
        if tag != TagId::SelectedIon {
            return Ok(false);
        }
        if is_open {
            list.selected_ions.push(parse_ion_selection(ws, &element)?);
        } else {
            list.selected_ions.push(SelectedIon::default());
        }
        Ok(true)
    })?;
    Ok(list)
}

fn parse_activation<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<Activation, ParseError> {
    let mut activation = Activation::default();
    ws.collect_params_into(start, &mut activation)?;
    Ok(activation)
}

fn parse_ion_selection<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<SelectedIon, ParseError> {
    let mut ion = SelectedIon::default();
    ws.collect_params_into(start, &mut ion)?;
    Ok(ion)
}

fn push_selected_ion_onto_precursor<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    element: &BytesStart<'_>,
    precursor: &mut Precursor,
) -> Result<(), ParseError> {
    let list = precursor
        .selected_ion_list
        .get_or_insert_with(Default::default);
    list.selected_ions.push(parse_ion_selection(ws, element)?);
    list.count = Some(list.selected_ions.len());
    Ok(())
}

fn append_empty_selected_ion(precursor: &mut Precursor) {
    let list = precursor
        .selected_ion_list
        .get_or_insert_with(Default::default);
    list.selected_ions.push(SelectedIon::default());
    list.count = Some(list.selected_ions.len());
}