Module fastq

Structs and trait to read and write files in FASTQ format.

Example

Read

In this example, we parse a fastq file from stdin and compute some statistics

use bio::io::fastq;
use std::io;
let mut reader = fastq::Reader::new(io::stdin());

let mut nb_reads = 0;
let mut nb_bases = 0;

for result in reader.records() {
    let record = result.expect("Error during fastq record parsing");

    nb_reads += 1;
    nb_bases += record.seq().len();
}

println!("Number of reads: {}", nb_reads);
println!("Number of bases: {}", nb_bases);

We can also use a while loop to iterate over records

use bio::io::fastq;
use std::io;
let mut records = fastq::Reader::new(io::stdin()).records();

let mut nb_reads = 0;
let mut nb_bases = 0;

while let Some(Ok(record)) = records.next() {
    nb_reads += 1;
    nb_bases += record.seq().len();
}

println!("Number of reads: {}", nb_reads);
println!("Number of bases: {}", nb_bases);

Write

In this example we generate 10 random sequences with length 100 and write them to stdout.

use std::io;
use bio::io::fastq;

let mut seed = 42;

let nucleotides = [b'A', b'C', b'G', b'T'];

let mut writer = fastq::Writer::new(io::stdout());

for _ in 0..10 {
    let seq = (0..100).map(|_| {
        seed = ((seed ^ seed << 13) ^ seed >> 7) ^ seed << 17; // don't use this random generator
        nucleotides[seed % 4]
    }).collect::<Vec<u8>>();

    let qual = (0..100).map(|_| b'!').collect::<Vec<u8>>();

   writer.write("random", None, seq.as_slice(), qual.as_slice());
}

Read and Write

In this example we filter reads from stdin on mean quality (Phred + 33) and write them to stdout

use bio::io::fastq;
use bio::io::fastq::FastqRead;
use std::io;

let mut reader = fastq::Reader::new(io::stdin());
let mut writer = fastq::Writer::new(io::stdout());
let mut record = fastq::Record::new();

while let Ok(()) = reader.read(&mut record) {
    if record.is_empty() {
        let check = record.check();
        break;
    }

    let mut sum_qual = record.qual().iter().sum::<u8>() as f64;

    if (sum_qual / record.seq().len() as f64 - 33.0) > 30.0 {
        writer.write_record(&record);
    }
}

Structs

Reader

A FastQ reader.

Record

A FastQ record.

Records

An iterator over the records of a FastQ file.

Writer

A FastQ writer.

Enums

Error

Traits

FastqRead

Trait for FastQ readers.

Type Aliases

Result