sigalign-core 0.2.1

A core crate for sigalign
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

use crate::results::QueryAlignment;
use crate::reference::{
    Reference, PatternIndex, SequenceStorage,
};
use crate::algorithm::local_alignment_algorithm_with_limit;
use super::{
    AlignmentRegulator,
    LocalWorkspace,
    LocalAligner,
};

#[derive(Clone)]
pub struct LocalWithLimitAligner {
    pub(super) regulator: AlignmentRegulator,
    pub(super) workspace: LocalWorkspace,
    pub(super) limit: u32,
}

impl LocalWithLimitAligner {
    /// Create a new Aligner
    pub fn new(regulator: AlignmentRegulator, limit: u32) -> Self {
        let aligner = LocalAligner::new(regulator);
        aligner.to_limited(limit)
    }
    /// Low-level alignment function
    #[inline]
    pub fn align<I: PatternIndex, S: SequenceStorage> (
        &mut self,
        // Query
        query: &[u8],
        // Targets
        reference: &Reference<I, S>,
        sequence_buffer: &mut S::Buffer,
        sorted_target_indices: &[u32],
    ) -> QueryAlignment {
        // Initialization
        self.workspace.allocate_more_space_if_needed(
            query.len() as u32,
            &self.regulator,
        );
        
        // Perform alignment
        let mut result = local_alignment_algorithm_with_limit(
            reference,
            sequence_buffer,
            query,
            sorted_target_indices,
            self.regulator.pattern_size,
            &self.regulator.penalties,
            &self.regulator.cutoff,
            &mut self.workspace.spare_penalty_calculator,
            &mut self.workspace.wave_front_buffer_1.as_mut(),
            &mut self.workspace.wave_front_buffer_2.as_mut(),
            &mut self.workspace.left_vpc_buffer,
            &mut self.workspace.right_vpc_buffer,
            &mut self.workspace.traversed_anchors_buffer,
            &mut self.workspace.operations_buffer,
            self.limit,
        );
        self.regulator.decompress_result_with_gcd(&mut result);
        result
    }
    pub fn limit(&self) -> u32 {
        self.limit
    }
    pub fn set_limit(&mut self, limit: u32) {
        self.limit = limit;
    }
    pub fn regulator(&self) -> &AlignmentRegulator {
        &self.regulator
    }
}