Trait MZFileReader 

pub trait MZFileReader<C: CentroidLike = CentroidPeak, D: DeconvolutedCentroidLike = DeconvolutedPeak, S: SpectrumLike<C, D> = MultiLayerSpectrum<C, D>>: SpectrumSource<C, D, S> + Sized {
    // Required methods
    fn construct_index_from_stream(&mut self) -> u64;
    fn open_file(source: File) -> Result<Self>;

    // Provided methods
    fn read_index(&mut self, reader: Box<dyn Read>) -> Result<&mut Self, Error> { ... }
    fn write_index(&self, writer: Box<dyn Write>) -> Result<&Self, Error> { ... }
    fn open_path<P>(path: P) -> Result<Self>
       where P: Into<PathBuf> + Clone { ... }
}

A trait defining some helper methods to make efficient use of indices automatic when opening a file from a path-like object.

Required Methods

fn construct_index_from_stream(&mut self) -> u64

An on-trait method of constructing an index. Assumed to be a trivial wrapper.

fn open_file(source: File) -> Result<Self>

Given a regular file, construct a new instance without indexing.

Provided Methods

fn read_index(&mut self, reader: Box<dyn Read>) -> Result<&mut Self, Error>

Re-construct an offset index from this readable object, assuming it is a JSON stream over the serialized index.

fn write_index(&self, writer: Box<dyn Write>) -> Result<&Self, Error>

fn open_path<P>(path: P) -> Result<Self>

where P: Into<PathBuf> + Clone,

The preferred method of opening a file from a path-like object. This method will open the file at the provided path, test whether there is an accompanied index file next to it on the file system, and if not, build one and save it or otherwise read in the index.

The index building process is usually neglible on “regular” IO file systems.

Examples found in repository

examples/mzcat.rs (line 33)

fn main() -> io::Result<()> {
    env_logger::init();
    let path = path::PathBuf::from(
        env::args()
            .nth(1)
            .expect("Please pass an MS data file path"),
    );

    let mut reader = MZReader::open_path(&path)?;
    scan_file(&mut reader);
    Ok(())
}

examples/mzinfo.rs (line 246)

fn main() -> io::Result<()> {
    env_logger::init();
    let path = path::PathBuf::from(env::args().nth(1).unwrap_or_else(|| {
        eprintln!("Please provide a path to an MS data file");
        process::exit(1)
    }));
    let mut summarizer = MSDataFileSummary::default();

    if path.as_os_str() == "-" {
        mzdata::mz_read!(Source::Stdin, reader => {
            summarizer.scan_file(reader)
        })?;
    } else {
        let mut reader = MZReader::open_path(path)?;
        eprintln!("Format: {}", reader.as_format());
        if reader.count_chromatograms() > 0 {
            summarizer.scan_chromatograms(&mut reader);
            reader.reset();
        }
        summarizer.scan_file(reader)
    };

    summarizer.write_out();
    Ok(())
}

examples/readme.rs (line 7)

fn main() -> io::Result<()> {
    let reader = mzdata::MZReader::open_path("./test/data/small.mzML")?;

    let mut ms1_count = 0;
    let mut msn_count = 0;
    for spectrum in reader {
        if spectrum.ms_level() == 1 {
            ms1_count += 1;
        } else {
            msn_count += 1;
        }
        println!(
            "Scan {} => BP {}",
            spectrum.id(),
            spectrum.peaks().base_peak().mz
        );
        if spectrum.signal_continuity() < SignalContinuity::Profile {
            let peak_picked = spectrum.into_centroid().unwrap();
            println!(
                "Matches for 579.155: {:?}",
                peak_picked
                    .peaks
                    .all_peaks_for(579.155, Tolerance::Da(0.02))
            );
        }
    }
    println!("MS1 Count: {}\nMSn Count: {}", ms1_count, msn_count);
    assert_eq!(ms1_count, 14);
    assert_eq!(msn_count, 34);
    Ok(())
}

examples/get_chromatogram_by.rs (line 21)

fn main() -> io::Result<()> {
    env_logger::init();
    let mut args = env::args().skip(1);

    let path = path::PathBuf::from(args.next().expect("Please pass an MS data file path"));

    let key = args
        .next()
        .expect("Please provide a key type, \"id\" or \"index\"");
    let key_value = args
        .next()
        .expect("Please provide a key value matching the key type");

    info!("Opening {}", path.display());
    let mut reader = MZReader::open_path(path)?;

    let chrom = match key.as_str() {
        "id" => reader.get_chromatogram_by_id(&key_value).unwrap(),
        "index" => reader
            .get_chromatogram_by_index(key_value.parse().unwrap())
            .unwrap(),
        _ => {
            panic!("Unknown key type {}", key);
        }
    };

    println!("ID: {}; Index: {};", chrom.id(), chrom.index(),);
    println!("Type: {:?}", chrom.chromatogram_type());
    if let Some(product) = chrom.product() {
        println!("Product: {:?}", product);
    }
    Ok(())
}

examples/get_scan_by.rs (line 21)

fn main() -> io::Result<()> {
    env_logger::init();
    let mut args = env::args().skip(1);

    let path = path::PathBuf::from(args.next().expect("Please pass an MS data file path"));

    let key = args
        .next()
        .expect("Please provide a key type, \"id\", \"index\" or \"time\"");
    let key_value = args
        .next()
        .expect("Please provide a key value matching the key type");

    info!("Opening {}", path.display());
    let mut reader = MZReader::open_path(path)?;
    info!("{} spectra detected", reader.len());
    let spectrum = match key.as_str() {
        "id" => reader.get_spectrum_by_id(&key_value).unwrap(),
        "index" => reader
            .get_spectrum_by_index(key_value.parse().unwrap())
            .unwrap(),
        "time" => reader
            .get_spectrum_by_time(key_value.parse().unwrap())
            .unwrap(),
        _ => {
            panic!("Unknown key type {}", key);
        }
    };

    // dbg!(spectrum);
    println!(
        "ID: {}; Index: {}; Time: {}",
        spectrum.id(),
        spectrum.index(),
        spectrum.start_time()
    );
    println!(
        "Num data points: {}",
        spectrum
            .raw_arrays()
            .and_then(|r| Some(r.mzs().ok()?.len()))
            .unwrap_or_default()
    );
    if spectrum.signal_continuity().is_centroid() && spectrum.raw_arrays().is_none() {
        println!("Num peaks: {}", spectrum.peaks().len());
    }
    Ok(())
}

examples/random_access_iter.rs (line 14)

fn main() -> io::Result<()> {
    let path = path::PathBuf::from(
        env::args()
            .nth(1)
            .expect("Please pass an MS data file path"),
        // "test/data/batching_test.mzML"
    );

    let mut reader = mzml::MzMLReader::open_path(path)?;

    let n_spectra = reader.len();

    // Find the spectrum at the midpoint of the run
    let spec = reader.get_spectrum_by_index(n_spectra / 2).unwrap();
    eprintln!(
        "Midpoint spectrum {} (level {}) at time {}",
        spec.id(),
        spec.ms_level(),
        spec.start_time()
    );

    // Jump the iterator to that point in time
    reader.start_from_time(spec.start_time())?;
    let s = reader.next().unwrap();
    eprintln!(
        "Resuming at {} (level {}) at time {}",
        s.id(),
        s.ms_level(),
        s.start_time()
    );

    // Convert the iterator into a group iterator
    let mut group_iter = reader.into_groups();
    // Jump the group iterator to that point in time (If an MSn spectrum was found, the next MS1 may be shown instead)
    group_iter.start_from_time(spec.start_time())?;
    let g = group_iter.next().unwrap();
    eprintln!(
        "Resuming at group having {:?} at time {:?}",
        g.earliest_spectrum().map(|s| s.id()),
        g.earliest_spectrum().map(|s| s.start_time())
    );

    // Convert the group iterator into an averaging group iterator
    let mut avg_iter = group_iter.averaging(1, 200.0, 2200.0, 0.005);
    // Jump the group iterator to that point in time (If an MSn spectrum was found, the next MS1 may be shown instead)
    avg_iter.start_from_time(spec.start_time())?;
    let g = avg_iter.next().unwrap();
    eprintln!(
        "Resuming at group having {:?} at time {:?}",
        g.earliest_spectrum().map(|s| s.id()),
        g.earliest_spectrum().map(|s| s.start_time())
    );

    Ok(())
}

Additional examples can be found in:

• examples/averaging_writer.rs

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFromArrayMap> MZFileReader<C, D> for ImzMLReaderType<File, File, C, D>

For open_file we assume that the IBD file is named the same as the imzML file

impl<C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFromArrayMap> MZFileReader<C, D> for MzMLReaderType<File, C, D>

impl<C: CentroidLike + From<CentroidPeak> + BuildFromArrayMap, D: DeconvolutedCentroidLike + From<DeconvolutedPeak> + BuildFromArrayMap> MZFileReader<C, D> for MZReaderType<File, C, D>

impl<C: CentroidLike + From<CentroidPeak>, D: DeconvolutedCentroidLike + From<DeconvolutedPeak>> MZFileReader<C, D> for MGFReaderType<File, C, D>

impl<C: CentroidLike + From<CentroidPeak>, D: DeconvolutedCentroidLike> MZFileReader<C, D> for ThermoRawReaderType<C, D>

impl<C: FeatureLike<MZ, IonMobility>, D: FeatureLike<Mass, IonMobility> + KnownCharge, CP: CentroidLike + From<CentroidPeak>, DP: DeconvolutedCentroidLike> MZFileReader<CP, DP> for TDFSpectrumReaderType<C, D, CP, DP>