Struct seq_io::fasta::RefRecord

pub struct RefRecord<'a, S = LineStore> where
    S: PositionStore,  { /* fields omitted */ }

A FASTA record that borrows data from a buffer. It implements the traits BaseRecord and Record.

Implementations

impl<'a, S> RefRecord<'a, S> where
    S: PositionStore, 

pub fn seq_lines(&self) -> impl Iterator<Item = &'a [u8]> + DoubleEndedIterator

Returns an iterator over all sequence lines in the data. The exact type of the iterator depends on the generic parameter S.

pub fn owned_seq(&self) -> Vec<u8>

Returns the sequence as owned Vec. Note: This function must be called in order to obtain a sequence that does not contain line endings (as returned by seq())

pub fn to_owned_record(&self) -> OwnedRecord

Returns a new OwnedRecord with the same data.

pub fn clone_into_owned(&self, rec: &mut OwnedRecord)

Copies the data of the record into an OwnedRecord instance.

pub fn write_unchanged<W: Write>(&self, writer: W) -> Result<()>

Writes a record to the given io::Write instance by just writing the unmodified input, which is faster than BaseRecord::write

Trait Implementations

impl<'a, S> BaseRecord for RefRecord<'a, S> where
    S: PositionStore, 

fn head(&self) -> &[u8]

Return the header line of the record as byte slice

fn seq(&self) -> &[u8]

Return the record sequence as byte slice. With FASTA and multi-line FASTQ, this slice may contain line terminators if called on RefRecord. Use full_seq or full_seq_given instead in such cases, or iterate over lines with fasta/q/x::RefRecord::seq_lines()

fn full_seq(&self) -> Cow<'_, [u8]>

Returns the full sequence as Cow<[u8]>. If the sequence consists of a single line, then the sequence will be borrowed from the underlying buffer (equivalent to calling seq()). If there are multiple lines, an owned copy will be created.

fn full_seq_given<'s, F>(&'s self, owned_fn: F) -> Cow<'s, [u8]> where
    F: FnOnce() -> &'s mut Vec<u8>, 

Like full_seq returns the full sequence as Cow<[u8]>, with the difference that the vector that is used to store the contiguous sequence (in the case of multiple sequence lines) is provided in a closure, which is only executed if needed. This allows e.g. storing the necessary vectors in an arena allocator.

fn num_seq_lines(&self) -> usize

Returns the number of sequence lines. Calling record.seq_lines() gives the same result as record.seq_lines().len(), but the latter may be slow depending on the type PositionStore used since the line positions may have to be searched first.

fn has_quality(&self) -> bool

Returns a booleany specifying whether there is quality information in this record or not.

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

Returns the quality information or None. With multi-line FASTQ, this slice may contain line terminators if called on RefRecord. Use opt_full_qual or opt_full_qual_given instead in such cases, or iterate over lines with fasta/q/x::RefRecord::[opt_]qual_lines()

fn opt_full_qual(&self) -> Option<Cow<'_, [u8]>>

Returns the quality scores as contiguous Cow<[u8]>, if present. If not dealing with multi-line FASTQ, this does not involve any copying (same as if calling opt_qual()). If there are multiple lines, an owned copy will be created.

fn opt_full_qual_given<'s, F>(&'s self, _: F) -> Option<Cow<'s, [u8]>> where
    F: FnOnce() -> &'s mut Vec<u8>, 

Like opt_full_qual returns the full quality scores as Cow<[u8]>, with the difference that the vector that is used to store the contiguous data (in the case of multiple quality lines) is provided in a closure, which is only executed if needed.

fn num_qual_lines(&self) -> usize

Returns the number of quality lines. Always > 0 with the current parsers.

fn write<W>(&self, writer: W) -> Result<()> where
    W: Write, 

Writes the record to an output.

fn id_bytes(&self) -> &[u8]

Returns the record ID (everything before an optional space) as byte slice.

fn id(&self) -> Result<&str, Utf8Error>

Returns the record ID (everything before an optional space) as &str.

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

Returns the record description (separated from the ID by a space) as byte slice, if present.

fn desc(&self) -> Option<Result<&str, Utf8Error>>

Returns the record description (separated from the ID by a space) as &str slice, if present.

fn id_desc_bytes(&self) -> (&[u8], Option<&[u8]>)

Return both the ID and the description of the record (if present) This should be faster than calling id() and desc() separately.

fn id_desc(&self) -> Result<(&str, Option<&str>), Utf8Error>

Returns both the ID and the description of the record (if present) as &str slices. This should be faster than calling id() and desc() separately.

impl<'a, S: Clone> Clone for RefRecord<'a, S> where
    S: PositionStore, 

fn clone(&self) -> RefRecord<'a, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, S: Debug> Debug for RefRecord<'a, S> where
    S: PositionStore, 

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

Formats the value using the given formatter.

impl<'a, S> From<RefRecord<'a, S>> for RefRecord<'a, S> where
    S: PositionStore, 

fn from(rec: RefRecord<'a, S>) -> Self

Performs the conversion.

impl<'a, S> From<RefRecord<'a, S>> for RefRecord<'a, S> where
    S: PositionStore, 

fn from(rec: RefRecord<'a, S>) -> Self

Performs the conversion.

impl<'a, S> Record for RefRecord<'a, S> where
    S: PositionStore, 

fn write_wrap<W: Write>(&self, writer: W, wrap: usize) -> Result<()>

Writes the record to the given io::Write instance. The sequence is wrapped to produce multi-line FASTA with a maximum width specified by wrap.