Struct DataArray

pub struct DataArray {
    pub data: Vec<u8>,
    pub dtype: BinaryDataArrayType,
    pub compression: BinaryCompressionType,
    pub name: ArrayType,
    pub params: Option<Box<Vec<Param>>>,
    pub unit: Unit,
    /* private fields */
}

Represents a data array that holds a byte buffer that may be compressed, base64 encoded, or raw little endian bytes, and provides views of those bytes as a small range of supported types.

This type is modeled after the <binaryDataArray> element in mzML.

Note

This type tries to walk a fine line between convenience and performance and as such is easy to misuse. All operations that view the byte buffer as arbitrary data need that data to be decoded and decompressed in order to borrow it. If the byte buffer is not already stored decoded, the operation will copy and decode the buffer in its entirety before performing any other operation, so repeated method calls may incur excessive overhead. If this is happening, please use DataArray::decode_and_store to store the decoded representation explicitly.

Normally, SpectrumSource-implementing file readers will eagerly decode all arrays as soon as they are ready. If they are operating in lazy mode, the buffers will need to be decoded explicitly, again using DataArray::decode_and_store or operations should make as much use of the copied arrays as possible instead.

Fields

data: Vec<u8>

dtype: BinaryDataArrayType

compression: BinaryCompressionType

name: ArrayType

params: Option<Box<Vec<Param>>>

unit: Unit

Implementations

impl<'transient, 'lifespan> DataArray

where 'lifespan: 'transient,

A type to represent a base64-encoded, possibly compressed data array of a fixed size, usually numeric, type. It can be decoded, and it can

pub fn new() -> DataArray

pub fn from_name(name: &ArrayType) -> DataArray

pub fn from_name_and_type( name: &ArrayType, dtype: BinaryDataArrayType, ) -> DataArray

pub fn from_name_type_size( name: &ArrayType, dtype: BinaryDataArrayType, size: usize, ) -> DataArray

pub fn slice( &self, start: usize, end: usize, ) -> Result<DataArray, ArrayRetrievalError>

pub fn slice_buffer( &self, start: usize, end: usize, ) -> Result<Cow<'_, [u8]>, ArrayRetrievalError>

pub fn wrap( name: &ArrayType, dtype: BinaryDataArrayType, data: Vec<u8>, ) -> DataArray

pub fn update_buffer<T>( &mut self, data_buffer: &[T], ) -> Result<usize, ArrayRetrievalError>

where T: Pod,

pub fn push<T>(&mut self, value: T) -> Result<(), ArrayRetrievalError>

where T: Pod,

pub fn extend<T>(&mut self, values: &[T]) -> Result<(), ArrayRetrievalError>

where T: Pod,

pub fn encode_bytestring(&self, compression: BinaryCompressionType) -> Vec<u8>

pub fn compress_zlib(bytestring: &[u8]) -> Vec<u8>

pub fn decompress_zlib(bytestring: &[u8]) -> Vec<u8>

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

Decode the compressed data, if needed, and store that buffer in self.data. After decoding self.compression will always be BinaryCompressionType::Decoded.

The return value is the content of self.compression after decoding.

This may fail if the decoding fails for any reason.

pub fn decode( &'lifespan self, ) -> Result<Cow<'lifespan, [u8]>, ArrayRetrievalError>

Decompress and base64-decode encoded bytes, and return the data.

If the data were already decoded, the existing bytes are returned. Otherwise one or more buffers may be allocated to hold the decompressed and decoded bytes.

pub fn decode_mut( &'transient mut self, ) -> Result<&'transient mut Vec<u8>, ArrayRetrievalError>

pub fn clear(&mut self)

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

The reverse of DataArray::decode_and_store, this method compresses self.data to the desired compression method and stores that buffer as self.data.

pub fn store_as( &mut self, dtype: BinaryDataArrayType, ) -> Result<usize, ArrayRetrievalError>

Recode the stored data as the requested binary data type.

pub const fn is_ion_mobility(&self) -> bool

Test if the the array describes an ion mobility quantity.

See also

ArrayType::is_ion_mobility

pub fn raw_len(&self) -> usize

The size of the raw byte buffer

Trait Implementations

impl<'transient, 'lifespan> ByteArrayView<'transient, 'lifespan> for DataArray

where 'lifespan: 'transient,

fn view(&'lifespan self) -> Result<Cow<'lifespan, [u8]>, ArrayRetrievalError>

fn dtype(&self) -> BinaryDataArrayType

The real data type encoded in bytes

fn data_len(&'lifespan self) -> Result<usize, ArrayRetrievalError>

The size of encoded array in terms of # of elements of the BinaryDataArrayType given by ByteArrayView::dtype

fn unit(&self) -> Unit

The unit of measurement each data point is in

fn name(&self) -> &ArrayType

The kind of array this is

fn coerce_from<T>( buffer: Cow<'transient, [u8]>, ) -> Result<Cow<'transient, [T]>, ArrayRetrievalError>

where T: Pod,

fn coerce<T>( &'lifespan self, ) -> Result<Cow<'transient, [T]>, ArrayRetrievalError>

where T: Pod,

fn convert<S, D>( &'lifespan self, ) -> Result<Cow<'transient, [D]>, ArrayRetrievalError>

where S: Num + Clone + AsPrimitive<D> + Pod, D: Num + Clone + Copy + 'static,

Decode the array, then copy it to a new array, converting each element from type D to to type S

fn to_f32( &'lifespan self, ) -> Result<Cow<'transient, [f32]>, ArrayRetrievalError>

fn to_f64( &'lifespan self, ) -> Result<Cow<'transient, [f64]>, ArrayRetrievalError>

fn to_i32( &'lifespan self, ) -> Result<Cow<'transient, [i32]>, ArrayRetrievalError>

fn to_i64( &'lifespan self, ) -> Result<Cow<'transient, [i64]>, ArrayRetrievalError>

fn iter_type<T>( &'lifespan self, ) -> Result<DataSliceIter<'lifespan, T>, ArrayRetrievalError>

where T: Pod,

fn iter_u8( &'lifespan self, ) -> Result<DataSliceIter<'lifespan, u8>, ArrayRetrievalError>

fn iter_f32( &'lifespan self, ) -> Result<DataSliceIter<'lifespan, f32>, ArrayRetrievalError>

fn iter_f64( &'lifespan self, ) -> Result<DataSliceIter<'lifespan, f64>, ArrayRetrievalError>

fn iter_i32( &'lifespan self, ) -> Result<DataSliceIter<'lifespan, i32>, ArrayRetrievalError>

fn iter_i64( &'lifespan self, ) -> Result<DataSliceIter<'lifespan, i64>, ArrayRetrievalError>

impl<'transient, 'lifespan> ByteArrayViewMut<'transient, 'lifespan> for DataArray

where 'lifespan: 'transient,

fn view_mut( &'transient mut self, ) -> Result<&'transient mut Vec<u8>, ArrayRetrievalError>

Get a mutable view of the bytes backing this data array.

fn unit_mut(&mut self) -> &mut Unit

Specify the unit of the data array

fn coerce_from_mut<T>( buffer: &mut [u8], ) -> Result<&'transient mut [T], ArrayRetrievalError>

where T: Clone,

fn coerce_mut<T>( &'lifespan mut self, ) -> Result<&'transient mut [T], ArrayRetrievalError>

where T: Clone,

impl Clone for DataArray

fn clone(&self) -> DataArray

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataArray

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

Formats the value using the given formatter.

impl Default for DataArray

fn default() -> DataArray

Returns the “default value” for a type.

impl ParamDescribed for DataArray

fn params(&self) -> &[Param]

Obtain an immutable slice over the encapsulated Param list

fn params_mut(&mut self) -> &mut Vec<Param>

Obtain an mutable slice over the encapsulated Param list

fn add_param(&mut self, param: Param)

Add a new Param to the entity

fn extend_params(&mut self, it: impl IntoIterator<Item = Param>)

Add all parameters from an iterator of Param to the entity

fn remove_param(&mut self, index: usize) -> Param

Remove the ith Param from the entity.

fn get_param_by_name(&self, name: &str) -> Option<&Param>

Find the first Param whose name matches name

fn get_param_by_curie(&self, curie: &CURIE) -> Option<&Param>

Find the first Param whose CURIE matches curie

fn get_param_by_accession(&self, accession: &str) -> Option<&Param>

Find the first Param whose Param::accession matches accession

fn iter_params(&self) -> Iter<'_, Param>

Iterate over the encapsulated parameter list

fn iter_params_mut(&mut self) -> IterMut<'_, Param>

Iterate mutably over the encapsulated parameter list