Struct BinaryArrayMap

Source

pub struct BinaryArrayMap {
    pub byte_buffer_map: HashMap<ArrayType, DataArray>,
}

Expand description

A collection of DataArrays that are identified by name.

§Examples

use mzdata_bindata::{ArrayType, BinaryArrayMap, BinaryDataArrayType, DataArray};

let mut map = BinaryArrayMap::new();
assert!(!map.has_array(&ArrayType::MZArray));

let array = DataArray::from_name_and_type(&ArrayType::MZArray, BinaryDataArrayType::Float64);
map.add(array);

assert!(map.has_array(&ArrayType::MZArray));
assert_eq!(map.len(), 1);

Fields§

§byte_buffer_map: HashMap<ArrayType, DataArray>

Implementations§

Source §

impl BinaryArrayMap

Source

pub fn new() -> BinaryArrayMap

Source

pub fn len(&self) -> usize

Get the number of arrays in the map

Source

pub fn is_empty(&self) -> bool

Source

pub fn has_ion_mobility(&self) -> bool

Check if there is an ion mobility array present

Source

pub fn iter(&self) -> Iter<'_, ArrayType, DataArray> ⓘ

Iterate over references to the key-value pairs of this map

Source

pub fn iter_mut(&mut self) -> IterMut<'_, ArrayType, DataArray> ⓘ

Iterate over mutable references to the key-value pairs of this map

Source

pub fn encode_array( &mut self, array_type: &ArrayType, compression: BinaryCompressionType, ) -> Result<(), ArrayRetrievalError>

Compress a specific DataArray with the compression scheme provided, if it is present.

This method may fail if the compression fails or if the array type is missing.

§See Also

DataArray::store_compressed

Source

pub fn decode_all_arrays(&mut self) -> Result<(), ArrayRetrievalError>

Decode all DataArray in this map if they have not been decoded already so that they are ready for use. If there are many arrays and the parallelism feature is enabled, arrays may be decoded in parallel.

§Examples

use mzdata_bindata::{ArrayType, BinaryArrayMap, BinaryCompressionType, BinaryDataArrayType, DataArray};

let mut mz_array = DataArray::from_name_and_type(&ArrayType::MZArray, BinaryDataArrayType::Float64);
mz_array.extend(&[1.0f64, 2.0, 3.0]).unwrap();
mz_array.store_compressed(BinaryCompressionType::Zlib).unwrap();

let mut map = BinaryArrayMap::new();
map.add(mz_array);
assert_eq!(map.get(&ArrayType::MZArray).unwrap().compression, BinaryCompressionType::Zlib);

map.decode_all_arrays().unwrap();
assert_eq!(map.get(&ArrayType::MZArray).unwrap().compression, BinaryCompressionType::Decoded);

Source

pub fn decode_array( &mut self, array_type: &ArrayType, ) -> Result<(), ArrayRetrievalError>

Decode a specific DataArray if it is present.

This method may fail if decoding fails or if the array type is missing.

See DataArray::decode_and_store

Source

pub fn add(&mut self, array: DataArray)

Add a DataArray to the map by its ArrayType name

Source

pub fn get(&self, array_type: &ArrayType) -> Option<&DataArray>

Get a reference to a specific DataArray if present

Source

pub fn get_mut(&mut self, array_type: &ArrayType) -> Option<&mut DataArray>

Get a mutable reference to a specific DataArray if present

Source

pub fn has_array(&self, array_type: &ArrayType) -> bool

Check whether a specific ArrayType is present

Source

pub fn clear(&mut self)

Clear the map, discarding any array data

Source

pub fn search(&self, query: f64, error_tolerance: Tolerance) -> Option<usize>

Search for a specific m/z within a specified Tolerance.

This effectively calls BinaryArrayMap::mzs to get the m/z array and then performs a binary search to find the best index within range, if one exists.

Source

pub fn mzs(&self) -> Result<Cow<'_, [f64]>, ArrayRetrievalError>

Get a reference to the m/z array if it is present

§Examples

use mzdata_bindata::{ArrayType, BinaryArrayMap, BinaryDataArrayType, DataArray};

let mut mz_array = DataArray::from_name_and_type(&ArrayType::MZArray, BinaryDataArrayType::Float64);
mz_array.extend(&[100.0f64, 200.0, 300.0]).unwrap();

let mut map = BinaryArrayMap::new();
map.add(mz_array);

assert_eq!(&*map.mzs().unwrap(), &[100.0f64, 200.0, 300.0][..]);

Source

pub fn sort_from_indices( &mut self, mask: Vec<usize>, ) -> Result<(), ArrayRetrievalError>

Re-order all arrays of matching length with respect to the provided index mask operating on the decoded native value states.

The mask would be created using an indirect sort from another array:

let vals = self.mzs().unwrap();
let n = vals.len();
let mut mask: Vec<usize> = (0..n).into_iter().collect();
mask.sort_by(|i, j| {
    let a = vals[*i];
    let b = vals[*j];
    a.total_cmp(&b)
});
drop(vals);
self.sort_from_indices(mask)

Source

pub fn sort_by_array( &mut self, name: &ArrayType, ) -> Result<(), ArrayRetrievalError>

Sort all the arrays in the map by name if they are the same length. This operates on the decoded state directly.

This builds the sorting mask and then leaves Self::sort_from_indices to perform the re-ordering.

Not supported for BinaryDataArrayType::ASCII and BinaryDataArrayType::Unknown.

Source

pub fn mzs_mut(&mut self) -> Result<&mut [f64], ArrayRetrievalError>

Get a mutable reference to the m/z array if it is present.

This method obtains the m/z array, calls DataArray::decode_and_store to force the data to be stored natively in memory, and forces the storage to be BinaryDataArrayType::Float64 if not already. Finally it returns a mutable view of that decoded dataas &mut [f64]

Source