ionic-rs 0.1.2

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::{ParseError, attr, attr_u32, attr_usize, parsing_workspace::ParsingWorkspace},
};

pub(crate) fn parse_data_processing_list<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<DataProcessingList, ParseError> {
    let mut list = DataProcessingList {
        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::DataProcessing {
            return Ok(false);
        }
        if is_open {
            list.data_processing
                .push(parse_data_processing(ws, &element)?);
        } else {
            list.data_processing.push(DataProcessing {
                id: attr(&element, b"id").unwrap_or_default(),
                ..Default::default()
            });
        }
        Ok(true)
    })?;
    Ok(list)
}

fn parse_data_processing<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<DataProcessing, ParseError> {
    let mut dp = DataProcessing {
        id: attr(start, b"id").unwrap_or_default(),
        software_ref: attr(start, b"softwareRef"),
        ..Default::default()
    };
    ws.for_each_child(start, |ws, event| {
        let (tag, element, is_open) = event.into_parts();
        if tag != TagId::ProcessingMethod {
            return Ok(false);
        }
        if is_open {
            dp.processing_method
                .push(parse_processing_method(ws, &element)?);
        } else {
            dp.processing_method.push(ProcessingMethod {
                order: attr_u32(&element, b"order"),
                software_ref: attr(&element, b"softwareRef"),
                ..Default::default()
            });
        }
        Ok(true)
    })?;
    Ok(dp)
}

fn parse_processing_method<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<ProcessingMethod, ParseError> {
    let mut pm = ProcessingMethod {
        order: attr_u32(start, b"order"),
        software_ref: attr(start, b"softwareRef"),
        ..Default::default()
    };
    ws.collect_params_into(start, &mut pm)?;
    Ok(pm)
}