Struct seq_io::fastq::Reader

pub struct Reader<R: Read, S = DoubleUntil8M> { /* fields omitted */ }

FASTQ parser.

Methods

impl<R> Reader<R, DoubleUntil8M> where
    R: Read, 

fn new(reader: R) -> Reader<R, DoubleUntil8M>

Creates a new reader with the default buffer size of 68 KB

Example:

use seq_io::fastq::{Reader,Record};
let fastq = b"@id\nACGT\n+\nIIII";

let mut reader = Reader::new(&fastq[..]);
let record = reader.next().unwrap().unwrap();
assert_eq!(record.id(), Ok("id"))

fn with_capacity(reader: R, capacity: usize) -> Reader<R, DoubleUntil8M>

Creates a reader with the given buffer size

impl Reader<File, DoubleUntil8M>

fn from_path<P: AsRef<Path>>(path: P) -> Result<Reader<File>>

Creates a reader from a file path.

Example:

use seq_io::fastq::Reader;

let mut reader = Reader::from_path("seqs.fastq").unwrap();

// (... do something with the reader)

impl<R, S> Reader<R, S> where
    R: Read,
    S: BufStrategy, 

fn with_cap_and_strategy(reader: R, cap: usize, buf_strategy: S) -> Reader<R, S>

Creates a new reader with a given buffer capacity and growth strategy. See here for an example using the FASTA reader, but otherwise equivalent.

fn next<'a>(&'a mut self) -> Option<Result<RefRecord<'a>, Error>>

Searches the next FASTQ record and returns a RefRecord that borrows its data from the underlying buffer of this reader.

Example:

use seq_io::fastq::{Reader,Record};

let mut reader = Reader::from_path("seqs.fastq").unwrap();

while let Some(record) = reader.next() {
    let record = record.unwrap();
    println!("{}", record.id().unwrap());
}

fn read_record_set(&mut self, rset: &mut RecordSet) -> Option<Result<(), Error>>

Updates a RecordSet with new data. The contents of the internal buffer are just copied over to the record set and the positions of all records are found. Old data will be erased. Returns None if the input reached its end.

fn position(&self) -> &Position

Returns the current position (useful with seek())

Example

use seq_io::fastq::{Reader,Position};

let fastq = b"@id1
ACGT
+
IIII
@id2
TGCA
+
IIII";

let mut reader = Reader::new(&fastq[..]);

// skip one record
reader.next().unwrap();
// second position
reader.next().unwrap();

assert_eq!(reader.position(), &Position::new(5, 17));

fn records(&mut self) -> RecordsIter<R, S>

Returns a borrowed iterator over all FASTQ records. The records are owned (OwnedRecord), this is therefore slower than using Reader::next().

Example

use seq_io::fastq::{Reader,OwnedRecord};

let fastq = b"@id1
ACGT
+
IIII
@id2
TGCA
+
IIII";

let mut reader = Reader::new(&fastq[..]);

let records: Result<Vec<_>, _> = reader
    .records()
    .collect();

assert_eq!(records.unwrap(),
    vec![
        OwnedRecord {head: b"id1".to_vec(), seq: b"ACGT".to_vec(), qual: b"IIII".to_vec()},
        OwnedRecord {head: b"id2".to_vec(), seq: b"TGCA".to_vec(), qual: b"IIII".to_vec()}
    ]
);

fn into_records(self) -> RecordsIntoIter<R, S>

Returns an iterator over all FASTQ records like Reader::records(), but with the difference that it owns the underlying reader.

impl<R, S> Reader<R, S> where
    R: Read + Seek,
    S: BufStrategy, 

fn seek(&mut self, pos: &Position) -> Result<(), Error>

Seeks to a specified position. Keep the underyling buffer if the seek position is found within it, otherwise it has to be discarded. If an error was returned before, seeking to that position will return the same error. The same is not always true with None. If there is no newline character at the end of the file, the last record will be returned instead of None.

Example

use seq_io::fastq::{Reader,Position,OwnedRecord};
use std::io::Cursor;

let fastq = b"@id1
ACGT
+
IIII
@id2
TGCA
+
IIII";

let mut cursor = Cursor::new(&fastq[..]);
let mut reader = Reader::new(cursor);

// read the first record and get its position
let record1 = reader.next().unwrap().unwrap().to_owned_record();
let pos1 = reader.position().to_owned();

// read the second record
reader.next().unwrap().unwrap();

// now seek to position of first record
reader.seek(&pos1);
assert_eq!(reader.next().unwrap().unwrap().to_owned_record(), record1);

Trait Implementations

impl<R, S> Reader for Reader<R, S> where
    R: Read,
    S: BufStrategy + Send, 

type DataSet = RecordSet

type Err = Error

fn fill_data(&mut self, rset: &mut RecordSet) -> Option<Result<(), Error>>