Struct needletail::parser::SequenceRecord

pub struct SequenceRecord<'a> { /* fields omitted */ }

A FASTA or FASTQ record

Implementations

impl<'a> SequenceRecord<'a>

pub fn format(&self) -> Format

Returns the format of the record

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

Returns the id of the record

pub fn raw_seq(&self) -> &[u8]

Returns the raw sequence of the record. Only matters for FASTA since it can contain newlines.

pub fn seq(&self) -> Cow<[u8]>

Returns the cleaned up sequence of the record. For FASTQ it is the same as raw_seq but for FASTA it is raw_seq minus all the \r\n

pub fn qual(&self) -> Option<&[u8]>

Returns the quality line if there is one. Always None for FASTA and Some for FASTQ, even if the quality line is empty.

pub fn all(&self) -> &[u8]

Returns the full sequence, including line endings. This doesn't include a trailing newline.

pub fn num_bases(&self) -> usize

Return the number of bases in the sequence, computed efficiently.

pub fn start_line_number(&self) -> u64

Return the line number in the file of the start of the sequence

pub fn line_ending(&self) -> LineEnding

Which line ending is this record using?

pub fn write(
    &self,
    writer: &mut dyn Write,
    forced_line_ending: Option<LineEnding>
) -> Result<(), ParseError>

Write record back to a Write instance. By default it will use the original line ending but you can force it to use another one.

Trait Implementations

impl<'a> Clone for SequenceRecord<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SequenceRecord<'a>

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

Formats the value using the given formatter.

impl<'a> Sequence<'a> for SequenceRecord<'a>

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

fn strip_returns(&'a self) -> Cow<'a, [u8]>

Remove newlines from the sequence; this handles \r, \n, and \r\n and removes internal newlines in addition to ones at the end. Primarily used for FASTA multiline records, but can also help process (the much rarer) multiline FASTQs. Always use before iteration methods below to ensure no newlines are being returned with e.g. .kmers. If you are using normalize, you do not need to call this function directly.

fn reverse_complement(&'a self) -> Vec<u8>

Returns the reverse complement of a sequence. Biologically this is equivalent to the sequence of the strand opposite the one you pass in.

fn normalize(&'a self, iupac: bool) -> Cow<'a, [u8]>

[Nucleic Acids] Normalizes the sequence. See documentation for needletail::sequence::normalize. Do not use on amino acid sequences. Note that this returns a Cow so you may have to coerce to a Vec or &u8 as necessary.

fn canonical_kmers(
    &'a self,
    k: u8,
    reverse_complement: &'a [u8]
) -> CanonicalKmers<'a>

[Nucleic Acids] Returns an iterator over the sequence that skips non-ACGT bases and returns a tuple containing (position, the canonicalized kmer, if the sequence is the complement of the original).

fn kmers(&'a self, k: u8) -> Kmers<'a>

Returns an iterator that returns a sliding window of k-sized sequences (k-mers). Does not skip whitespace or correct bases in the original sequence so .normalize or .strip_returns may be appropriate to use first.

fn bit_kmers(&'a self, k: u8, canonical: bool) -> BitNuclKmer<'a>

Return an iterator that returns valid kmers in 4-bit form