Struct SequenceRef 

pub struct SequenceRef<'a> { /* private fields */ }

One FASTA or FASTQ record, borrowed from the reader that produced it.

Valid only until the next record is read. Call SequenceRef::to_owned to keep one.

Identifiers are &[u8] rather than &str deliberately: validating UTF-8 is work this type exists to avoid, and sequence identifiers are ASCII in practice. SequenceRef::id_str converts when you need text, borrowing rather than allocating whenever the bytes are already valid UTF-8.

Implementations

impl<'a> SequenceRef<'a>

pub fn id(&self) -> &'a [u8]

The identifier: the header up to the first ASCII whitespace.

pub fn id_str(&self) -> Cow<'a, str>

The identifier as text, replacing anything that is not UTF-8.

Borrows when the bytes are already valid UTF-8, which is the normal case.

pub fn description(&self) -> Option<&'a [u8]>

Everything after the first whitespace in the header, if any.

pub fn description_str(&self) -> Option<Cow<'a, str>>

The description as text, replacing anything that is not UTF-8.

pub fn seq(&self) -> &'a [u8]

The residues, without line breaks.

pub fn quality(&self) -> Option<&'a [u8]>

The Phred quality characters, FASTQ only, always Phred+33.

pub fn len(&self) -> usize

Number of residues.

pub fn is_empty(&self) -> bool

True when the record has no residues.

pub fn has_quality(&self) -> bool

True when the record carries quality scores.

pub fn format(&self) -> Format

The format this record can be written as losslessly.

pub fn base_counts(&self) -> BaseCounts

Per-base counts.

pub fn gc_content(&self) -> Option<f64>

GC fraction over unambiguous bases, None when there are none.

pub fn mean_quality(&self) -> Option<f64>

Error-probability-weighted mean quality (Phred+33).

pub fn expected_errors(&self) -> Option<f64>

Expected number of sequencing errors in the read (Phred+33).

pub fn kmers(&self, k: usize) -> impl Iterator<Item = &'a [u8]>

Iterator over overlapping k-mers.

pub fn to_owned(&self) -> Sequence

Copy into an owned Sequence, for the records you want to keep.

pub fn write<W: Write>( &self, out: &mut W, format: Format, line_width: Option<usize>, ) -> Result<()>

Write this record out in format.

FASTA lines are wrapped at line_width; None writes one line.

Trait Implementations

impl<'a> Clone for SequenceRef<'a>

fn clone(&self) -> SequenceRef<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for SequenceRef<'a>

impl<'a> Debug for SequenceRef<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for SequenceRef<'a>

impl<'a> Hash for SequenceRef<'a>

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> PartialEq for SequenceRef<'a>

fn eq(&self, other: &SequenceRef<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<Sequence> for SequenceRef<'_>

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

Compare against an owned record, so tests can assert the two read paths agree without copying first.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for SequenceRef<'a>