Struct seq_io::fastx::dynamic::RefRecord

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

A FASTX 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 opt_qual_lines(
    &self
) -> Option<impl Iterator<Item = &'a [u8]> + DoubleEndedIterator>

Returns an iterator over all quality lines in the data (if present). The exact type of the iterator depends on the generic parameter S.

pub fn check_lengths_strict(&self) -> Result<&Self, Error>

Checks if the lengths of the sequence and quality lines are equal. If not, returns an error of ErrorKind::UnequalLengths.

In contrast to RefRecord::check_lengths, this method always removes line terminators before comparing the lengths. Therefore, it will always return the correct result, even if there is a mix of CR and CRLF line ends.

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>,
    Self: Sized, 

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, owned_fn: 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,
    Self: Sized, 

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> 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>(&self, writer: W, wrap: usize) -> Result<()> where
    W: Write,
    Self: Sized, 

Write the record to the given io::Write instance. For FASTA, the sequence is wrapped to produce multi-line FASTA with a maximum width specified by wrap. Wrapping FASTQ sequence and quality lines is explicitly not supported because such files are prone to parsing problems.

fn write_as<W>(
    &self,
    writer: W,
    format: SeqFormat,
    wrap_fasta: Option<usize>
) -> Result<()> where
    W: Write, 

Writes the record to an output given a sequence format.

fn check_lengths(&self) -> Result<&Self, Error>

Checks if the lengths of the sequence and quality lines are equal. If not, returns an error of ErrorKind::UnequalLengths.