Struct AlignAlgorithm 

pub struct AlignAlgorithm {
    pub name: String,
    pub gap_open: i32,
    pub gap_extend: i32,
    pub mismatch_score: i32,
    pub match_score: i32,
    pub mode: AlignMode,
    pub backend: AlignBackend,
}

Contains parameters to run the alignment algorithm with

Fields

name: String

A name for displaying the algorithm in settings etc.

gap_open: i32

The penalty for opening a gap (negative)

gap_extend: i32

The penalty for extending a gap by one character (negative)

mismatch_score: i32

The penalty for a mismatch (negative)

match_score: i32

The score for a match (non-negative)

mode: AlignMode

Whether to align globally, semiglobally or blockwise

backend: AlignBackend

The backend used for alignment

Implementations

impl AlignAlgorithm

pub fn check_parameters(&self, filesizes: [usize; 2]) -> CheckStatus

Checks whether aligning the files could use a lot of memory whether the backend is available, and whether the parameters are valid. The filesizes are the sizes of the two files to be aligned, or zero if they are not known.

pub fn default_semiglobal() -> Self

The normal default() implementation gives the default global algorithm. This one gives the default semiglobal algorithm.

pub fn align_whole<FileContent: AsRef<[u8]>>( &self, files: [Arc<FileContent>; 2], ) -> Vec<AlignElement>

Aligns x to y as a whole, starting at address 0 in both files.

pub fn start_align<FileContent: AsRef<[u8]> + Send + Sync + 'static>( &self, files: [Arc<FileContent>; 2], addr: [usize; 2], sender: impl FnMut(AlignedMessage) -> bool + Clone + Send + 'static, )

This function starts the threads for the alignment, which send the data over the sender. It should then immediately return. Cannot be used for semiglobal alignment. sender should return false if the alignment should be stopped.

pub fn align_initial_block<FileContent: AsRef<[u8]> + Send + Sync>( &self, files: [Arc<FileContent>; 2], addresses: [usize; 2], sender: impl FnMut(AlignedMessage) -> bool + Clone + Send, )

Aligns the initial block centered around the given addresses, then aligns the rest of the files in both directions.

sender should return false if the alignment should be stopped.

pub fn align_end( &self, files: [&[u8]; 2], start_addresses: [usize; 2], sender: impl FnMut(AlignedMessage) -> bool, )

Blockwise alignment in the ascending address direction.

pub fn align_front( &self, files: [&[u8]; 2], end_addresses: [usize; 2], sender: impl FnMut(AlignedMessage) -> bool, )

Blockwise alignment in the descending address direction.

Trait Implementations

impl Clone for AlignAlgorithm

fn clone(&self) -> AlignAlgorithm

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AlignAlgorithm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AlignAlgorithm

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AlignAlgorithm

where AlignAlgorithm: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AlignAlgorithm

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.