Struct FastxWriter 

pub struct FastxWriter<W: Write> { /* private fields */ }

A writer for FASTA and FASTQ records.

FASTA sequence lines are wrapped at DEFAULT_LINE_WIDTH unless configured otherwise. Writing a FASTQ record without quality scores is an error rather than a silent fabrication of quality values; writing a FASTQ record to a FASTA writer simply drops the quality, which is the usual fq2fa conversion.

use fastx::{FastxWriter, Format, Sequence};

let mut out = Vec::new();
{
    let mut writer = FastxWriter::new(&mut out, Format::Fasta).line_width(4);
    writer.write_record(&Sequence::fasta("a", b"ACGTAC"))?;
    writer.flush()?;
}
assert_eq!(out, b">a\nACGT\nAC\n");

Implementations

impl<W: Write> FastxWriter<W>

pub fn new(inner: W, format: Format) -> FastxWriter<W>

A writer for format, wrapping FASTA at DEFAULT_LINE_WIDTH.

Wrap inner in a BufWriter yourself for best throughput, or use create which does it for you.

pub fn line_width(self, width: usize) -> Self

Set the FASTA line width. 0 disables wrapping.

pub fn validate(self, alphabet: Alphabet) -> Self

Validate every record against alphabet before writing it.

pub fn format(&self) -> Format

The output format.

pub fn records_written(&self) -> u64

Number of records written so far.

pub fn write_record(&mut self, record: &Sequence) -> Result<()>

Write one record in the writer’s format.

pub fn write_all<'a, I>(&mut self, records: I) -> Result<()>

where I: IntoIterator<Item = &'a Sequence>,

Write every record of an iterator.

pub fn write_fasta( &mut self, id: &str, description: Option<&str>, seq: &[u8], ) -> Result<()>

Write a FASTA record from parts, without building a Sequence.

pub fn write_fastq( &mut self, id: &str, description: Option<&str>, seq: &[u8], quality: &[u8], ) -> Result<()>

Write a FASTQ record from parts, without building a Sequence.

pub fn flush(&mut self) -> Result<()>

Flush buffered bytes to the underlying writer.

pub fn finish(self) -> Result<W>

Flush and return the underlying writer.

Always prefer this over dropping the writer: for gzip output it is the only way to learn that finishing the stream failed.

pub fn get_ref(&self) -> &W

Borrow the underlying writer.

Trait Implementations

impl<W: Write> Debug for FastxWriter<W>

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

Formats the value using the given formatter.