mzcore 0.1.0

Core logic for handling massspectrometry in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Code to handle the Custom ontology
use context_error::{BoxedError, Context, CreateError, FullErrorContent};

use mzcv::{CVError, CVFile, CVSource, CVVersion, HashBufReader};

use crate::{
    parse_json::ParseJson,
    sequence::{SimpleModification, SimpleModificationInner},
};

/// The shared type for contact between the build and compile steps
pub type CustomDatabase = Vec<(Option<usize>, String, SimpleModification)>;

/// Custom modifications
///
/// These can be used to handle `C:modification` and `Custom:0001` modifications in ProForma
/// definitions. As these are custom made by the user there is no way of automatically updating
/// from the internet. To parse these files the `custom_modifications.json` file is parsed with
/// [`CustomDatabase::from_json_value`] which generates the modifications.
///
/// To update the modifications use [`mzcv::CVIndex::update`] or [`mzcv::CVIndex::update_from_path`].
/// Both automatically write the cache and the original JSON file.
#[allow(missing_copy_implementations, missing_debug_implementations)]
pub struct Custom {}

impl CVSource for Custom {
    const AUTOMATICALLY_WRITE_UNCOMPRESSED: bool = true;

    type Data = SimpleModificationInner;
    type Structure = Vec<SimpleModification>;

    fn cv_name() -> &'static str {
        "CUSTOM"
    }

    fn files() -> &'static [CVFile] {
        &[CVFile {
            name: "custom_modifications",
            extension: "json",
            url: None,
            compression: mzcv::CVCompression::None,
        }]
    }

    fn static_data() -> Option<(CVVersion, Self::Structure)> {
        None
    }

    fn parse(
        mut reader: impl Iterator<Item = HashBufReader<Box<dyn std::io::Read>, impl sha2::Digest>>,
    ) -> Result<(CVVersion, Self::Structure), Vec<BoxedError<'static, CVError>>> {
        let mut reader = reader.next().unwrap();

        let json: serde_json::Value = serde_json::de::from_reader(&mut reader).map_err(|err| {
            vec![BoxedError::new(
                CVError::FileCouldNotBeParsed,
                "Could not parse custom modifications file",
                err.to_string(),
                Context::default(),
            )]
        })?;

        let db = CustomDatabase::from_json_value(json)
            .map_err(|err| vec![err.convert(|_| CVError::FileCouldNotBeParsed)])?;

        Ok((
            CVVersion {
                hash: reader.hash(),
                last_updated: None,
                version: None,
            },
            db.into_iter().map(|(_, _, s)| s).collect(),
        ))
    }

    fn write_uncompressed<W: std::io::Write>(
        writer: W,
        _version: &CVVersion,
        data: impl Iterator<Item = std::sync::Arc<Self::Data>>,
    ) -> Result<(), BoxedError<'static, CVError>> {
        let value = data
            .map(|m| {
                (
                    m.description()
                        .and_then(crate::sequence::ModificationId::id),
                    m.description()
                        .map_or_else(|| "UNNAMED".to_string(), |i| i.name.to_string()),
                    m,
                )
            })
            .collect::<Vec<_>>();
        serde_json::to_writer_pretty(writer, &value).map_err(|e| {
            BoxedError::new(
                CVError::FileCouldNotBeMade,
                "Could not save custom modifications file",
                e.to_string(),
                Context::default(),
            )
        })
    }
}