1#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
2use std::{
3 fs::File,
4 io::BufReader,
5 path::{Path, PathBuf},
6};
7
8#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
9use quick_xml::{
10 Reader,
11 events::{BytesStart, Event},
12};
13
14#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
15use crate::{
16 ion::IonError,
17 mzml::{
18 schema::TagId,
19 structs::{
20 ChromatogramList, DataProcessingList, InstrumentList, ReferenceableParamGroupList, Run,
21 SampleList, ScanSettingsList, SoftwareList, SourceFileRefList, SpectrumList,
22 },
23 utilities::{
24 ParamCollector, ParseError, ParsingWorkspace, attr, attr_u32, attr_usize,
25 drain_until_close, finalize_bda, parse_chromatogram_list::parse_chromatogram,
26 parse_cv_list, parse_data_processing_list, parse_file_description,
27 parse_instrument_list, parse_ref_param_group_list, parse_sample_list,
28 parse_scan_settings_list, parse_software_list, parse_source_file_ref_list,
29 parse_spectrum_list::parse_spectrum, read_cv_param, read_ref_group_ref,
30 read_user_param, tag_id_from_bytes,
31 },
32 },
33};
34use crate::{
35 ion::{
36 IonResult,
37 encoder::scan_stream::{MemoryReader, ScanStream},
38 },
39 mzml::structs::{Chromatogram, MzML, Spectrum},
40};
41
42pub struct MzmlReader {
43 kind: ReaderKind,
44}
45
46enum ReaderKind {
47 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
48 File(StreamReader),
49 Memory(MemoryReader),
50}
51
52#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
53struct StreamReader {
54 workspace: ParsingWorkspace<BufReader<File>>,
55 path: PathBuf,
56 metadata: MzML,
57 state: ReaderState,
58}
59
60#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
61#[derive(Clone, Copy, PartialEq, Eq)]
62enum ReaderState {
63 NeedMetadata,
64 SpectrumList,
65 NeedChromatograms,
66 ChromatogramList,
67 NeedRunEnd,
68 NeedMzmlEnd,
69 Done,
70}
71
72impl MzmlReader {
73 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
74 pub fn open(path: &Path) -> IonResult<Self> {
75 let file = File::open(path).map_err(|err| {
76 IonError::from(format!("cannot open mzML file '{}': {err}", path.display()))
77 })?;
78 let reader = Reader::from_reader(BufReader::new(file));
79 Ok(Self {
80 kind: ReaderKind::File(StreamReader {
81 workspace: ParsingWorkspace::new(reader),
82 path: path.to_path_buf(),
83 metadata: MzML::default(),
84 state: ReaderState::NeedMetadata,
85 }),
86 })
87 }
88
89 pub fn from_mzml(mzml: MzML) -> Self {
90 Self {
91 kind: ReaderKind::Memory(MemoryReader::new(mzml)),
92 }
93 }
94
95 #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
96 pub fn open(_path: &std::path::Path) -> IonResult<Self> {
97 Err("MzmlReader::open is not available in browser wasm".into())
98 }
99}
100
101impl ScanStream for MzmlReader {
102 fn metadata(&mut self) -> IonResult<MzML> {
103 match &mut self.kind {
104 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
105 ReaderKind::File(reader) => reader.metadata(),
106 ReaderKind::Memory(reader) => reader.metadata(),
107 }
108 }
109
110 fn next_spectrum(&mut self) -> IonResult<Option<Spectrum>> {
111 match &mut self.kind {
112 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
113 ReaderKind::File(reader) => reader.next_spectrum(),
114 ReaderKind::Memory(reader) => reader.next_spectrum(),
115 }
116 }
117
118 fn next_chromatogram(&mut self) -> IonResult<Option<Chromatogram>> {
119 match &mut self.kind {
120 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
121 ReaderKind::File(reader) => reader.next_chromatogram(),
122 ReaderKind::Memory(reader) => reader.next_chromatogram(),
123 }
124 }
125}
126
127#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
128impl StreamReader {
129 fn metadata(&mut self) -> IonResult<MzML> {
130 match self.state {
131 ReaderState::NeedMetadata => self.read_metadata()?,
132 ReaderState::NeedChromatograms => self.read_to_chromatograms()?,
133 ReaderState::NeedRunEnd | ReaderState::NeedMzmlEnd => self.read_to_end()?,
134 _ => {}
135 }
136 Ok(self.metadata.clone())
137 }
138
139 fn next_spectrum(&mut self) -> IonResult<Option<Spectrum>> {
140 if self.state == ReaderState::NeedMetadata {
141 self.metadata()?;
142 }
143 if self.state != ReaderState::SpectrumList {
144 return Ok(None);
145 }
146 loop {
147 match self.next_event()? {
148 Event::Start(element) => match tag_id_from_bytes(element.name().as_ref()) {
149 TagId::Spectrum => {
150 let mut spectrum = parse_or_error(
151 &self.path,
152 parse_spectrum(&mut self.workspace, &element),
153 )?;
154 finish_spectrum_arrays(&mut spectrum).map_err(|err| self.error(err))?;
155 return Ok(Some(spectrum));
156 }
157 _ => drain_until_close(&mut self.workspace, element.name().as_ref())
158 .map_err(|err| self.error(err))?,
159 },
160 Event::Empty(element) => {
161 if tag_id_from_bytes(element.name().as_ref()) == TagId::Spectrum {
162 return Ok(Some(Spectrum {
163 id: attr(&element, b"id").unwrap_or_default(),
164 index: attr_u32(&element, b"index"),
165 ..Default::default()
166 }));
167 }
168 }
169 Event::End(element)
170 if tag_id_from_bytes(element.name().as_ref()) == TagId::SpectrumList =>
171 {
172 self.state = ReaderState::NeedChromatograms;
173 return Ok(None);
174 }
175 Event::Eof => return Err(self.unexpected_end("spectrumList")),
176 _ => {}
177 }
178 }
179 }
180
181 fn next_chromatogram(&mut self) -> IonResult<Option<Chromatogram>> {
182 if self.state == ReaderState::NeedMetadata || self.state == ReaderState::NeedChromatograms {
183 self.metadata()?;
184 }
185 if self.state != ReaderState::ChromatogramList {
186 return Ok(None);
187 }
188 loop {
189 match self.next_event()? {
190 Event::Start(element) => match tag_id_from_bytes(element.name().as_ref()) {
191 TagId::Chromatogram => {
192 let mut chromatogram = parse_or_error(
193 &self.path,
194 parse_chromatogram(&mut self.workspace, &element),
195 )?;
196 finish_chromatogram_arrays(&mut chromatogram)
197 .map_err(|err| self.error(err))?;
198 return Ok(Some(chromatogram));
199 }
200 _ => drain_until_close(&mut self.workspace, element.name().as_ref())
201 .map_err(|err| self.error(err))?,
202 },
203 Event::Empty(element) => {
204 if tag_id_from_bytes(element.name().as_ref()) == TagId::Chromatogram {
205 return Ok(Some(Chromatogram {
206 id: attr(&element, b"id").unwrap_or_default(),
207 index: attr_u32(&element, b"index"),
208 ..Default::default()
209 }));
210 }
211 }
212 Event::End(element)
213 if tag_id_from_bytes(element.name().as_ref()) == TagId::ChromatogramList =>
214 {
215 self.state = ReaderState::NeedRunEnd;
216 return Ok(None);
217 }
218 Event::Eof => return Err(self.unexpected_end("chromatogramList")),
219 _ => {}
220 }
221 }
222 }
223
224 fn read_metadata(&mut self) -> IonResult<()> {
225 let mut inside_mzml = false;
226 loop {
227 match self.next_event()? {
228 Event::Start(element) => {
229 let tag = tag_id_from_bytes(element.name().as_ref());
230 if !inside_mzml {
231 if tag == TagId::MzML {
232 inside_mzml = true;
233 }
234 continue;
235 }
236 match tag {
237 TagId::CvList => {
238 self.metadata.cv_list = Some(parse_or_error(
239 &self.path,
240 parse_cv_list(&mut self.workspace, &element),
241 )?);
242 }
243 TagId::FileDescription => {
244 self.metadata.file_description = Some(parse_or_error(
245 &self.path,
246 parse_file_description(&mut self.workspace, &element),
247 )?);
248 }
249 TagId::ReferenceableParamGroupList => {
250 self.metadata.referenceable_param_group_list = Some(parse_or_error(
251 &self.path,
252 parse_ref_param_group_list(&mut self.workspace, &element),
253 )?);
254 }
255 TagId::SampleList => {
256 self.metadata.sample_list = Some(parse_or_error(
257 &self.path,
258 parse_sample_list(&mut self.workspace, &element),
259 )?);
260 }
261 TagId::InstrumentConfigurationList => {
262 self.metadata.instrument_list = parse_or_error(
263 &self.path,
264 parse_instrument_list(&mut self.workspace, &element),
265 )?;
266 }
267 TagId::SoftwareList => {
268 self.metadata.software_list = Some(parse_or_error(
269 &self.path,
270 parse_software_list(&mut self.workspace, &element),
271 )?);
272 }
273 TagId::DataProcessingList => {
274 self.metadata.data_processing_list = Some(parse_or_error(
275 &self.path,
276 parse_data_processing_list(&mut self.workspace, &element),
277 )?);
278 }
279 TagId::ScanSettingsList | TagId::AcquisitionSettingsList => {
280 self.metadata.scan_settings_list = parse_or_error(
281 &self.path,
282 parse_scan_settings_list(&mut self.workspace, &element),
283 )?;
284 }
285 TagId::Run => {
286 self.read_run(&element)?;
287 return Ok(());
288 }
289 _ => drain_until_close(&mut self.workspace, element.name().as_ref())
290 .map_err(|err| self.error(err))?,
291 }
292 }
293 Event::Empty(element) => {
294 if inside_mzml {
295 self.read_empty_metadata(&element);
296 }
297 }
298 Event::End(element)
299 if tag_id_from_bytes(element.name().as_ref()) == TagId::MzML =>
300 {
301 self.state = ReaderState::Done;
302 return Ok(());
303 }
304 Event::Eof => {
305 if inside_mzml {
306 return Err(self.unexpected_end("mzML"));
307 }
308 self.state = ReaderState::Done;
309 return Ok(());
310 }
311 _ => {}
312 }
313 }
314 }
315
316 fn read_empty_metadata(&mut self, element: &BytesStart<'_>) {
317 match tag_id_from_bytes(element.name().as_ref()) {
318 TagId::ReferenceableParamGroupList => {
319 self.metadata.referenceable_param_group_list = Some(ReferenceableParamGroupList {
320 count: attr_usize(element, b"count"),
321 ..Default::default()
322 });
323 }
324 TagId::SampleList => {
325 self.metadata.sample_list = Some(SampleList {
326 count: attr_u32(element, b"count"),
327 ..Default::default()
328 });
329 }
330 TagId::InstrumentConfigurationList => {
331 self.metadata.instrument_list = Some(InstrumentList {
332 count: attr_usize(element, b"count"),
333 ..Default::default()
334 });
335 }
336 TagId::SoftwareList => {
337 self.metadata.software_list = Some(SoftwareList {
338 count: attr_usize(element, b"count"),
339 ..Default::default()
340 });
341 }
342 TagId::DataProcessingList => {
343 self.metadata.data_processing_list = Some(DataProcessingList {
344 count: attr_usize(element, b"count"),
345 ..Default::default()
346 });
347 }
348 TagId::ScanSettingsList | TagId::AcquisitionSettingsList => {
349 self.metadata.scan_settings_list = Some(ScanSettingsList {
350 count: attr_usize(element, b"count"),
351 ..Default::default()
352 });
353 }
354 _ => {}
355 }
356 }
357
358 fn read_run(&mut self, start: &BytesStart<'_>) -> IonResult<()> {
359 self.metadata.run = Run {
360 id: attr(start, b"id").unwrap_or_default(),
361 start_time_stamp: attr(start, b"startTimeStamp"),
362 default_instrument_configuration_ref: attr(start, b"defaultInstrumentConfigurationRef")
363 .or_else(|| attr(start, b"instrumentRef")),
364 default_source_file_ref: attr(start, b"defaultSourceFileRef"),
365 sample_ref: attr(start, b"sampleRef"),
366 ..Default::default()
367 };
368 self.read_run_body()
369 }
370
371 fn read_run_body(&mut self) -> IonResult<()> {
372 loop {
373 match self.next_event()? {
374 Event::Start(element) => match tag_id_from_bytes(element.name().as_ref()) {
375 TagId::CvParam => self.read_run_param(&element, RunParam::Cv)?,
376 TagId::UserParam => self.read_run_param(&element, RunParam::User)?,
377 TagId::ReferenceableParamGroupRef => {
378 self.read_run_param(&element, RunParam::Reference)?;
379 }
380 TagId::SourceFileRefList => {
381 self.metadata.run.source_file_ref_list = Some(parse_or_error(
382 &self.path,
383 parse_source_file_ref_list(&mut self.workspace, &element),
384 )?);
385 }
386 TagId::SpectrumList => {
387 self.metadata.run.spectrum_list = Some(get_spectrum_list(&element));
388 self.state = ReaderState::SpectrumList;
389 return Ok(());
390 }
391 TagId::ChromatogramList => {
392 self.metadata.run.chromatogram_list = Some(get_chromatogram_list(&element));
393 self.state = ReaderState::ChromatogramList;
394 return Ok(());
395 }
396 _ => drain_until_close(&mut self.workspace, element.name().as_ref())
397 .map_err(|err| self.error(err))?,
398 },
399 Event::Empty(element) => match tag_id_from_bytes(element.name().as_ref()) {
400 TagId::CvParam => self.metadata.run.receive_cv(read_cv_param(&element)),
401 TagId::UserParam => self.metadata.run.receive_user(read_user_param(&element)),
402 TagId::ReferenceableParamGroupRef => self
403 .metadata
404 .run
405 .receive_ref_group(read_ref_group_ref(&element)),
406 TagId::SourceFileRefList => {
407 self.metadata.run.source_file_ref_list = Some(SourceFileRefList {
408 count: attr_usize(&element, b"count"),
409 ..Default::default()
410 });
411 }
412 TagId::SpectrumList => {
413 self.metadata.run.spectrum_list = Some(get_spectrum_list(&element));
414 self.state = ReaderState::NeedChromatograms;
415 return Ok(());
416 }
417 TagId::ChromatogramList => {
418 self.metadata.run.chromatogram_list = Some(get_chromatogram_list(&element));
419 self.state = ReaderState::NeedRunEnd;
420 return Ok(());
421 }
422 _ => {}
423 },
424 Event::End(element) if tag_id_from_bytes(element.name().as_ref()) == TagId::Run => {
425 self.state = ReaderState::NeedMzmlEnd;
426 return Ok(());
427 }
428 Event::Eof => return Err(self.unexpected_end("run")),
429 _ => {}
430 }
431 }
432 }
433
434 fn read_to_chromatograms(&mut self) -> IonResult<()> {
435 loop {
436 match self.next_event()? {
437 Event::Start(element) => match tag_id_from_bytes(element.name().as_ref()) {
438 TagId::ChromatogramList => {
439 self.metadata.run.chromatogram_list = Some(get_chromatogram_list(&element));
440 self.state = ReaderState::ChromatogramList;
441 return Ok(());
442 }
443 _ => drain_until_close(&mut self.workspace, element.name().as_ref())
444 .map_err(|err| self.error(err))?,
445 },
446 Event::Empty(element) => {
447 if tag_id_from_bytes(element.name().as_ref()) == TagId::ChromatogramList {
448 self.metadata.run.chromatogram_list = Some(get_chromatogram_list(&element));
449 self.state = ReaderState::NeedRunEnd;
450 return Ok(());
451 }
452 }
453 Event::End(element) if tag_id_from_bytes(element.name().as_ref()) == TagId::Run => {
454 self.state = ReaderState::NeedMzmlEnd;
455 return Ok(());
456 }
457 Event::Eof => return Err(self.unexpected_end("run")),
458 _ => {}
459 }
460 }
461 }
462
463 fn read_to_end(&mut self) -> IonResult<()> {
464 if self.state == ReaderState::NeedRunEnd {
465 loop {
466 match self.next_event()? {
467 Event::End(element)
468 if tag_id_from_bytes(element.name().as_ref()) == TagId::Run =>
469 {
470 self.state = ReaderState::NeedMzmlEnd;
471 break;
472 }
473 Event::Start(element) => {
474 drain_until_close(&mut self.workspace, element.name().as_ref())
475 .map_err(|err| self.error(err))?
476 }
477 Event::Eof => return Err(self.unexpected_end("run")),
478 _ => {}
479 }
480 }
481 }
482 if self.state == ReaderState::NeedMzmlEnd {
483 loop {
484 match self.next_event()? {
485 Event::End(element)
486 if tag_id_from_bytes(element.name().as_ref()) == TagId::MzML =>
487 {
488 self.state = ReaderState::Done;
489 return Ok(());
490 }
491 Event::Start(element) => {
492 drain_until_close(&mut self.workspace, element.name().as_ref())
493 .map_err(|err| self.error(err))?
494 }
495 Event::Eof => return Err(self.unexpected_end("mzML")),
496 _ => {}
497 }
498 }
499 }
500 Ok(())
501 }
502
503 fn read_run_param(&mut self, element: &BytesStart<'_>, param: RunParam) -> IonResult<()> {
504 match param {
505 RunParam::Cv => self.metadata.run.receive_cv(read_cv_param(element)),
506 RunParam::User => self.metadata.run.receive_user(read_user_param(element)),
507 RunParam::Reference => self
508 .metadata
509 .run
510 .receive_ref_group(read_ref_group_ref(element)),
511 }
512 drain_until_close(&mut self.workspace, element.name().as_ref())
513 .map_err(|err| self.error(err))
514 }
515
516 fn next_event(&mut self) -> IonResult<Event<'static>> {
517 self.workspace.next_event().map_err(|err| self.error(err))
518 }
519
520 fn error(&self, error: ParseError) -> IonError {
521 IonError::from(format!(
522 "cannot parse mzML file '{}': {error}",
523 self.path.display()
524 ))
525 }
526
527 fn unexpected_end(&self, context: &str) -> IonError {
528 IonError::from(format!(
529 "cannot parse mzML file '{}': unexpected end of file in {context}",
530 self.path.display()
531 ))
532 }
533}
534
535#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
536enum RunParam {
537 Cv,
538 User,
539 Reference,
540}
541
542#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
543fn get_spectrum_list(element: &BytesStart<'_>) -> SpectrumList {
544 SpectrumList {
545 count: attr_usize(element, b"count"),
546 default_data_processing_ref: attr(element, b"defaultDataProcessingRef"),
547 ..Default::default()
548 }
549}
550
551#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
552fn get_chromatogram_list(element: &BytesStart<'_>) -> ChromatogramList {
553 ChromatogramList {
554 count: attr_usize(element, b"count"),
555 default_data_processing_ref: attr(element, b"defaultDataProcessingRef"),
556 ..Default::default()
557 }
558}
559
560#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
561fn parse_or_error<T>(path: &Path, result: Result<T, ParseError>) -> IonResult<T> {
562 result.map_err(|error| {
563 IonError::from(format!(
564 "cannot parse mzML file '{}': {error}",
565 path.display()
566 ))
567 })
568}
569
570#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
571fn finish_spectrum_arrays(spectrum: &mut Spectrum) -> Result<(), ParseError> {
572 if let Some(list) = spectrum.binary_data_array_list.as_mut() {
573 for array in &mut list.binary_data_arrays {
574 finalize_bda(array, spectrum.default_array_length)?;
575 }
576 }
577 Ok(())
578}
579
580#[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
581fn finish_chromatogram_arrays(chromatogram: &mut Chromatogram) -> Result<(), ParseError> {
582 if let Some(list) = chromatogram.binary_data_array_list.as_mut() {
583 for array in &mut list.binary_data_arrays {
584 finalize_bda(array, chromatogram.default_array_length)?;
585 }
586 }
587 Ok(())
588}