ionic-rs 0.1.2

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use crate::{
    ion::{
        attr_meta::{
            ACC_ATTR_EXTERNAL_SPECTRUM_ID, ACC_ATTR_REF, ACC_ATTR_SOURCE_FILE_REF,
            ACC_ATTR_SPECTRUM_REF,
        },
        decoder::decode::Metadatum,
        utilities::{
            children_lookup::{ChildrenLookup, DefaultMetadataPolicy, OwnerRows},
            common::get_attr_text,
            parse_cv_and_user_params,
        },
    },
    mzml::{
        schema::TagId,
        structs::{
            Activation, IsolationWindow, Precursor, PrecursorList, ReferenceableParamGroupRef,
            SelectedIon, SelectedIonList,
        },
    },
};

#[inline]
pub(crate) fn parse_precursor_list<'a>(
    owner_rows: &'a OwnerRows<'a>,
    children_lookup: &ChildrenLookup,
    spectrum_id: u32,
) -> Option<PrecursorList> {
    let description_id = children_lookup
        .ids_for(spectrum_id, TagId::SpectrumDescription)
        .first()
        .copied();

    let precursor_list_id = children_lookup
        .ids_for(spectrum_id, TagId::PrecursorList)
        .first()
        .copied()
        .or_else(|| {
            description_id.and_then(|id| {
                children_lookup
                    .ids_for(id, TagId::PrecursorList)
                    .first()
                    .copied()
            })
        });

    let precursor_container_id = precursor_list_id.or(description_id).unwrap_or(spectrum_id);
    let precursor_ids = children_lookup.ids_for(precursor_container_id, TagId::Precursor);
    if precursor_ids.is_empty() {
        return None;
    }

    let policy = DefaultMetadataPolicy;
    let mut param_buffer: Vec<&Metadatum> = Vec::new();

    let precursors = precursor_ids
        .iter()
        .map(|&precursor_id| {
            let rows = owner_rows.get(precursor_id);
            Precursor {
                spectrum_ref: get_attr_text(rows, ACC_ATTR_SPECTRUM_REF),
                source_file_ref: get_attr_text(rows, ACC_ATTR_SOURCE_FILE_REF),
                external_spectrum_id: get_attr_text(rows, ACC_ATTR_EXTERNAL_SPECTRUM_ID),
                isolation_window: parse_isolation_window(
                    owner_rows,
                    children_lookup,
                    precursor_id,
                    &policy,
                    &mut param_buffer,
                ),
                selected_ion_list: parse_selected_ion_list(
                    owner_rows,
                    children_lookup,
                    precursor_id,
                    &policy,
                    &mut param_buffer,
                ),
                activation: parse_activation(
                    owner_rows,
                    children_lookup,
                    precursor_id,
                    &policy,
                    &mut param_buffer,
                ),
            }
        })
        .collect::<Vec<_>>();

    let (cv_params, user_params) = precursor_list_id
        .map(|id| {
            param_buffer.clear();
            children_lookup.get_param_rows_into(owner_rows, id, &policy, &mut param_buffer);
            parse_cv_and_user_params(&param_buffer)
        })
        .unwrap_or_default();

    Some(PrecursorList {
        count: Some(precursors.len()),
        cv_params,
        user_params,
        precursors,
    })
}

#[inline]
fn parse_isolation_window<'a>(
    owner_rows: &'a OwnerRows<'a>,
    children_lookup: &ChildrenLookup,
    precursor_id: u32,
    policy: &DefaultMetadataPolicy,
    param_buffer: &mut Vec<&'a Metadatum>,
) -> Option<IsolationWindow> {
    let isolation_window_id = children_lookup
        .ids_for(precursor_id, TagId::IsolationWindow)
        .first()
        .copied()?;

    param_buffer.clear();
    children_lookup.get_param_rows_into(owner_rows, isolation_window_id, policy, param_buffer);
    let (cv_params, user_params) = parse_cv_and_user_params(param_buffer);

    Some(IsolationWindow {
        referenceable_param_group_refs: children_lookup
            .ids_for(isolation_window_id, TagId::ReferenceableParamGroupRef)
            .iter()
            .filter_map(|&ref_id| {
                get_attr_text(owner_rows.get(ref_id), ACC_ATTR_REF)
                    .map(|r| ReferenceableParamGroupRef { r#ref: r })
            })
            .collect(),
        cv_params,
        user_params,
    })
}

#[inline]
fn parse_selected_ion_list<'a>(
    owner_rows: &'a OwnerRows<'a>,
    children_lookup: &ChildrenLookup,
    precursor_id: u32,
    policy: &DefaultMetadataPolicy,
    param_buffer: &mut Vec<&'a Metadatum>,
) -> Option<SelectedIonList> {
    let selected_ion_list_id = children_lookup
        .ids_for(precursor_id, TagId::SelectedIonList)
        .first()
        .copied();

    let selected_ion_ids = children_lookup.ids_for(
        selected_ion_list_id.unwrap_or(precursor_id),
        TagId::SelectedIon,
    );

    if selected_ion_ids.is_empty() {
        return None;
    }

    let selected_ions = selected_ion_ids
        .iter()
        .map(|&selected_ion_id| {
            param_buffer.clear();
            children_lookup.get_param_rows_into(owner_rows, selected_ion_id, policy, param_buffer);
            let (cv_params, user_params) = parse_cv_and_user_params(param_buffer);

            SelectedIon {
                referenceable_param_group_refs: children_lookup
                    .ids_for(selected_ion_id, TagId::ReferenceableParamGroupRef)
                    .iter()
                    .filter_map(|&ref_id| {
                        get_attr_text(owner_rows.get(ref_id), ACC_ATTR_REF)
                            .map(|r| ReferenceableParamGroupRef { r#ref: r })
                    })
                    .collect(),
                cv_params,
                user_params,
            }
        })
        .collect::<Vec<_>>();

    Some(SelectedIonList {
        count: Some(selected_ions.len()),
        selected_ions,
    })
}

#[inline]
fn parse_activation<'a>(
    owner_rows: &'a OwnerRows<'a>,
    children_lookup: &ChildrenLookup,
    precursor_id: u32,
    policy: &DefaultMetadataPolicy,
    param_buffer: &mut Vec<&'a Metadatum>,
) -> Option<Activation> {
    let activation_id = children_lookup
        .ids_for(precursor_id, TagId::Activation)
        .first()
        .copied()?;

    param_buffer.clear();
    children_lookup.get_param_rows_into(owner_rows, activation_id, policy, param_buffer);
    let (cv_params, user_params) = parse_cv_and_user_params(param_buffer);

    Some(Activation {
        referenceable_param_group_refs: children_lookup
            .ids_for(activation_id, TagId::ReferenceableParamGroupRef)
            .iter()
            .filter_map(|&ref_id| {
                get_attr_text(owner_rows.get(ref_id), ACC_ATTR_REF)
                    .map(|r| ReferenceableParamGroupRef { r#ref: r })
            })
            .collect(),
        cv_params,
        user_params,
    })
}