Struct Writer 

pub struct Writer<W>
where
    W: Write,
{ /* private fields */ }

A Fasta writer.

Implementations

impl Writer<File>

pub fn to_file<P>(path: P) -> Result<Writer<File>, Error>

where P: AsRef<Path>,

Write to the given file path.

pub fn to_file_with_capacity<P>( capacity: usize, path: P, ) -> Result<Writer<File>, Error>

where P: AsRef<Path>,

Write to the given file path and a buffer capacity

impl<W> Writer<W>

where W: Write,

pub fn new(writer: W) -> Writer<W>

Create a new Fasta writer.

pub fn with_capacity(capacity: usize, writer: W) -> Writer<W>

Create a new Fasta writer with a capacity of write buffer

pub fn from_bufwriter(bufwriter: BufWriter<W>) -> Writer<W>

Create a new Fasta writer with a given BufWriter

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

Directly write a fasta::Record.

Errors

If there is an issue writing to the Writer.

Examples

use bio::io::fasta::{Record, Writer};
use std::fs;
use std::io;
use std::path::Path;

let path = Path::new("test.fa");
let file = fs::File::create(path).unwrap();
{
    let handle = io::BufWriter::new(file);
    let mut writer = Writer::new(handle);
    let record = Record::with_attrs("id", Some("desc"), b"ACGT");

    let write_result = writer.write_record(&record);
    assert!(write_result.is_ok());
}

let actual = fs::read_to_string(path).unwrap();
let expected = ">id desc\nACGT\n";

assert!(fs::remove_file(path).is_ok());
assert_eq!(actual, expected)

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

Write a Fasta record with given id, optional description and sequence.

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

Flush the writer, ensuring that everything is written.

Trait Implementations

impl<W> Debug for Writer<W>

where W: Debug + Write,

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

Formats the value using the given formatter.