Enum ReadState 

#[non_exhaustive]
pub enum ReadState {
    PrimaryFwd,
    PrimaryRev,
    SecondaryFwd,
    SecondaryRev,
    SupplementaryFwd,
    SupplementaryRev,
    Unmapped,
}

Alignment state of a read; seven possibilities + one unknown state

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

PrimaryFwd

Primary alignment to the reference strand

PrimaryRev

Primary alignment opposite the reference strand

SecondaryFwd

Secondary alignment to the reference strand

SecondaryRev

Secondary alignment opposite the reference strand

SupplementaryFwd

Supplementary alignment to the reference strand

SupplementaryRev

Supplementary alignment opposite the reference strand

Unmapped

Marked as unmapped in the BAM file. We are assuming that unmapped sequences will not be stored as reversed complements, as what would be the point of that?

Implementations

impl ReadState

pub fn is_unmapped(&self) -> bool

Checks if the state is unmapped

pub fn strand(&self) -> char

Gets the strand corresponding to the alignment type

• ‘.’ if unmapped
• ‘+’ if forward
• ‘-’ if reverse

Trait Implementations

impl Clone for ReadState

fn clone(&self) -> ReadState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReadState

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

Formats the value using the given formatter.

impl Default for ReadState

fn default() -> ReadState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ReadState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ReadState

Implements printing of read state

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

Formats the value using the given formatter.

impl Distribution<ReadState> for StandardUniform

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> ReadState

Allows us to randomly pick a variant

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl From<ReadState> for u16

fn from(value: ReadState) -> u16

converts our internal representation to the BAM flag format

impl FromStr for ReadState

Implements from string for ReadState

use nanalogue_core::ReadState;
use std::str::FromStr;

// Primary alignments
let state = ReadState::from_str("primary_forward")?;
assert_eq!(state, ReadState::PrimaryFwd);

// Secondary alignments
let state = ReadState::from_str("secondary_reverse")?;
assert_eq!(state, ReadState::SecondaryRev);

// Supplementary alignments
let state = ReadState::from_str("supplementary_forward")?;
assert_eq!(state, ReadState::SupplementaryFwd);

// Unmapped reads
let state = ReadState::from_str("unmapped")?;
assert_eq!(state, ReadState::Unmapped);

// Invalid string should error
let state = ReadState::from_str("invalid_state")?;

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for ReadState

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 PartialEq for ReadState

fn eq(&self, other: &ReadState) -> 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 Serialize for ReadState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<u16> for ReadState

fn try_from(value: u16) -> Result<ReadState, Error>

converts BAM flag format to our internal representation

type Error = Error

The type returned in the event of a conversion error.

impl Copy for ReadState

impl Eq for ReadState

impl StructuralPartialEq for ReadState