Struct bio::pattern_matching::myers::MyersBuilder

pub struct MyersBuilder { /* private fields */ }

Builds a Myers instance, allowing to specify ambiguities.

Example:

This example shows how recognition of IUPAC ambiguities in patterns can be implemented:

use bio::pattern_matching::myers::MyersBuilder;

let ambigs = [
    (b'M', &b"AC"[..]),
    (b'R', &b"AG"[..]),
    (b'W', &b"AT"[..]),
    (b'S', &b"CG"[..]),
    (b'Y', &b"CT"[..]),
    (b'K', &b"GT"[..]),
    (b'V', &b"ACGMRS"[..]),
    (b'H', &b"ACTMWY"[..]),
    (b'D', &b"AGTRWK"[..]),
    (b'B', &b"CGTSYK"[..]),
    (b'N', &b"ACGTMRWSYKVHDB"[..]),
];

let mut builder = MyersBuilder::new();

for &(base, equivalents) in &ambigs {
    builder.ambig(base, equivalents);
}

let text = b"GGATGNGCGCCATAG";
let pattern = b"TRANCGG";
//                *   * (mismatch)

let myers = builder.build_64(pattern);
assert_eq!(myers.distance(text), 2);

Note that only ambiguities in the pattern are recognized. The reverse is not true; ambiguities in the search text are not matched by multiple symbols in the pattern. This would require specifying additional ambiguities (builder.ambig(b'A', b"MRWVHDN"), etc…).

Implementations

impl MyersBuilder

pub fn new() -> MyersBuilder

pub fn ambig<I, B>(&mut self, byte: u8, equivalents: I) -> &mut Self where
    I: IntoIterator<Item = B>,
    B: Borrow<u8>, 

Allows to specify ambiguous symbols and their equivalents. Note that the ambiguous symbol will always be matched by itself. Explicitly including it in the equivalents is not necessary.

Example:

use bio::pattern_matching::myers::MyersBuilder;

let text = b"GGATGAGCGCCATAG";
let pattern = b"TGAGCGN";

let myers = MyersBuilder::new()
    .ambig(b'N', b"ACGT")
    .build_64(pattern);

assert_eq!(myers.distance(text), 0);

pub fn text_wildcard(&mut self, wildcard: u8) -> &mut Self

Allows to specify a wildcard symbol, that upon appearance in the search text shall be matched by any symbol of the pattern. Multiple wildcards are possible. For the inverse, that is, wildcards in the pattern matching any symbol in search text, use ambig(byte, 0..255).

Example:

use bio::pattern_matching::myers::MyersBuilder;

let text = b"GGATGAGCG*CATAG";
let pattern = b"TGAGCGT";

let myers = MyersBuilder::new()
    .text_wildcard(b'*')
    .build_64(pattern);

assert_eq!(myers.distance(text), 0);

pub fn build_64<C, P>(&self, pattern: P) -> Myers<u64> where
    C: Borrow<u8>,
    P: IntoIterator<Item = C>,
    P::IntoIter: ExactSizeIterator, 

Creates a Myers instance given a pattern, using u64 as bit vector type. Pattern length is restricted to at most 64 symbols.

pub fn build<T, C, P>(&self, pattern: P) -> Myers<T> where
    T: BitVec,
    C: Borrow<u8>,
    P: IntoIterator<Item = C>,
    P::IntoIter: ExactSizeIterator, 

Creates a Myers instance given a pattern, using any desired type for bit vectors. Pattern length is restricted to the size of the bit vector T.

Example:

use bio::pattern_matching::myers::{MyersBuilder, Myers};

let myers: Myers<u32> = MyersBuilder::new()
    .text_wildcard(b'*')
    .build(b"TGAGCG*");
// ...

pub fn build_long_64<C, P>(&self, pattern: P) -> MyersLong<u64> where
    C: Borrow<u8>,
    P: IntoIterator<Item = C>,
    P::IntoIter: ExactSizeIterator, 

Creates a long::Myers instance given a pattern, using u64 as bit vector type. Pattern length is not restricted regardless of the type of the bit vector.

pub fn build_long<T, C, P>(&self, pattern: P) -> MyersLong<T> where
    T: BitVec,
    C: Borrow<u8>,
    P: IntoIterator<Item = C>,
    P::IntoIter: ExactSizeIterator, 

Creates a long::Myers instance given a pattern, using any desired type for bit vectors. Pattern length is not restricted regardless of the type of the bit vector.

Trait Implementations

impl Clone for MyersBuilder

fn clone(&self) -> MyersBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for MyersBuilder

fn default() -> MyersBuilder

Returns the “default value” for a type.

impl PartialEq<MyersBuilder> for MyersBuilder

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Eq for MyersBuilder

impl StructuralEq for MyersBuilder

impl StructuralPartialEq for MyersBuilder