seal 0.1.6

Implementation of Needleman-Wunsch & Smith-Waterman sequence 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

use std::iter::Peekable;

use crate::pair::run::Run;
use crate::pair::step::Step;
use crate::pair::steps::Steps;

pub struct Runs<'a> {
    inner: Peekable<Steps<'a>>,
}

impl<'a> Runs<'a> {
    pub fn new(inner: Peekable<Steps<'a>>) -> Self {
        Runs { inner }
    }
}

impl<'a> Iterator for Runs<'a> {
    type Item = Run;

    fn next(&mut self) -> Option<Run> {
        let inner = &mut self.inner;
        let run = inner.peek().map(|step| step.to_run());
        run.map(|mut run| {
            let mask = run.mask();
            let mut peekable = inner.peekable();
            let mut cautious_take_while = || {
                let is_match = match peekable.peek() {
                    Some(step) => step.mask() == mask,
                    None => false,
                };
                if is_match {
                    peekable.next()
                } else {
                    None
                }
            };
            while let Some(step) = cautious_take_while() {
                run = match (run, step) {
                    (
                        Run::Align { x: run_x, y: run_y },
                        Step::Align {
                            x: step_x,
                            y: step_y,
                        },
                    ) => Run::Align {
                        x: (run_x.start)..(step_x + 1),
                        y: (run_y.start)..(step_y + 1),
                    },
                    (Run::Delete { x: run_x }, Step::Delete { x: step_x }) => Run::Delete {
                        x: (run_x.start)..(step_x + 1),
                    },
                    (Run::Insert { y: run_y }, Step::Insert { y: step_y }) => Run::Insert {
                        y: (run_y.start)..(step_y + 1),
                    },
                    _ => unreachable!(),
                }
            }
            run
        })
    }
}