Struct rust_htslib::bam::Reader

pub struct Reader { /* fields omitted */ }

A BAM reader.

Implementations

impl Reader

pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>

Create a new Reader from path.

Arguments

• path - the path to open.

pub fn from_stdin() -> Result<Self>

Create a new Reader from STDIN.

pub fn from_url(url: &Url) -> Result<Self>

Create a new Reader from URL.

pub fn iter_chunk(
    &mut self,
    start: Option<i64>,
    end: Option<i64>
) -> ChunkIterator<'_, Self>

Iterator over the records between the (optional) virtual offsets start and end

Arguments

• start - Optional starting virtual offset to seek to. Throws an error if it is not a valid virtual offset.

• end - Read until the virtual offset is less than end

pub fn set_reference<P: AsRef<Path>>(&mut self, path: P) -> Result<()>

Set the reference path for reading CRAM files.

Arguments

• path - path to the FASTA reference

Trait Implementations

impl Debug for Reader

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

Formats the value using the given formatter.

impl Drop for Reader

fn drop(&mut self)

Executes the destructor for this type.

impl Read for Reader

fn read(&mut self, record: &mut Record) -> Option<Result<()>>

Read the next BAM record into the given Record. Returns None if there are no more records.

This method is useful if you want to read records as fast as possible as the Record can be reused. A more ergonomic approach is to use the records iterator.

Errors

If there are any issues with reading the next record an error will be returned.

Examples

use rust_htslib::errors::Error;
use rust_htslib::bam::{Read, Reader, Record};

let mut bam = Reader::from_path(&"test/test.bam")?;
let mut record = Record::new();

// Print the TID of each record
while let Some(r) = bam.read(&mut record) {
   r.expect("Failed to parse record");
   println!("TID: {}", record.tid())
}

fn records(&mut self) -> Records<'_, Self>

Iterator over the records of the fetched region. Note that, while being convenient, this is less efficient than pre-allocating a Record and reading into it with the read method, since every iteration involves the allocation of a new Record.

fn rc_records(&mut self) -> RcRecords<'_, Self>

Records iterator using an Rc to avoid allocating a Record each turn. This is about 1% slower than the read based API in micro benchmarks, but has nicer ergonomics (and might not actually be slower in your applications).

fn pileup(&mut self) -> Pileups<'_, Self>

Iterator over pileups.

fn htsfile(&self) -> *mut htsFile

Return the htsFile struct

fn header(&self) -> &HeaderView

Return the header.

fn set_thread_pool(&mut self, tpool: &ThreadPool) -> Result<()>

Use a shared thread-pool for writing. This permits controlling the total thread count when multiple readers and writers are working simultaneously. A thread pool can be created with crate::tpool::ThreadPool::new(n_threads)

fn seek(&mut self, offset: i64) -> Result<()>

Seek to the given virtual offset in the file

fn tell(&self) -> i64

Report the current virtual offset

fn set_threads(&mut self, n_threads: usize) -> Result<()>

Activate multi-threaded BAM read support in htslib. This should permit faster reading of large BAM files.

impl Send for Reader