Enum AuxArray

pub enum AuxArray<'a, T> {
    TargetType(AuxArrayTargetType<'a, T>),
    RawLeBytes(AuxArrayRawLeBytes<'a, T>),
}

Provides access to aux arrays.

Provides methods to either retrieve single elements or an iterator over the array.

This type is used for wrapping both, array data that was read from a BAM record and slices of data that are going to be stored in one.

In order to be able to add an AuxArray field to a BAM record, AuxArrays can be constructed via the From trait which is implemented for all supported types (see AuxArrayElement for a list).

Examples

use rust_htslib::{
    bam,
    bam::record::{Aux, AuxArray},
};

//Set up BAM record
let bam_header = bam::Header::new();
let mut record = bam::Record::from_sam(
    &mut bam::HeaderView::from_header(&bam_header),
    "ali1\t4\t*\t0\t0\t*\t*\t0\t0\tACGT\tFFFF".as_bytes(),
).unwrap();

let data = vec![0.4, 0.3, 0.2, 0.1];
let slice_of_data = &data;
let aux_array: AuxArray<f32> = slice_of_data.into();
let aux_field = Aux::ArrayFloat(aux_array);
record.push_aux(b"XA", aux_field);

if let Ok(Aux::ArrayFloat(array)) = record.aux(b"XA") {
    // Retrieve the second element from the array
    assert_eq!(array.get(1).unwrap(), 0.3);
    // Iterate over the array and collect it into a `Vec`
    let read_array = array.iter().collect::<Vec<_>>();
    assert_eq!(read_array, data);
} else {
    panic!("Could not read array data");
}

Variants

TargetType(AuxArrayTargetType<'a, T>)

RawLeBytes(AuxArrayRawLeBytes<'a, T>)

Implementations

impl<'a, T> AuxArray<'a, T>

where T: AuxArrayElement,

pub fn get(&self, index: usize) -> Option<T>

Returns the element at a position or None if out of bounds.

pub fn len(&self) -> usize

Returns the number of elements in the array.

pub fn is_empty(&self) -> bool

Returns true if the array contains no elements.

pub fn iter(&self) -> AuxArrayIter<'_, T>

Returns an iterator over the array.

Trait Implementations

impl<'a, T: Debug> Debug for AuxArray<'a, T>

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

Formats the value using the given formatter.

impl<'a, I, T> From<&'a T> for AuxArray<'a, I>

where I: AuxArrayElement, T: AsRef<[I]> + ?Sized,

Create AuxArrays from slices of allowed target types.

fn from(src: &'a T) -> Self

Converts to this type from the input type.

impl<T> PartialEq<AuxArray<'_, T>> for AuxArray<'_, T>

where T: AuxArrayElement + PartialEq,

fn eq(&self, other: &AuxArray<'_, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.