use std::io::BufRead;
use quick_xml::events::BytesStart;
use crate::{
accessions::ACC_MS_LEVEL,
mzml::{
schema::TagId,
structs::*,
utilities::{
PREALLOC_CAP, ParamCollector, ParseError, attr, attr_u32, attr_usize, parse_bda,
parse_bda_list, parse_precursor, parse_precursor_list::parse_precursor_list,
parse_product_list::parse_product_list, parse_scan, parse_scan_list,
parsing_workspace::ParsingWorkspace, read_cv_param, read_ref_group_ref,
read_user_param,
},
},
};
pub(crate) fn parse_spectrum_list<R: BufRead>(
ws: &mut ParsingWorkspace<R>,
start: &BytesStart<'_>,
) -> Result<SpectrumList, ParseError> {
let count = attr_usize(start, b"count");
let mut list = SpectrumList {
count,
default_data_processing_ref: attr(start, b"defaultDataProcessingRef"),
spectra: Vec::with_capacity(count.unwrap_or(0).min(PREALLOC_CAP)),
};
ws.for_each_child(start, |ws, event| {
let (tag, element, is_open) = event.into_parts();
if tag != TagId::Spectrum {
return Ok(false);
}
if is_open {
list.spectra.push(parse_spectrum(ws, &element)?);
} else {
list.spectra.push(Spectrum {
id: attr(&element, b"id").unwrap_or_default(),
index: attr_u32(&element, b"index"),
..Default::default()
});
}
Ok(true)
})?;
Ok(list)
}
pub(crate) fn parse_spectrum<R: BufRead>(
ws: &mut ParsingWorkspace<R>,
start: &BytesStart<'_>,
) -> Result<Spectrum, ParseError> {
let mut spectrum = Spectrum {
id: attr(start, b"id").unwrap_or_default(),
index: attr_u32(start, b"index"),
scan_number: attr_u32(start, b"scanNumber"),
ms_level: attr_u32(start, b"msLevel"),
default_array_length: attr_usize(start, b"defaultArrayLength"),
native_id: attr(start, b"nativeID"),
data_processing_ref: attr(start, b"dataProcessingRef"),
source_file_ref: attr(start, b"sourceFileRef"),
spot_id: attr(start, b"spotID"),
..Default::default()
};
ws.for_each_child(start, |ws, event| {
let (tag, element, is_open) = event.into_parts();
match tag {
TagId::CvParam => {
spectrum.receive_cv(read_cv_param(&element));
Ok(true)
}
TagId::UserParam => {
spectrum.receive_user(read_user_param(&element));
Ok(true)
}
TagId::ReferenceableParamGroupRef => {
spectrum.receive_ref_group(read_ref_group_ref(&element));
Ok(true)
}
TagId::SpectrumDescription if is_open => {
let result = parse_spectrum_description(ws, &element)?;
spectrum.merge_description(result);
Ok(true)
}
TagId::ScanList if is_open => {
spectrum.scan_list = Some(parse_scan_list(ws, &element)?);
Ok(true)
}
TagId::PrecursorList if is_open => {
spectrum.precursor_list = Some(parse_precursor_list(ws, &element)?);
Ok(true)
}
TagId::ProductList if is_open => {
spectrum.product_list = Some(parse_product_list(ws, &element)?);
Ok(true)
}
TagId::BinaryDataArrayList if is_open => {
spectrum.binary_data_array_list = Some(parse_bda_list(ws, &element)?);
Ok(true)
}
TagId::BinaryDataArray if is_open => {
spectrum
.binary_data_array_list
.get_or_insert_with(Default::default)
.binary_data_arrays
.push(parse_bda(ws, &element)?);
Ok(true)
}
TagId::Precursor if is_open => {
push_precursor_onto_spectrum(ws, &element, &mut spectrum)?;
Ok(true)
}
TagId::ScanList => {
spectrum.scan_list = Some(ScanList {
count: attr_usize(&element, b"count"),
..Default::default()
});
Ok(true)
}
TagId::PrecursorList => {
spectrum.precursor_list = Some(PrecursorList {
count: attr_usize(&element, b"count"),
..Default::default()
});
Ok(true)
}
TagId::ProductList => {
spectrum.product_list = Some(ProductList {
count: attr_usize(&element, b"count"),
..Default::default()
});
Ok(true)
}
TagId::BinaryDataArrayList => {
spectrum.binary_data_array_list = Some(BinaryDataArrayList {
count: attr_usize(&element, b"count"),
..Default::default()
});
Ok(true)
}
TagId::Precursor => {
append_empty_precursor(&element, &mut spectrum);
Ok(true)
}
_ => Ok(false),
}
})?;
normalize_ms_level(&mut spectrum);
Ok(spectrum)
}
fn has_ms_level_param(spectrum: &Spectrum) -> bool {
let in_spectrum = spectrum
.cv_params
.iter()
.any(|param| param.accession.as_deref() == Some(ACC_MS_LEVEL));
let in_description = spectrum.spectrum_description.as_ref().is_some_and(|desc| {
desc.cv_params
.iter()
.any(|param| param.accession.as_deref() == Some(ACC_MS_LEVEL))
});
in_spectrum || in_description
}
fn normalize_ms_level(spectrum: &mut Spectrum) {
let Some(level) = spectrum.ms_level else {
return;
};
if has_ms_level_param(spectrum) {
return;
}
spectrum.cv_params.push(CvParam {
cv_ref: Some("MS".to_owned()),
accession: Some(ACC_MS_LEVEL.to_owned()),
name: "ms level".to_owned(),
value: Some(level.to_string()),
unit_cv_ref: None,
unit_name: None,
unit_accession: None,
});
}
fn parse_spectrum_description<R: BufRead>(
ws: &mut ParsingWorkspace<R>,
start: &BytesStart<'_>,
) -> Result<SpectrumDescriptionResult, ParseError> {
let mut result = SpectrumDescriptionResult {
description: SpectrumDescription::default(),
scan_list: None,
precursor_list: None,
product_list: None,
ms_level_hint: None,
};
ws.for_each_child(start, |ws, event| {
let (tag, element, is_open) = event.into_parts();
match tag {
TagId::CvParam => {
let cv = read_cv_param(&element);
if result.ms_level_hint.is_none() && cv.accession.as_deref() == Some(ACC_MS_LEVEL) {
result.ms_level_hint = cv
.value
.as_deref()
.and_then(|v: &str| v.parse::<u32>().ok());
}
result.description.receive_cv(cv);
Ok(true)
}
TagId::UserParam => {
result.description.receive_user(read_user_param(&element));
Ok(true)
}
TagId::ReferenceableParamGroupRef => {
result
.description
.receive_ref_group(read_ref_group_ref(&element));
Ok(true)
}
TagId::ScanList if is_open => {
result.scan_list = Some(parse_scan_list(ws, &element)?);
Ok(true)
}
TagId::PrecursorList if is_open => {
result.precursor_list = Some(parse_precursor_list(ws, &element)?);
Ok(true)
}
TagId::ProductList if is_open => {
result.product_list = Some(parse_product_list(ws, &element)?);
Ok(true)
}
TagId::Scan if is_open => {
let list = result.scan_list.get_or_insert_with(Default::default);
list.scans.push(parse_scan(ws, &element)?);
list.count = Some(list.scans.len());
Ok(true)
}
TagId::Scan => {
let list = result.scan_list.get_or_insert_with(Default::default);
list.scans.push(Scan {
instrument_configuration_ref: attr(&element, b"instrumentConfigurationRef")
.or_else(|| attr(&element, b"instrumentRef")),
external_spectrum_id: attr(&element, b"externalSpectrumID"),
..Default::default()
});
list.count = Some(list.scans.len());
Ok(true)
}
_ => Ok(false),
}
})?;
Ok(result)
}
impl Spectrum {
fn merge_description(&mut self, result: SpectrumDescriptionResult) {
self.spectrum_description = Some(result.description);
self.scan_list = self.scan_list.take().or(result.scan_list);
self.precursor_list = self.precursor_list.take().or(result.precursor_list);
self.product_list = self.product_list.take().or(result.product_list);
if self.ms_level.is_none() {
self.ms_level = result.ms_level_hint;
}
}
}
struct SpectrumDescriptionResult {
description: SpectrumDescription,
scan_list: Option<ScanList>,
precursor_list: Option<PrecursorList>,
product_list: Option<ProductList>,
ms_level_hint: Option<u32>,
}
fn push_precursor_onto_spectrum<R: BufRead>(
ws: &mut ParsingWorkspace<R>,
element: &BytesStart<'_>,
spectrum: &mut Spectrum,
) -> Result<(), ParseError> {
let list = spectrum.precursor_list.get_or_insert_with(Default::default);
list.precursors.push(parse_precursor(ws, element)?);
list.count = Some(list.precursors.len());
Ok(())
}
fn append_empty_precursor(element: &BytesStart<'_>, spectrum: &mut Spectrum) {
let list = spectrum.precursor_list.get_or_insert_with(Default::default);
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()
});
list.count = Some(list.precursors.len());
}