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

use super::{cigar_ext::Cigar, cigar_ext::CigarIter, seq_ext::SequenceIter, Alignment, Nucleotide};

pub struct MapIter<'a> {
    ref_pos: usize,
    cur_cigar: Option<Cigar>,
    seq_it: SequenceIter<'a>,
    cigar_it: CigarIter<'a>,
}

impl<'a> Alignment<'a> {
    pub fn map_iter<'b>(&'b self) -> MapIter<'b> {
        let mut ret = MapIter {
            ref_pos: self.ref_begin(),
            seq_it: self.sequence().into_iter(),
            cigar_it: self.cigar(),
            cur_cigar: None,
        };
        ret.cur_cigar = ret.cigar_it.next();
        return ret;
    }
}

#[derive(Debug)]
pub struct Mapping {
    ref_base: Option<usize>,
    seq_base: Option<Nucleotide>,
}

impl<'a> Iterator for MapIter<'a> {
    type Item = Mapping;
    fn next(&mut self) -> Option<Mapping> {
        let mut ret = None;
        if let Some(ref mut cur_cigar) = self.cur_cigar {
            let mut map = Mapping {
                ref_base: None,
                seq_base: None,
            };

            if cur_cigar.in_reference() {
                map.ref_base = Some(self.ref_pos);
                self.ref_pos += 1;
            }

            if cur_cigar.in_alignment() {
                map.seq_base = self.seq_it.next();
            }

            cur_cigar.len -= 1;
            ret = Some(map);
        }

        if ret.is_some() {
            if self.cur_cigar.as_ref().unwrap().len == 0 {
                self.cur_cigar = self.cigar_it.next();
            }
        }

        ret
    }
}