lib_tsalign 1.0.1

A sequence-to-sequence aligner that accounts for template switches
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
122
123
124
125
126
127
128
129
130

use std::fmt::Display;

use iter::{
    CompactAlignmentIter, CompactAlignmentIterCloned, FlatAlignmentIter, FlatAlignmentIterCloned,
};

use super::IAlignmentType;

pub mod iter;
pub mod stream;
pub mod template_switch_specifics;

#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Alignment<AlignmentType> {
    alignment: Vec<(usize, AlignmentType)>,
}

impl<AlignmentType> Alignment<AlignmentType> {
    pub fn new() -> Self {
        Default::default()
    }

    pub fn push(&mut self, alignment_type: AlignmentType)
    where
        AlignmentType: Eq,
    {
        self.push_n(1, alignment_type);
    }

    pub fn push_n(&mut self, multiplicity: usize, alignment_type: AlignmentType)
    where
        AlignmentType: Eq,
    {
        if let Some((existing_multiplicity, last_alignment_type)) = self.alignment.last_mut() {
            if *last_alignment_type == alignment_type {
                *existing_multiplicity += multiplicity;
            } else {
                self.alignment.push((multiplicity, alignment_type));
            }
        } else {
            self.alignment.push((multiplicity, alignment_type));
        }
    }

    pub fn inner_mut(&mut self) -> &mut Vec<(usize, AlignmentType)> {
        &mut self.alignment
    }

    pub fn into_inner(self) -> Vec<(usize, AlignmentType)> {
        self.alignment
    }
}

impl<AlignmentType: IAlignmentType> Alignment<AlignmentType> {
    pub fn iter_compact(&self) -> CompactAlignmentIter<'_, AlignmentType> {
        CompactAlignmentIter::new(&self.alignment)
    }

    pub fn iter_compact_cloned(&self) -> CompactAlignmentIterCloned<'_, AlignmentType>
    where
        AlignmentType: Clone,
    {
        CompactAlignmentIterCloned::new(&self.alignment)
    }

    pub fn iter_flat(&self) -> FlatAlignmentIter<'_, AlignmentType> {
        FlatAlignmentIter::new(&self.alignment)
    }

    pub fn iter_flat_cloned(&self) -> FlatAlignmentIterCloned<'_, AlignmentType>
    where
        AlignmentType: Clone,
    {
        FlatAlignmentIterCloned::new(&self.alignment)
    }

    pub fn cigar(&self) -> String
    where
        AlignmentType: Display,
    {
        let mut result = String::new();
        self.write_cigar(&mut result).unwrap();
        result
    }

    pub fn write_cigar(&self, writer: &mut impl std::fmt::Write) -> std::fmt::Result
    where
        AlignmentType: Display,
    {
        for (amount, alignment_type) in &self.alignment {
            if alignment_type.is_repeatable() {
                write!(writer, "{amount}{alignment_type}")?;
            } else {
                write!(writer, "{alignment_type}")?;
            }
        }

        Ok(())
    }

    pub fn reverse(&self) -> Self
    where
        AlignmentType: Clone,
    {
        Self {
            alignment: self.alignment.iter().cloned().rev().collect(),
        }
    }
}

impl<AlignmentType> From<Vec<(usize, AlignmentType)>> for Alignment<AlignmentType> {
    fn from(value: Vec<(usize, AlignmentType)>) -> Self {
        Self { alignment: value }
    }
}

impl<AlignmentType: IAlignmentType + Display> Display for Alignment<AlignmentType> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.write_cigar(f)
    }
}

impl<AlignmentType> Default for Alignment<AlignmentType> {
    fn default() -> Self {
        Self {
            alignment: Default::default(),
        }
    }
}