feature: add attribute to hold data processing method references to DataArray instances.

Author: mobiusklein

src/io/mzml/async_reader.rs

@@ -290,6 +290,9 @@ impl<
         let mut reader = Reader::from_reader(&mut self.handle);
         reader.trim_text(true);
         accumulator.instrument_id_map = Some(&mut self.instrument_id_map);
+        if let Some(val) = self.run.default_data_processing_id.as_ref() {
+            accumulator.set_run_data_processing(Some(val.clone().into()));
+        }
         let mut offset: usize = 0;
         loop {
             let event = reader.read_event_into_async(&mut self.buffer).await;

src/io/mzml/reader.rs

@@ -58,23 +58,46 @@ pub trait SpectrumBuilding<'a, C: CentroidLike, D: DeconvolutedCentroidLike, S:
     fn isolation_window_mut(&mut self) -> &mut IsolationWindow;
     /// Get the last scan window being constructed.
     fn scan_window_mut(&mut self) -> &mut ScanWindow;
+
+    /// Get the current [`SelectedIon`] being built.
     fn selected_ion_mut(&mut self) -> &mut SelectedIon;
+
+    /// Add a new [`SelectedIon`] to the stack for the current [`Precursor`].
+    /// This will be the current [`SelectedIon`].
     fn new_selected_ion(&mut self) -> &mut SelectedIon;
+
+    /// Add a new [`Precursor`] to the stack. This will be the current [`Precursor`].
     fn new_precursor_mut(&mut self) -> &mut Precursor;
+
+    /// Get the current [`Precursor`] being built.
     fn precursor_mut(&mut self) -> &mut Precursor;
+
+    /// Get the current [`DataArray`] being built. This may be an empty instance if
+    /// if there is no array being built currently.
     fn current_array_mut(&mut self) -> &mut DataArray;
+
     /// Move all the data into the provided `spectrum` reference
     fn into_spectrum(self, spectrum: &mut S);
 
+    /// Optionally set the global data processing identifier for the run to be used if
+    /// a data processing reference isn't specified locally.
+    ///
+    /// This is a no-op if not explicitly implemented.
+    fn set_run_data_processing(&mut self, _identifier: Option<Box<str>>) {}
+
+    /// Move all the data into the provided `chromatogram` reference
     fn into_chromatogram(self, chromatogram: &mut Chromatogram);
 
+    /// Put a parameter-like instance into the current top-level instance
     fn fill_spectrum<P: ParamLike + Into<Param> + ParamValue>(&mut self, param: P);
 
+    /// Set the compression method for the current [`DataArray`]
     fn set_current_compressiion(&mut self, compression: BinaryCompressionType) {
         trace!("Setting current compression method for {:?} to {compression:?}", self.current_array_mut().name());
         self.current_array_mut().compression = compression;
     }
 
+    /// Put a parameter-like instance into the current [`DataArray`]
     fn fill_binary_data_array<P: ParamLike + Into<Param> + ParamValue>(&mut self, param: P) {
         if param.is_ms() {
             match param.accession().unwrap() {
@@ -229,6 +252,7 @@ pub trait SpectrumBuilding<'a, C: CentroidLike, D: DeconvolutedCentroidLike, S:
         }
     }
 
+    /// Put a parameter-like instance into the current [`SelectedIon`]
     fn fill_selected_ion(&mut self, param: Param) {
         match param.name.as_ref() {
             "selected ion m/z" => {
@@ -248,6 +272,7 @@ pub trait SpectrumBuilding<'a, C: CentroidLike, D: DeconvolutedCentroidLike, S:
         };
     }
 
+    /// Put a parameter-like instance into the current [`IsolationWindow`]
     fn fill_isolation_window(&mut self, param: Param) {
         let window = self.isolation_window_mut();
         match param.name.as_ref() {
@@ -324,6 +349,7 @@ pub trait SpectrumBuilding<'a, C: CentroidLike, D: DeconvolutedCentroidLike, S:
         }
     }
 
+    /// Put a parameter-like instance into the current [`ScanWindow`]
     fn fill_scan_window(&mut self, param: Param) {
         let window = self.scan_window_mut();
         match param.name.as_ref() {
@@ -355,7 +381,10 @@ macro_rules! xml_error {
 const BUFFER_SIZE: usize = 10000;
 
 /// An accumulator for the attributes of a spectrum as it is read from an
-/// mzML document
+/// mzML document.
+///
+/// While this type is public, it is unnecessary for most users. Instead
+/// just use [`MzMLReaderType::read_next`].
 pub struct MzMLSpectrumBuilder<
     'a,
     C: CentroidLike = CentroidPeak,
@@ -376,6 +405,8 @@ pub struct MzMLSpectrumBuilder<
     pub has_precursor: bool,
     pub detail_level: DetailLevel,
     pub instrument_id_map: Option<&'a mut IncrementingIdMap>,
+    pub run_level_data_processing: Option<Box<str>>,
+    pub spectrum_data_processing_ref: Option<Box<str>>,
     entry_type: EntryType,
     centroid_type: PhantomData<C>,
     deconvoluted_type: PhantomData<D>,
@@ -397,6 +428,8 @@ impl<C: CentroidLike, D: DeconvolutedCentroidLike> Default for MzMLSpectrumBuild
             has_precursor: Default::default(),
             detail_level: Default::default(),
             instrument_id_map: Default::default(),
+            run_level_data_processing: None,
+            spectrum_data_processing_ref: None,
             entry_type: Default::default(),
             centroid_type: PhantomData,
             deconvoluted_type: PhantomData,
@@ -410,6 +443,10 @@ impl<C: CentroidLike, D: DeconvolutedCentroidLike> CVParamParse for MzMLSpectrum
 impl<'inner, C: CentroidLike, D: DeconvolutedCentroidLike>
     SpectrumBuilding<'inner, C, D, MultiLayerSpectrum<C, D>> for MzMLSpectrumBuilder<'inner, C, D>
 {
+    fn set_run_data_processing(&mut self, identifier: Option<Box<str>>) {
+        self.run_level_data_processing = identifier;
+    }
+
     fn isolation_window_mut(&mut self) -> &mut IsolationWindow {
         &mut self.precursor_mut().isolation_window
     }
@@ -542,6 +579,10 @@ impl<
         Self::with_detail_level(DetailLevel::Full)
     }
 
+    pub fn set_run_data_processing(&mut self, identifier: Option<Box<str>>) {
+        self.run_level_data_processing = identifier;
+    }
+
     pub fn with_detail_level(detail_level: DetailLevel) -> MzMLSpectrumBuilder<'inner, C, D> {
         Self {
             detail_level,
@@ -707,6 +748,10 @@ impl<C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFro
                                     .expect("Failed to parse index");
                                 trace!("Stored spectrum index = {}", self.index);
                             }
+                            b"dataProcessingRef" => {
+                                let ident: Box<str> = String::from_utf8_lossy(&attr.value).into();
+                                self.spectrum_data_processing_ref = Some(ident);
+                            }
                             _ => {}
                         },
                         Err(msg) => {
@@ -799,6 +844,38 @@ impl<C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFro
                 return Ok(MzMLParserState::BinaryDataArrayList);
             }
             b"binaryDataArray" => {
+                let mut dp_set = false;
+                for attr_parsed in event.attributes() {
+                    match attr_parsed {
+                        Ok(attr) => {
+                            match attr.key.as_ref() {
+                                b"dataProcessingRef" => {
+                                    match attr.unescape_value() {
+                                        Ok(v) => {
+                                            self.current_array.set_data_processing_reference(Some(v.into()));
+                                            dp_set = true;
+                                            break;
+                                        },
+                                        Err(msg) => return Err(self.handle_xml_error(msg.into(), state))
+                                    }
+                                }
+                                _ => {}
+                            }
+                        },
+                        Err(msg) => {
+                            return Err(self.handle_xml_error(msg.into(), state));
+                        },
+                    }
+                }
+                if !dp_set {
+                    if let Some(dp_ref) = self.spectrum_data_processing_ref.as_ref() {
+                        self.current_array.set_data_processing_reference(Some(dp_ref.clone()));
+                    }
+                    else if let Some(dp_ref) = self.run_level_data_processing.as_ref() {
+                        self.current_array.set_data_processing_reference(Some(dp_ref.clone()));
+                    }
+                }
+
                 return Ok(MzMLParserState::BinaryDataArray);
             }
             b"binary" => {
@@ -1317,6 +1394,7 @@ impl<
         let mut reader = Reader::from_reader(&mut self.handle);
         reader.trim_text(true);
         accumulator = accumulator.borrow_instrument_configuration(&mut self.instrument_id_map);
+        accumulator.set_run_data_processing(self.run.default_data_processing_id.clone().map(|v| v.into_boxed_str()));
         let mut offset: usize = 0;
 
         macro_rules! err_state {

src/io/mzml/writer.rs

@@ -1752,6 +1752,13 @@ where
 
         let encoded_len = encoded_array.len().to_string();
         attrib!("encodedLength", encoded_len, outer);
+        if let Some(dp_id) = array.data_processing_reference() {
+            if let Some(dp_global) = self.run.default_data_processing_id.as_deref() {
+                if dp_id.as_ref() != dp_global {
+                    attrib!("dataProcessingRef", dp_id, outer);
+                }
+            }
+        }
         let array_len = array.data_len()?;
         if array_len != default_array_len {
             let array_len = array_len.to_string();

src/spectrum/bindata/array.rs

@@ -52,6 +52,7 @@ pub struct DataArray {
     pub params: Option<Box<ParamList>>,
     pub unit: Unit,
     item_count: Option<usize>,
+    data_processing_reference: Option<Box<str>>,
 }
 
 impl core::fmt::Debug for DataArray {
@@ -63,6 +64,7 @@ impl core::fmt::Debug for DataArray {
             .field("compression", &self.compression)
             .field("params", &self.params)
             .field("unit", &self.unit)
+            .field("data_processing_ref", &self.data_processing_reference)
             .finish()
     }
 }
@@ -890,6 +892,16 @@ impl<'transient, 'lifespan: 'transient> DataArray {
     pub fn raw_len(&self) -> usize {
         self.data.len()
     }
+
+    /// Get the identifier referencing a [`DataProcessing`](crate::meta::DataProcessing)
+    pub fn data_processing_reference(&self) -> Option<&Box<str>> {
+        self.data_processing_reference.as_ref()
+    }
+
+    /// Set the identifier referencing a [`DataProcessing`](crate::meta::DataProcessing)
+    pub fn set_data_processing_reference(&mut self, data_processing_reference: Option<Box<str>>) {
+        self.data_processing_reference = data_processing_reference;
+    }
 }
 
 impl<'transient, 'lifespan: 'transient> ByteArrayView<'transient, 'lifespan> for DataArray {
@@ -915,6 +927,10 @@ impl<'transient, 'lifespan: 'transient> ByteArrayView<'transient, 'lifespan> for
         self.unit
     }
 
+    fn data_processing_reference(&self) -> Option<&Box<str>> {
+        self.data_processing_reference()
+    }
+
     fn name(&self) -> &ArrayType {
         &self.name
     }
@@ -928,6 +944,10 @@ impl<'transient, 'lifespan: 'transient> ByteArrayViewMut<'transient, 'lifespan>
     fn unit_mut(&mut self) -> &mut Unit {
         &mut self.unit
     }
+
+    fn set_data_processing_reference(&mut self, data_processing_reference: Option<Box<str>>) {
+        self.set_data_processing_reference(data_processing_reference);
+    }
 }
 
 impl_param_described_deferred!(DataArray);
@@ -975,6 +995,10 @@ impl<'transient, 'lifespan: 'transient> ByteArrayView<'transient, 'lifespan>
     fn name(&self) -> &ArrayType {
         self.source.name()
     }
+
+    fn data_processing_reference(&self) -> Option<&Box<str>> {
+        self.source.data_processing_reference()
+    }
 }
 
 #[cfg(test)]

src/spectrum/bindata/traits.rs

@@ -79,6 +79,11 @@ pub trait ByteArrayView<'transient, 'lifespan: 'transient> {
     /// The unit of measurement each data point is in
     fn unit(&self) -> Unit;
 
+    /// Get the identifier referencing a [`DataProcessing`](crate::meta::DataProcessing)
+    fn data_processing_reference(&self) -> Option<&Box<str>> {
+        None
+    }
+
     fn to_f32(&'lifespan self) -> Result<Cow<'transient, [f32]>, ArrayRetrievalError> {
         type D = f32;
         match self.dtype() {
@@ -224,6 +229,10 @@ pub trait ByteArrayViewMut<'transient, 'lifespan: 'transient>:
         let view = self.view_mut()?;
         Self::coerce_from_mut(view)
     }
+
+    #[allow(unused)]
+    /// Set the identifier referencing a [`DataProcessing`](crate::meta::DataProcessing)
+    fn set_data_processing_reference(&mut self, data_processing_reference: Option<Box<str>>) {}
 }
 
 #[derive(Debug)]