Struct DataAccess 

pub struct DataAccess<D: Read + Seek> { /* private fields */ }

Enables access to data stored in data_location. The data could be compressed and/or encoded and stored with various different types. This information is captured in the data_description

Implementations

impl<D: Read + Seek> DataAccess<D>

pub fn from_binary_data_array( bda: &BinaryDataArray, data_location: Arc<Mutex<D>>, ) -> Option<Self>

Create a DataAccess instance from a BinaryDataArray, using the specified data_location

pub fn offset(&self) -> u64

Return the offset (in the file) of the data

pub fn encoded_length(&self) -> u64

Return the length (in bytes) of the data in the file

pub fn binary_type(&self) -> BinaryDataType

Returns the binary type of the data (e.g. 64-bit float)

pub fn as_f64(&self) -> Result<Vec<f64>, DataError>

Decode, decompress and convert (if necessary) data points to f64

Examples found in repository

examples/rewrite.rs (line 32)

fn main() {
    let filename = "test/only_ms2_mzml.mzML";

    let start = Instant::now();
    let file = File::open(filename).unwrap();
    let header_reader = BufReader::new(file);

    let data_file = File::open(filename).unwrap();
    let data_reader = BufReader::new(data_file);

    let parser = ImzMLReader::new(header_reader, data_reader).unwrap();

    let duration = start.elapsed();

    for error in parser.errors() {
        println!("{:?}", error);
    }
    println!("Time elapsed when parsing is: {:?}", duration);

    let spectrum = parser.spectrum(0).unwrap();
    let mzs = spectrum.mz_array().unwrap();
    println!("Data: {:?}", mzs.as_f64());

    let start = Instant::now();

    let mut writer = ImzMLWriter::from_parser(&parser);

    writer
        .write(
            "test/only_ms2_mzml.imzML",
            ImzMLWritableSpectrumIterator::new(&parser),
            RectangleImage::new(10, 10),
        )
        .unwrap();

    // let file = File::create("test/only_ms2_mzml.imzML").unwrap();
    // let mut writer = Writer::new_with_indent(BufWriter::new(file), b' ', 2);
    // let decl_elem = quick_xml::events::BytesDecl::new(
    //     "1.1".as_ref(),
    //     Some("UTF-8".as_ref()),
    //     Some("yes".as_ref()),
    // );
    // writer
    //     .write_event(quick_xml::events::Event::Decl(decl_elem))
    //     .unwrap();

    // parser.mzml().unwrap().write_xml(&mut writer).unwrap();
    let duration = start.elapsed();
    println!("Time elapsed when writing is: {:?}", duration);
}

Trait Implementations

impl<D: Debug + Read + Seek> Debug for DataAccess<D>

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

Formats the value using the given formatter.