Struct AlleleVariant 

pub struct AlleleVariant<T> {
    pub allele_one: Allele<T>,
    pub allele_two: Option<Allele<T>>,
    pub phase: Option<AllelePhase>,
    pub alleles_unphased: Vec<Allele<T>>,
}

Allele container holding an initial allele, an optional second established allele, and any later unphased alleles.

Examples

use tinyhgvs::{AllelePhase, VariantDescription, parse_hgvs};

let variant = parse_hgvs("NM_004006.2:c.[2376G>C];[2376=]").unwrap();

match variant.description {
    VariantDescription::NucleotideAllele(allele) => {
        assert_eq!(allele.allele_one.variants.len(), 1);
        assert!(allele.allele_two.is_some());
        assert_eq!(allele.phase, Some(AllelePhase::Trans));
        assert_eq!(allele.iter().count(), 2);
    }
    _ => unreachable!("expected nucleotide allele"),
}

Fields

allele_one: Allele<T>

allele_two: Option<Allele<T>>

phase: Option<AllelePhase>

alleles_unphased: Vec<Allele<T>>

Implementations

impl<T> AlleleVariant<T>

pub fn iter(&self) -> impl Iterator<Item = &Allele<T>>

Returns all written alleles in order.

pub fn phased_alleles(&self) -> Option<(&Allele<T>, &Allele<T>)>

Returns the established trans allele pair when the relation is known.

pub fn unphased_alleles(&self) -> &[Allele<T>]

Returns any later alleles written in uncertain relation to the established allele state.

Trait Implementations

impl<T: Clone> Clone for AlleleVariant<T>

fn clone(&self) -> AlleleVariant<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AlleleVariant<T>

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

Formats the value using the given formatter.

impl<'a, T> IntoIterator for &'a AlleleVariant<T>

type Item = &'a Allele<T>

The type of the elements being iterated over.

type IntoIter = Chain<Chain<Once<&'a Allele<T>>, Iter<'a, Allele<T>>>, Iter<'a, Allele<T>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for AlleleVariant<T>

fn eq(&self, other: &AlleleVariant<T>) -> 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<T: Eq> Eq for AlleleVariant<T>

impl<T> StructuralPartialEq for AlleleVariant<T>