ionic-rs 0.2.2

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use crate::{
    ion::{
        attr_meta::{ACC_ATTR_COUNT, ACC_ATTR_ID, ACC_ATTR_NAME, ACC_ATTR_REF, ACC_ATTR_VERSION},
        decoder::decode::Metadatum,
        utilities::{
            children_lookup::{ChildrenLookup, MetadataPolicy, OwnerRows},
            common::get_attr_text,
            cv_table, parse_cv_and_user_params,
        },
    },
    mzml::{
        schema::TagId,
        structs::{ReferenceableParamGroupRef, Software, SoftwareList, SoftwareParam},
    },
};

const EXCLUDED_ACCESSION_PREFIX: &str = "ATTR:";

#[inline]
pub(crate) fn parse_software_list<P: MetadataPolicy>(
    metadata: &[&Metadatum],
    children_lookup: &ChildrenLookup,
    policy: &P,
) -> Option<SoftwareList> {
    let mut owner_rows = OwnerRows::with_capacity(metadata.len());
    for &entry in metadata {
        owner_rows.insert(entry.id, entry);
    }

    let list_id = children_lookup
        .all_ids(TagId::SoftwareList)
        .first()
        .copied();

    let software_ids: &[u32] = if let Some(id) = list_id {
        let direct = children_lookup.ids_for(id, TagId::Software);
        if direct.is_empty() {
            children_lookup.all_ids(TagId::Software)
        } else {
            direct
        }
    } else {
        children_lookup.all_ids(TagId::Software)
    };

    if software_ids.is_empty() {
        return None;
    }

    let count = list_id.and_then(|id| {
        get_attr_text(owner_rows.get(id), ACC_ATTR_COUNT).and_then(|c| c.parse::<usize>().ok())
    });

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

    let software = software_ids
        .iter()
        .map(|&software_id| {
            parse_software(
                children_lookup,
                &owner_rows,
                software_id,
                policy,
                &mut param_buffer,
            )
        })
        .collect();

    Some(SoftwareList {
        count: count.or(Some(software_ids.len())),
        software,
    })
}

fn parse_software<'a, P: MetadataPolicy>(
    children_lookup: &ChildrenLookup,
    owner_rows: &'a OwnerRows<'a>,
    software_id: u32,
    policy: &P,
    param_buffer: &mut Vec<&'a Metadatum>,
) -> Software {
    let rows = owner_rows.get(software_id);

    let id = get_attr_text(rows, ACC_ATTR_ID).unwrap_or_default();
    let version = get_attr_text(rows, ACC_ATTR_VERSION).filter(|s| !s.is_empty());

    param_buffer.clear();
    children_lookup.get_param_rows_into(owner_rows, software_id, policy, param_buffer);
    let (cv_param, user_params) = parse_cv_and_user_params(param_buffer);

    let software_param =
        parse_software_params(children_lookup, owner_rows, software_id, version.as_deref());

    let referenceable_param_group_refs = children_lookup
        .ids_for(software_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();

    Software {
        id,
        version,
        software_param,
        cv_param,
        user_params,
        referenceable_param_group_refs,
    }
}

#[inline]
fn parse_software_params(
    children_lookup: &ChildrenLookup,
    owner_rows: &OwnerRows,
    software_id: u32,
    parent_version: Option<&str>,
) -> Vec<SoftwareParam> {
    children_lookup
        .ids_for(software_id, TagId::SoftwareParam)
        .iter()
        .map(|&software_param_id| {
            parse_software_param(owner_rows, software_param_id, parent_version)
        })
        .collect()
}

#[inline]
fn parse_software_param(
    owner_rows: &OwnerRows,
    software_param_id: u32,
    parent_version: Option<&str>,
) -> SoftwareParam {
    let rows = owner_rows.get(software_param_id);

    let version = get_attr_text(rows, ACC_ATTR_VERSION)
        .filter(|s| !s.is_empty())
        .or_else(|| parent_version.map(ToString::to_string));

    let (mut cv_params, mut user_params) = parse_cv_and_user_params(rows);

    if let Some(cv) = cv_params.pop() {
        let accession = cv.accession.unwrap_or_default();
        let cv_ref = cv
            .cv_ref
            .or_else(|| get_attr_text(rows, ACC_ATTR_REF).filter(|s| !s.is_empty()));

        return SoftwareParam {
            cv_ref,
            accession,
            name: cv.name,
            version,
        };
    }

    if let Some(user) = user_params.pop() {
        return SoftwareParam {
            cv_ref: None,
            accession: String::new(),
            name: user.name,
            version,
        };
    }

    let accession = accession_from_rows(rows).unwrap_or_default();

    let cv_ref = get_attr_text(rows, ACC_ATTR_REF).filter(|s| !s.is_empty());

    let name = get_attr_text(rows, ACC_ATTR_NAME)
        .filter(|s| !s.is_empty())
        .unwrap_or_else(|| {
            cv_table::get(&accession)
                .and_then(|v| v.as_str())
                .unwrap_or(&accession)
                .to_string()
        });

    SoftwareParam {
        cv_ref,
        accession,
        name,
        version,
    }
}

#[inline]
fn accession_from_rows(rows: &[&Metadatum]) -> Option<String> {
    rows.iter().find_map(|entry| {
        let accession = entry.accession.as_deref()?;
        if !accession.starts_with(EXCLUDED_ACCESSION_PREFIX) && accession.contains(':') {
            Some(accession.to_string())
        } else {
            None
        }
    })
}