ionic-rs 0.2.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::{
        PREALLOC_CAP, ParamCollector, ParseError, attr, attr_usize,
        parsing_workspace::ParsingWorkspace, read_cv_param, read_ref_group_ref, read_user_param,
    },
};

pub(crate) fn parse_scan_list<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<ScanList, ParseError> {
    let count = attr_usize(start, b"count");
    let mut scan_list = ScanList {
        count,
        scans: 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 => {
                scan_list.receive_cv(read_cv_param(&element));
                Ok(true)
            }
            TagId::UserParam => {
                scan_list.receive_user(read_user_param(&element));
                Ok(true)
            }
            TagId::ReferenceableParamGroupRef => {
                scan_list.receive_ref_group(read_ref_group_ref(&element));
                Ok(true)
            }
            TagId::Scan => {
                if is_open {
                    scan_list.scans.push(parse_scan(ws, &element)?);
                } else {
                    scan_list.scans.push(Scan {
                        instrument_configuration_ref: attr(&element, b"instrumentConfigurationRef")
                            .or_else(|| attr(&element, b"instrumentRef")),
                        external_spectrum_id: attr(&element, b"externalSpectrumID"),
                        source_file_ref: attr(&element, b"sourceFileRef"),
                        spectrum_ref: attr(&element, b"spectrumRef"),
                        ..Default::default()
                    });
                }
                Ok(true)
            }
            _ => Ok(false),
        }
    })?;

    Ok(scan_list)
}

pub(crate) fn parse_scan<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<Scan, ParseError> {
    let mut scan = Scan {
        instrument_configuration_ref: attr(start, b"instrumentConfigurationRef")
            .or_else(|| attr(start, b"instrumentRef")),
        external_spectrum_id: attr(start, b"externalSpectrumID"),
        source_file_ref: attr(start, b"sourceFileRef"),
        spectrum_ref: attr(start, b"spectrumRef"),
        ..Default::default()
    };
    ws.for_each_child(start, |ws, event| {
        let (tag, element, is_open) = event.into_parts();
        match tag {
            TagId::CvParam => {
                scan.receive_cv(read_cv_param(&element));
                Ok(true)
            }
            TagId::UserParam => {
                scan.receive_user(read_user_param(&element));
                Ok(true)
            }
            TagId::ReferenceableParamGroupRef => {
                scan.receive_ref_group(read_ref_group_ref(&element));
                Ok(true)
            }
            TagId::ScanWindowList if is_open => {
                scan.scan_window_list = Some(parse_scan_window_list(ws, &element)?);
                Ok(true)
            }
            _ => Ok(false),
        }
    })?;
    Ok(scan)
}

fn parse_scan_window_list<R: BufRead>(
    ws: &mut ParsingWorkspace<R>,
    start: &BytesStart<'_>,
) -> Result<ScanWindowList, ParseError> {
    let mut list = ScanWindowList {
        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::ScanWindow {
            return Ok(false);
        }
        if is_open {
            list.scan_windows.push(parse_scan_window(ws, &element)?);
        } else {
            list.scan_windows.push(ScanWindow::default());
        }
        Ok(true)
    })?;
    Ok(list)
}

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