Struct Sequence 

pub struct Sequence {
    pub id: String,
    pub description: Option<String>,
    pub seq: Vec<u8>,
    pub quality: Option<Vec<u8>>,
}

One FASTA or FASTQ record.

A record with quality == None is a FASTA record; a record with quality is a FASTQ record whose quality string always has the same length as seq.

Fields are public so that pipelines can build records without ceremony, but the constructors and Sequence::validate exist to keep the length invariant intact.

use fastx::Sequence;

let read = Sequence::fastq("read1", b"ACGT", b"IIII")?;
assert_eq!(read.len(), 4);
assert_eq!(read.mean_quality(), Some(40.0));

Fields

id: String

Identifier: the header up to the first whitespace, without >/@.

description: Option<String>

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

seq: Vec<u8>

Residues as ASCII bytes, without line breaks.

quality: Option<Vec<u8>>

Phred quality characters (not scores), FASTQ only.

Implementations

impl Sequence

pub fn fasta<I: Into<String>>(id: I, seq: impl Into<Vec<u8>>) -> Sequence

A FASTA record.

pub fn fastq<I: Into<String>>( id: I, seq: impl Into<Vec<u8>>, quality: impl Into<Vec<u8>>, ) -> Result<Sequence>

A FASTQ record. Fails if sequence and quality lengths differ.

pub fn with_description<D: Into<String>>(self, description: D) -> Sequence

Builder-style setter for the description.

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 header(&self) -> String

The header line without its leading >/@.

let s = Sequence::fasta("chr1", b"ACGT".to_vec()).with_description("human chromosome 1");
assert_eq!(s.header(), "chr1 human chromosome 1");

pub fn seq_str(&self) -> Result<&str>

The residues as &str, if they are valid UTF-8 (ASCII in practice).

pub fn clear(&mut self)

Reset the record to an empty state while keeping its allocations.

This is what makes crate::FastxReader::read_into allocation-free.

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 ambiguous_count(&self) -> u64

Number of N/ambiguity bases.

pub fn reverse_complement(&self) -> Sequence

Reverse complement, reversing the quality string as well.

let read = Sequence::fastq("r", b"ACGT", b"ABCD")?.reverse_complement();
assert_eq!(read.seq, b"ACGT");
assert_eq!(read.quality.unwrap(), b"DCBA");

pub fn reverse_complement_in_place(&mut self)

Reverse complement in place.

pub fn make_uppercase(&mut self)

Uppercase the residues in place (undoes soft masking).

pub fn subseq(&self, range: Range<usize>) -> Result<Sequence>

A sub-record covering range, carrying the matching quality slice.

Returns Error::OutOfBounds if the range does not fit.

pub fn trim_to(&mut self, range: Range<usize>) -> Result<()>

Keep only range, discarding the rest, in place.

pub fn translate(&self, frame: usize, stop_at_stop: bool) -> Sequence

Translate the residues into protein using the standard genetic code.

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

Iterator over overlapping k-mers.

pub fn quality_scores(&self) -> Option<Vec<u8>>

Decoded Phred scores assuming the Phred+33 offset.

pub fn quality_scores_with(&self, offset: u8) -> Option<Vec<u8>>

Decoded Phred scores for an explicit offset.

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 convert_quality_offset(&mut self, from: u8, to: u8)

Convert Phred+64 quality to Phred+33 in place. No-op for FASTA records.

pub fn into_fasta(self) -> Sequence

Drop the quality string, turning a FASTQ record into a FASTA record.

pub fn validate(&self, alphabet: Alphabet) -> Result<()>

Check the invariants that the writers rely on.

• the id is non-empty and free of whitespace/newlines
• the description contains no newlines
• residues are printable and non-whitespace, and in alphabet
• quality, when present, has the same length as the sequence and is printable ASCII

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

Write this record as FASTA, wrapping sequence lines at line_width (None writes the sequence on a single line).

Fails with Error::InvalidByte if the sequence contains a byte FASTA cannot represent: \n, \r or >. None of the three survives a write/read cycle once line wrapping can move it, so writing one would silently corrupt the record.

pub fn write_fastq<W: Write>(&self, out: &mut W) -> Result<()>

Write this record as FASTQ. Fails when the record has no quality, when the lengths disagree, or when a byte cannot be represented.

pub fn to_string_in(&self, format: Format) -> Result<String>

Render the record in its native format as a String.

Trait Implementations

impl Clone for Sequence

fn clone(&self) -> Sequence

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sequence

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

Formats the value using the given formatter.

impl Default for Sequence

fn default() -> Sequence

Returns the “default value” for a type.

impl Display for Sequence

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

FASTA with 60-column wrapping, or FASTQ when quality is present.

impl Eq for Sequence

impl Hash for Sequence

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 Sequence

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