Struct BcfReader 

pub struct BcfReader<R>
where
    R: Read,
{ /* private fields */ }

BcfReader suitable for read through the BCF file.

This assumes that the source reader is in BCF format and stored as BGZF blocks.

Example

use bcf_reader::*;
use std::{
    fs::File,
    io::{BufReader, Seek},
};
// underlying reader can be stdin or a file
let reader = std::fs::File::open("testdata/test3.bcf")
    .map(BufReader::new)
    .unwrap();
// 1. for sequential decompression (works for data from stdin or a file)
let reader = flate2::bufread::MultiGzDecoder::new(reader);
// 2. for parallel decompression (works for data from stdin or a file)
// however, when data is from stdin, jump is not supported for now.
// let reader = ParMultiGzipReader::from_reader(reader, 3, None, None);

// create bcf reader
let mut reader = BcfReader::from_reader(reader);
// read though header
let _header = reader.read_header();
// create a reusable record
let mut record = Record::default();

let mut pos_found = vec![];
// iterate records from the targeted genome interval
while let Ok(_) = reader.read_record(&mut record) {
    pos_found.push(record.pos() + 1);
}

assert_eq!(pos_found[0], 72);
assert_eq!(*pos_found.last().unwrap(), 1498841);

Implementations

impl<R> BcfReader<R>

where R: Read,

pub fn from_reader(reader: R) -> Self

max_gzip, the number of gzip blocks to read before batch decompression. See ParMultiGzipReader::from_reader (by default or None, 3 gzip buffers will be used.)

pub fn read_header(&mut self) -> Result<Header>

Read the header

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

Read one record. This should be called after the header is read and parsed. Otherwise, it will panic.