Struct AlignedRead 

pub struct AlignedRead {
    pub chr_id: usize,
    pub strand: Strand,
    pub ref_start0: u32,
    pub seq: Vec<u8>,
    pub qual: Option<Vec<u8>>,
    pub ops: Vec<ReadOp>,
    /* private fields */
}

BAM-independent aligned read.

Fields

chr_id: usize

strand: Strand

ref_start0: u32

seq: Vec<u8>

qual: Option<Vec<u8>>

ops: Vec<ReadOp>

Implementations

impl AlignedRead

pub fn new( chr_id: usize, strand: Strand, ref_start0: u32, seq: Vec<u8>, qual: Option<Vec<u8>>, ops_input: Vec<(ReadOpKind, u32)>, ) -> Self

Create a new aligned read from raw pieces.

ops_input contains only (ReadOpKind, len). This constructor walks the operations and fills reference/read coordinates.

pub fn build_positioned_ops( ref_start0: u32, ops_input: &[(ReadOpKind, u32)], ) -> Vec<ReadOp>

Build positioned operations from plain operation/length pairs.

pub fn from_record(record: &Record, chr_id: usize) -> Self

Build an AlignedRead from a BAM record.

chr_id must already be mapped into the same chromosome id space used by SnpIndex.

pub fn ref_blocks(&self) -> Vec<RefBlock>

Convert aligned read bases into genomic reference blocks.

Only operations that contain aligned read bases are emitted: Match, Equal, and Diff.

Deletions and reference skips consume reference coordinates but do not produce read-supported blocks.

pub fn cigar_op_to_read_op(op: Cigar) -> (ReadOpKind, u32)

Convert one BAM CIGAR op into a ReadOpKind.

pub fn finalize(&mut self) -> Result<(), String>

Validate the read and mark it finalized.

Later refinement steps can also call this after changing operations.

pub fn is_finalized(&self) -> bool

Return whether this read has been finalized.

pub fn validate(&self) -> Result<(), String>

Validate sequence, quality, and operation consistency.

pub fn read_len_from_ops(&self) -> u32

Return read length implied by operations.

pub fn ref_span(&self) -> Option<(u32, u32)>

Return full reference span [start0, end0).

pub fn base_at_ref_pos(&self, pos0: u32) -> Option<ObservedBase>

Return observed base at reference position pos0.

Returns None for deletions, ref-skips, insertions, clips, pads, and positions outside the alignment.

pub fn replace_ops(&mut self, ops_input: Vec<(ReadOpKind, u32)>)

Replace operations from plain operation/length pairs.

This is useful for refinement modules that rewrite CIGAR-like structure.

pub fn op_pairs(&self) -> Vec<(ReadOpKind, u32)>

Return operations as plain (kind, len) pairs.

pub fn uppercase_seq(seq: Vec<u8>) -> Vec<u8>

Uppercase sequence bases.

impl AlignedRead

pub fn refine_against_genome(&mut self, genome: &Genome, options: RefineOptions)

Refine this read against a reference genome.

This is the safe production refinement entry point.

pub fn refine_against_genome_default(&mut self, genome: &Genome)

Convenience wrapper using default options.

pub fn absorb_diff_before_refskip_against_genome( &self, pairs: &[(ReadOpKind, u32)], genome: &Genome, options: RefineOptions, ) -> Vec<(ReadOpKind, u32)>

Absorb M X N M into M N M only if the X base matches the first reference base after the skipped region.

pub fn absorb_diff_after_refskip_against_genome( &self, pairs: &[(ReadOpKind, u32)], genome: &Genome, options: RefineOptions, ) -> Vec<(ReadOpKind, u32)>

Absorb M N X M into M N M only if the X base matches the last reference base before the skipped region.

pub fn diff_matches_reference_at_target( &self, genome: &Genome, diff_op: &ReadOp, target_ref_start0: u32, ) -> bool

Check whether every read base in a Diff operation matches the reference at the proposed corrected target position.

pub fn merge_adjacent_op_pairs( pairs: &[(ReadOpKind, u32)], ) -> Vec<(ReadOpKind, u32)>

pub fn is_aligned_kind(kind: ReadOpKind) -> bool

Trait Implementations

impl Clone for AlignedRead

fn clone(&self) -> AlignedRead

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlignedRead

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

Formats the value using the given formatter.

impl PartialEq for AlignedRead

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

impl StructuralPartialEq for AlignedRead