Skip to main content

ionic/mzml/
stream_reader.rs

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}