mzalign 0.2.0

Align peptidoforms while with mass-based alignment.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use serde::{Deserialize, Serialize};

use super::scoring::MatchType;

/// A piece in an alignment, determining what step was taken in the alignment and how this impacted
/// the score
#[derive(
    Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default, Serialize, Deserialize,
)]
pub struct Piece {
    /// The total score of the path up till now
    pub score: isize,
    /// The local contribution to the score of this piece
    pub local_score: isize,
    /// The type of the match
    pub match_type: MatchType,
    /// The number of steps on the first sequence
    pub step_a: u16,
    /// The number of steps on the second sequence
    pub step_b: u16,
}

impl Piece {
    /// Create a new alignment piece
    pub const fn new(
        score: isize,
        local_score: isize,
        match_type: MatchType,
        step_a: u16,
        step_b: u16,
    ) -> Self {
        Self {
            score,
            local_score,
            match_type,
            step_a,
            step_b,
        }
    }

    /// Create a CIGAR like string from a path
    pub(crate) fn cigar(path: &[Self], start_a: usize, start_b: usize) -> String {
        #[derive(Eq, PartialEq)]
        enum StepType {
            Insertion,
            Deletion,
            Match,
            Mismatch,
            Massmismatch,
            Rotation(u16),
            IsobaricIdentical(u16),
            Isobaric(u16, u16),
        }

        impl std::fmt::Display for StepType {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "{}", match self {
                    Self::Insertion => String::from("I"),
                    Self::Deletion => String::from("D"),
                    Self::Match => String::from("="),
                    Self::Mismatch => String::from("X"),
                    Self::Massmismatch => String::from("m"),
                    Self::Rotation(a) => format!("{a}r"),
                    Self::IsobaricIdentical(a) => format!("{a}i"),
                    Self::Isobaric(a, b) => format!("{a}:{b}i"),
                })
            }
        }

        let (_, _, output, last) = path.iter().fold(
            (start_a, start_b, String::new(), None),
            |(a, b, output, last), step| {
                let current_type = match (step.match_type, step.step_a, step.step_b) {
                    (MatchType::Isobaric, a, b) => {
                        if a == b {
                            StepType::IsobaricIdentical(a)
                        } else {
                            StepType::Isobaric(a, b)
                        }
                    }
                    (_, 0, 1) => StepType::Insertion,
                    (_, 1, 0) => StepType::Deletion,
                    (MatchType::IdentityMassMismatch, 1, 1) => StepType::Massmismatch,
                    (MatchType::FullIdentity, 1, 1) => StepType::Match,
                    (MatchType::Mismatch, 1, 1) => StepType::Mismatch,
                    (MatchType::Rotation, a, _) => StepType::Rotation(a),
                    _ => unreachable!("Invalid step types while creating CIGAR"),
                };
                let (str, last) = match last {
                    Some((
                        t @ (StepType::Rotation(..)
                        | StepType::Isobaric(..)
                        | StepType::IsobaricIdentical(..)),
                        _,
                    )) => (format!("{output}{t}"), Some((current_type, 1))),
                    Some((t, n)) if t == current_type => (output, Some((t, n + 1))),
                    Some((t, n)) => (format!("{output}{n}{t}"), Some((current_type, 1))),
                    None => (output, Some((current_type, 1))),
                };
                (
                    a + step.step_a as usize,
                    b + step.step_b as usize,
                    str,
                    last,
                )
            },
        );
        match last {
            Some((
                t @ (StepType::Rotation(..)
                | StepType::Isobaric(..)
                | StepType::IsobaricIdentical(..)),
                _,
            )) => {
                format!("{output}{t}")
            }
            Some((t, n)) => format!("{output}{n}{t}"),
            _ => output,
        }
    }
}