Struct Alignment 

pub struct Alignment<A, B> { /* private fields */ }

An alignment of two reads. It has either a reference to the two sequences to prevent overzealous use of memory, or if needed use Self::to_owned to get a variant that clones the sequences and so can be used in more places.

Implementations

impl<A: Clone, B: Clone> Alignment<Cow<'_, A>, Cow<'_, B>>

pub fn to_owned(&self) -> Self

Clone the referenced sequences to make an alignment that owns the sequences. This can be necessary in some context where the references cannot be guaranteed to stay as long as you need the alignment.

impl<'lifetime, A, B> Alignment<&'lifetime A, &'lifetime B>

where A: HasPeptidoform<SimpleLinear>, B: HasPeptidoform<SimpleLinear>,

pub fn create_from_path( seq_a: &'lifetime A, seq_b: &'lifetime B, start_a: usize, start_b: usize, path: &str, scoring: AlignScoring<'_>, align_type: AlignType, maximal_step: u16, ) -> Option<Self>

Recreate an alignment from a path, the path is Self::short.

impl<A, B> Alignment<A, B>

pub const fn seq_a(&self) -> &A

The first sequence

pub const fn seq_b(&self) -> &B

The second sequence

pub const fn normalised_score(&self) -> f64

The normalised score, normalised for the alignment length and for the used alphabet. The normalisation is calculated as follows absolute_score / max_score.

pub const fn score(&self) -> Score

All three scores for this alignment.

pub fn path(&self) -> &[Piece]

The path or steps taken for the alignment

pub const fn start(&self) -> (usize, usize)

The position in the sequences where the alignment starts (a, b)

pub const fn start_a(&self) -> usize

The position in the first sequence where the alignment starts

pub const fn start_b(&self) -> usize

The position in the second sequence where the alignment starts

pub const fn align_type(&self) -> AlignType

The alignment type

pub const fn max_step(&self) -> u16

The maximal step size (the const generic STEPS)

pub fn len_a(&self) -> usize

The total number of residues matched on the first sequence

pub fn len_b(&self) -> usize

The total number of residues matched on the second sequence

pub fn stats(&self) -> Stats

Returns statistics for this match.

impl<A: HasPeptidoform<Linear>, B: HasPeptidoform<Linear>> Alignment<A, B>

pub fn mass_a(&self) -> Multi<MolecularFormula>

The mass(es) for the matched portion of the first sequence TODO: this assumes no terminal mods

pub fn mass_b(&self) -> Multi<MolecularFormula>

The mass(es) for the matched portion of the second sequence

pub fn mass_difference(&self) -> Mass

Get the mass delta for this match, if it is a (partial) local match it will only take the matched amino acids into account. If there are multiple possible masses for any of the stretches it returns the smallest difference.

pub fn ppm(&self) -> Ratio

Get the error in ppm for this match, if it is a (partial) local match it will only take the matched amino acids into account. If there are multiple possible masses for any of the stretches it returns the smallest difference.

pub fn short(&self) -> String

Get a short representation of the alignment in CIGAR like format. It has three additional classes {a}(:{b})?(r|i) and {a}m denoting any special step with the given a and b step size, if b is not given it is the same as a. r is rotation, i is isobaric, and m is identity but mass mismatch (modification).

Trait Implementations

impl<A: Clone, B: Clone> Clone for Alignment<A, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for Alignment<A, B>

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

Formats the value using the given formatter.

impl<'de, A, B> Deserialize<'de> for Alignment<A, B>

where A: Deserialize<'de>, B: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Hash, B: Hash> Hash for Alignment<A, B>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: Eq, B: Eq> Ord for Alignment<A, B>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<A: PartialEq, B: PartialEq> PartialEq for Alignment<A, B>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Eq, B: Eq> PartialOrd for Alignment<A, B>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A, B> Serialize for Alignment<A, B>

where A: Serialize, B: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: PartialEq + Eq, B: PartialEq + Eq> Eq for Alignment<A, B>