Struct mzdata::io::mzml::MzMLWriterType

pub struct MzMLWriterType<W: Write, C: CentroidLike + Default + BuildArrayMapFrom + 'static = CentroidPeak, D: DeconvolutedCentroidLike + Default + BuildArrayMapFrom + 'static = DeconvolutedPeak> {

    pub offset: usize,
    pub spectrum_count: u64,
    pub spectrum_counter: u64,
    pub chromatogram_count: u64,
    pub chromatogram_counter: u64,
    pub data_array_compression: BinaryCompressionType,
    pub file_description: FileDescription,
    pub softwares: Vec<Software>,
    pub data_processings: Vec<DataProcessing>,
    pub instrument_configurations: HashMap<u32, InstrumentConfiguration>,
    pub state: MzMLWriterState,
    pub write_index: bool,
    pub spectrum_offset_index: OffsetIndex,
    pub chromatogram_offset_index: OffsetIndex,
    pub tic_collector: ChromatogramCollector,
    pub bic_collector: ChromatogramCollector,
    pub wrote_summaries: bool,
    pub run: MassSpectrometryRun,
    /* private fields */
}

An indexed mzML writer that writes MultiLayerSpectrum.

Does not buffer spectra in-memory, writing them out immediately but summary chromatogram information is accumulated.

Fields

offset: usize

The current offset from the stream start

spectrum_count: u64

The total number of spectra this mzML document will contain. This value will appear in the spectrumList element’s count attribute

spectrum_counter: u64

The number of spectrum elements written so far.

chromatogram_count: u64

The total number of chromatograms this mzML document will contain. This value will appear in the chromatogramList element’s count attribute

chromatogram_counter: u64

The number of chromatograms written so far

data_array_compression: BinaryCompressionType

The compression type to use when generating binary data arrays.

file_description: FileDescription

The file-level metadata describing the provenance of the original data

softwares: Vec<Software>

The list of software components that were used to process the data into its current state

data_processings: Vec<DataProcessing>

The types of data transformations applied to (parts of) the data

instrument_configurations: HashMap<u32, InstrumentConfiguration>

The different instrument configurations that were in use during the data acquisition.

state: MzMLWriterState

write_index: bool

spectrum_offset_index: OffsetIndex

chromatogram_offset_index: OffsetIndex

tic_collector: ChromatogramCollector

bic_collector: ChromatogramCollector

wrote_summaries: bool

run: MassSpectrometryRun

Implementations

impl<W: Write, C, D> MzMLWriterType<W, C, D>

where C: BuildArrayMapFrom + CentroidLike + Default, D: BuildArrayMapFrom + DeconvolutedCentroidLike + Default,

pub const fn get_indent_size() -> u64

pub fn new_with_index_and_compression( file: W, write_index: bool, data_array_compression: BinaryCompressionType ) -> MzMLWriterType<W, C, D>

pub fn new_with_index(file: W, write_index: bool) -> MzMLWriterType<W, C, D>

pub fn new(file: W) -> MzMLWriterType<W, C, D>

Wrap a new std::io::Write-able type, constructing a new MzMLWriterType

pub fn stream_position(&mut self) -> Result<u64>

Imitate the io::Seek method using an internal byte counter

pub fn start_spectrum_list(&mut self) -> Result<(), MzMLWriterError>

pub fn write_summary_chromatograms(&mut self) -> Result<(), MzMLWriterError>

pub fn start_chromatogram_list(&mut self) -> Result<(), MzMLWriterError>

pub fn close(&mut self) -> Result<(), MzMLWriterError>

Close the wrapping <indexedmzML> document, which will trigger writing out the offset indices and file checksum at the tail of the document.

pub fn write_scan_list( &mut self, acq: &Acquisition ) -> Result<(), MzMLWriterError>

pub fn write_isolation_window( &mut self, iw: &IsolationWindow ) -> Result<(), MzMLWriterError>

pub fn write_selected_ions( &mut self, precursor: &Precursor ) -> Result<(), MzMLWriterError>

pub fn write_activation( &mut self, precursor: &Precursor ) -> Result<(), MzMLWriterError>

pub fn write_precursor( &mut self, precursor: &Precursor ) -> Result<(), MzMLWriterError>

pub fn write_binary_data_array_pre_encoded( &mut self, array: &DataArray, default_array_len: usize, encoded_array: &[u8] ) -> Result<(), MzMLWriterError>

pub fn write_binary_data_array( &mut self, array: &DataArray, default_array_len: usize ) -> Result<(), MzMLWriterError>

pub fn write_binary_data_arrays( &mut self, arrays: &BinaryArrayMap, default_array_len: usize ) -> Result<(), MzMLWriterError>

pub fn start_spectrum<S: SpectrumLike<C, D> + 'static>( &mut self, spectrum: &S, outer: &mut BytesStart<'_> ) -> Result<usize, MzMLWriterError>

pub fn write_spectrum_descriptors<S: SpectrumLike<C, D> + 'static>( &mut self, spectrum: &S ) -> Result<(), MzMLWriterError>

pub fn write_spectrum<S: SpectrumLike<C, D> + 'static>( &mut self, spectrum: &S ) -> Result<(), MzMLWriterError>

Write a spectrum out to the mzML file, encoding the highest procressing degree peak data present.

Side-Effects

If the writer has not already started writing the spectra, this will cause all the metadata to be written out and the <spectrumList> element will be opened, preventing no new metadata from being written to this stream. Furthermore, this writes the spectrum count out, so the value may no longer be changed.

pub fn start_chromatogram( &mut self, chromatogram: &Chromatogram, outer: &mut BytesStart<'_> ) -> Result<usize, MzMLWriterError>

pub fn write_chromatogram( &mut self, chromatogram: &Chromatogram ) -> Result<(), MzMLWriterError>

pub fn spectrum_count(&self) -> &u64

Get a reference to the mzML writer’s spectrum count.

pub fn set_spectrum_count(&mut self, spectrum_count: u64)

Set the mzML writer’s spectrum count.

pub fn spectrum_count_mut(&mut self) -> &mut u64

Get a mutable reference to the mzML writer’s spectrum count to modify in-place.

pub fn get_mut(&mut self) -> Result<&mut W>

pub fn write_event(&mut self, event: Event<'_>) -> Result<(), MzMLWriterError>

pub fn write_param<P: ParamLike>( &mut self, param: &P ) -> Result<(), MzMLWriterError>

pub fn write_param_list<'a, P: ParamLike + 'a, T: Iterator<Item = &'a P>>( &mut self, params: T ) -> Result<(), MzMLWriterError>

pub fn get_ms_cv(&self) -> &ControlledVocabulary

Trait Implementations

impl<W: Debug + Write, C: Debug + CentroidLike + Default + BuildArrayMapFrom + 'static, D: Debug + DeconvolutedCentroidLike + Default + BuildArrayMapFrom + 'static> Debug for MzMLWriterType<W, C, D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<W: Write, C: CentroidLike + Default + BuildArrayMapFrom, D: DeconvolutedCentroidLike + Default + BuildArrayMapFrom> Drop for MzMLWriterType<W, C, D>

fn drop(&mut self)

Executes the destructor for this type.

impl<W: Write, C: CentroidLike + Default + BuildArrayMapFrom, D: DeconvolutedCentroidLike + Default + BuildArrayMapFrom> MSDataFileMetadata for MzMLWriterType<W, C, D>

fn data_processings(&self) -> &Vec<DataProcessing>

The series of DataProcessing workflows applied to spectra in this data file.

fn instrument_configurations(&self) -> &HashMap<u32, InstrumentConfiguration>

A mapping over different InstrumentConfiguration modes that spectra were acquired under.

fn file_description(&self) -> &FileDescription

A description of the contents and the sources for this mass spectrometry data file.

fn softwares(&self) -> &Vec<Software>

The series of Software applied to the data file to apply different DataProcessing methods.

fn data_processings_mut(&mut self) -> &mut Vec<DataProcessing>

Mutably access the DataProcessing list for this data file

fn instrument_configurations_mut( &mut self ) -> &mut HashMap<u32, InstrumentConfiguration>

Mutably access the InstrumentConfiguration mapping for this data file

fn file_description_mut(&mut self) -> &mut FileDescription

Mutably access the FileDescription description of the contents and the sources for this mass spectrometry data file.

fn softwares_mut(&mut self) -> &mut Vec<Software>

Mutably access the list of Software of this data file.

fn copy_metadata_from(&mut self, source: &impl MSDataFileMetadata)

Copy the metadata from another MSDataFileMetadata implementation into this one.

fn run_description(&self) -> Option<&MassSpectrometryRun>

Access the MassSpectrometryRun metadata record if it is available

fn run_description_mut(&mut self) -> Option<&mut MassSpectrometryRun>

Mutably access the MassSpectrometryRun metadata record if it is available

fn spectrum_count_hint(&self) -> Option<u64>

A hint about how many spectra are in this data file

fn source_file_name(&self) -> Option<&str>

Get the name of the primary source file, if available

impl<W: Write, C: CentroidLike + Default + BuildArrayMapFrom, D: DeconvolutedCentroidLike + Default + BuildArrayMapFrom> SpectrumWriter<C, D> for MzMLWriterType<W, C, D>

fn write<S: SpectrumLike<C, D> + 'static>( &mut self, spectrum: &S ) -> Result<usize>

Write out a single spectrum

fn flush(&mut self) -> Result<()>

As std::io::Write::flush

fn close(&mut self) -> Result<()>

Completes the data file format, preventing new data from being able incorporate additional data. Does not formally close the underlying writing stream.

fn write_owned<S: SpectrumLike<C, D> + 'static>( &mut self, spectrum: S ) -> Result<usize>

Write out a single owned spectrum.

fn write_all<'b, S: SpectrumLike<C, D> + 'static, T: Iterator<Item = &'b S>>( &mut self, iterator: T ) -> Result<usize>

Consume an Iterator over Spectrum references

fn write_group<S: SpectrumLike<C, D> + 'static, G: SpectrumGrouping<C, D, S> + 'static>( &mut self, group: &G ) -> Result<usize>

Write a SpectrumGroup out in order

fn write_group_owned<S: SpectrumLike<C, D> + 'static, G: SpectrumGrouping<C, D, S> + 'static>( &mut self, group: G ) -> Result<usize>

Write an owned SpectrumGroup out in order

fn write_all_groups<'b, S: SpectrumLike<C, D> + 'static, G: SpectrumGrouping<C, D, S> + 'static, T: Iterator<Item = &'b G>>( &mut self, iterator: T ) -> Result<usize>

Consume an Iterator over SpectrumGroup references