ionic-rs 0.2.0

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use crate::{
    ion::{
        attr_meta::{ACC_ATTR_ID, ACC_ATTR_ORDER, ACC_ATTR_REF, ACC_ATTR_SCAN_SETTINGS_REF},
        decoder::decode::Metadatum,
        utilities::{
            children_lookup::{ChildrenLookup, MetadataPolicy, OwnerRows},
            common::get_attr_text,
            parse_cv_and_user_params,
        },
    },
    mzml::{
        schema::TagId,
        structs::{
            Analyzer, ComponentList, CvParam, Detector, Instrument, InstrumentList,
            InstrumentSoftwareRef, ReferenceableParamGroupRef, ScanSettingsRef, Source, UserParam,
        },
    },
};

pub(crate) fn parse_instrument_list<P: MetadataPolicy>(
    metadata: &[&Metadatum],
    children_lookup: &ChildrenLookup,
    policy: &P,
) -> Option<InstrumentList> {
    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::InstrumentConfigurationList)
        .first()
        .copied();

    let instrument_ids: &[u32] = list_id
        .map(|id| children_lookup.ids_for(id, TagId::Instrument))
        .filter(|ids| !ids.is_empty())
        .unwrap_or_else(|| children_lookup.all_ids(TagId::Instrument));

    if instrument_ids.is_empty() {
        return None;
    }

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

    let instrument = instrument_ids
        .iter()
        .map(|&instrument_id| {
            parse_instrument(
                children_lookup,
                &owner_rows,
                instrument_id,
                policy,
                &mut param_buffer,
            )
        })
        .collect::<Vec<_>>();

    Some(InstrumentList {
        count: Some(instrument.len()),
        instrument,
    })
}

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

    param_buffer.clear();
    children_lookup.get_param_rows_into(owner_rows, instrument_id, policy, param_buffer);
    let (cv_param, user_param) = parse_cv_and_user_params(param_buffer);

    Instrument {
        id: get_attr_text(rows, ACC_ATTR_ID).unwrap_or_default(),
        scan_settings_ref: get_attr_text(rows, ACC_ATTR_SCAN_SETTINGS_REF)
            .filter(|s| !s.is_empty())
            .map(|s| ScanSettingsRef { r#ref: s }),
        cv_param,
        user_param,
        referenceable_param_group_ref: parse_param_group_refs(
            children_lookup,
            owner_rows,
            instrument_id,
        ),
        component_list: parse_component_list(
            children_lookup,
            owner_rows,
            instrument_id,
            policy,
            param_buffer,
        ),
        software_ref: parse_software_ref(children_lookup, owner_rows, instrument_id),
    }
}

struct ComponentData {
    order: Option<u32>,
    referenceable_param_group_ref: Vec<ReferenceableParamGroupRef>,
    cv_param: Vec<CvParam>,
    user_param: Vec<UserParam>,
}

fn parse_component_data<'a, P: MetadataPolicy>(
    children_lookup: &ChildrenLookup,
    owner_rows: &'a OwnerRows<'a>,
    component_id: u32,
    policy: &P,
    param_buffer: &mut Vec<&'a Metadatum>,
) -> ComponentData {
    param_buffer.clear();
    children_lookup.get_param_rows_into(owner_rows, component_id, policy, param_buffer);
    let (cv_param, user_param) = parse_cv_and_user_params(param_buffer);

    ComponentData {
        order: get_attr_text(owner_rows.get(component_id), ACC_ATTR_ORDER)
            .and_then(|s| s.parse().ok()),
        referenceable_param_group_ref: parse_param_group_refs(
            children_lookup,
            owner_rows,
            component_id,
        ),
        cv_param,
        user_param,
    }
}

fn parse_component_list<'a, P: MetadataPolicy>(
    children_lookup: &ChildrenLookup,
    owner_rows: &'a OwnerRows<'a>,
    instrument_id: u32,
    policy: &P,
    param_buffer: &mut Vec<&'a Metadatum>,
) -> Option<ComponentList> {
    let component_root_id = children_lookup
        .ids_for(instrument_id, TagId::ComponentList)
        .first()
        .copied()
        .unwrap_or(instrument_id);

    let source_ids = children_lookup.ids_for(component_root_id, TagId::ComponentSource);
    let analyzer_ids = children_lookup.ids_for(component_root_id, TagId::ComponentAnalyzer);
    let detector_ids = children_lookup.ids_for(component_root_id, TagId::ComponentDetector);

    if source_ids.is_empty() && analyzer_ids.is_empty() && detector_ids.is_empty() {
        return None;
    }

    let source: Vec<Source> = source_ids
        .iter()
        .map(|&id| {
            let ComponentData {
                order,
                referenceable_param_group_ref,
                cv_param,
                user_param,
            } = parse_component_data(children_lookup, owner_rows, id, policy, param_buffer);
            Source {
                order,
                referenceable_param_group_ref,
                cv_param,
                user_param,
            }
        })
        .collect();

    let analyzer: Vec<Analyzer> = analyzer_ids
        .iter()
        .map(|&id| {
            let ComponentData {
                order,
                referenceable_param_group_ref,
                cv_param,
                user_param,
            } = parse_component_data(children_lookup, owner_rows, id, policy, param_buffer);
            Analyzer {
                order,
                referenceable_param_group_ref,
                cv_param,
                user_param,
            }
        })
        .collect();

    let detector: Vec<Detector> = detector_ids
        .iter()
        .map(|&id| {
            let ComponentData {
                order,
                referenceable_param_group_ref,
                cv_param,
                user_param,
            } = parse_component_data(children_lookup, owner_rows, id, policy, param_buffer);
            Detector {
                order,
                referenceable_param_group_ref,
                cv_param,
                user_param,
            }
        })
        .collect();

    Some(ComponentList {
        count: Some(source.len() + analyzer.len() + detector.len()),
        source,
        analyzer,
        detector,
    })
}

fn parse_software_ref(
    children_lookup: &ChildrenLookup,
    owner_rows: &OwnerRows,
    instrument_id: u32,
) -> Option<InstrumentSoftwareRef> {
    children_lookup
        .ids_for(instrument_id, TagId::SoftwareRef)
        .first()
        .and_then(|&ref_id| {
            get_attr_text(owner_rows.get(ref_id), ACC_ATTR_REF)
                .map(|r| InstrumentSoftwareRef { r#ref: r })
        })
}

fn parse_param_group_refs(
    children_lookup: &ChildrenLookup,
    owner_rows: &OwnerRows,
    parent_id: u32,
) -> Vec<ReferenceableParamGroupRef> {
    children_lookup
        .ids_for(parent_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()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ion::decoder::decode::MetadatumValue;

    fn make_metadatum(id: u32, parent_id: u32, tag_id: TagId) -> Metadatum {
        Metadatum {
            item_index: 0,
            id,
            parent_id,
            tag_id,
            accession: None,
            unit_accession: None,
            value: MetadatumValue::Empty,
        }
    }

    #[test]
    fn parse_instrument_list_returns_none_when_no_instruments_in_metadata() {
        let metadata: Vec<Metadatum> = vec![make_metadatum(1, 0, TagId::SpectrumList)];
        let refs: Vec<&Metadatum> = metadata.iter().collect();
        let lookup = ChildrenLookup::new(&metadata);
        let policy = DefaultMetadataPolicy;
        assert!(parse_instrument_list(&refs, &lookup, &policy).is_none());
    }

    #[test]
    fn parse_component_list_returns_none_when_no_components_present() {
        let metadata: Vec<Metadatum> = vec![make_metadatum(1, 0, TagId::Instrument)];
        let mut owner_rows = OwnerRows::with_capacity(1);
        for m in &metadata {
            owner_rows.insert(m.id, m);
        }
        let lookup = ChildrenLookup::new(&metadata);
        let policy = DefaultMetadataPolicy;
        let mut buf = Vec::new();

        let result = parse_component_list(&lookup, &owner_rows, 1, &policy, &mut buf);
        assert!(result.is_none());
    }

    #[test]
    fn parse_component_data_reads_order_attribute() {
        use crate::ion::attr_meta::ACC_ATTR_ORDER;
        let order_row = Metadatum {
            item_index: 0,
            id: 2,
            parent_id: 1,
            tag_id: TagId::ComponentSource,
            accession: Some({
                use core::fmt::Write;
                let mut s = String::from("ATTR:");
                write!(&mut s, "{:07}", ACC_ATTR_ORDER.raw()).unwrap();
                s
            }),
            unit_accession: None,
            value: MetadatumValue::Number(3.0),
        };
        let metadata = vec![make_metadatum(2, 1, TagId::ComponentSource), order_row];
        let mut owner_rows = OwnerRows::with_capacity(2);
        for m in &metadata {
            owner_rows.insert(m.id, m);
        }
        let lookup = ChildrenLookup::new(&metadata);
        let policy = DefaultMetadataPolicy;
        let mut buf = Vec::new();

        let data = parse_component_data(&lookup, &owner_rows, 2, &policy, &mut buf);
        assert_eq!(data.order, Some(3));
    }

    #[test]
    fn component_list_counts_all_component_types() {
        let metadata = vec![
            make_metadatum(1, 0, TagId::Instrument),
            make_metadatum(2, 1, TagId::ComponentList),
            make_metadatum(3, 2, TagId::ComponentSource),
            make_metadatum(4, 2, TagId::ComponentAnalyzer),
            make_metadatum(5, 2, TagId::ComponentAnalyzer),
            make_metadatum(6, 2, TagId::ComponentDetector),
        ];
        let mut owner_rows = OwnerRows::with_capacity(6);
        for m in &metadata {
            owner_rows.insert(m.id, m);
        }
        let lookup = ChildrenLookup::new(&metadata);
        let policy = DefaultMetadataPolicy;
        let mut buf = Vec::new();

        let list = parse_component_list(&lookup, &owner_rows, 1, &policy, &mut buf).unwrap();
        assert_eq!(list.source.len(), 1);
        assert_eq!(list.analyzer.len(), 2);
        assert_eq!(list.detector.len(), 1);
        assert_eq!(list.count, Some(4));
    }

    use crate::ion::utilities::children_lookup::{ChildrenLookup, DefaultMetadataPolicy};
}