Struct seq_io::fastq::Reader [−][src]
pub struct Reader<R: Read, S = DoubleUntil8M> { /* fields omitted */ }
FASTQ parser.
Methods
impl<R> Reader<R, DoubleUntil8M> where
R: Read,
[src]
impl<R> Reader<R, DoubleUntil8M> where
R: Read,
pub fn new(reader: R) -> Reader<R, DoubleUntil8M>
[src]
pub 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"))
pub fn with_capacity(reader: R, capacity: usize) -> Reader<R, DoubleUntil8M>
[src]
pub fn with_capacity(reader: R, capacity: usize) -> Reader<R, DoubleUntil8M>
Creates a reader with the given buffer size
impl Reader<File, DoubleUntil8M>
[src]
impl Reader<File, DoubleUntil8M>
pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Reader<File>>
[src]
pub 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,
[src]
impl<R, S> Reader<R, S> where
R: Read,
S: BufStrategy,
pub fn with_cap_and_strategy(
reader: R,
cap: usize,
buf_strategy: S
) -> Reader<R, S>
[src]
pub 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.
pub fn next<'a>(&'a mut self) -> Option<Result<RefRecord<'a>, Error>>
[src]
pub 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()); }
pub fn read_record_set(
&mut self,
rset: &mut RecordSet
) -> Option<Result<(), Error>>
[src]
pub 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.
pub fn position(&self) -> &Position
[src]
pub 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));
ⓘImportant traits for RecordsIter<'a, R, S>pub fn records(&mut self) -> RecordsIter<R, S>
[src]
pub 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()} ] );
ⓘImportant traits for RecordsIntoIter<R, S>pub fn into_records(self) -> RecordsIntoIter<R, S>
[src]
pub 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,
[src]
impl<R, S> Reader<R, S> where
R: Read + Seek,
S: BufStrategy,
pub fn seek(&mut self, pos: &Position) -> Result<(), Error>
[src]
pub 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);