Struct noodles_cram::reader::Reader

pub struct Reader<R> { /* private fields */ }

A CRAM reader.

The CRAM format is comprised of four main parts: 1) a file definition, 2) a file header, 3) a list of data containers, and 4) an end-of-file (EOF) container.

Examples

use noodles_cram as cram;
use noodles_fasta as fasta;

let repository = fasta::Repository::default();

let mut reader = File::open("sample.cram").map(cram::Reader::new)?;
reader.read_file_definition()?;

let header = reader.read_file_header()?.parse()?;

for result in reader.records(&repository, &header) {
    let record = result?;
    println!("{:?}", record);
}

Implementations

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

pub fn new(reader: R) -> Self

Creates a CRAM reader.

Examples

use noodles_cram as cram;
let mut reader = File::open("sample.bam").map(cram::Reader::new)?;

pub fn get_ref(&self) -> &R

Returns a reference to the underlying reader.

Examples

use noodles_cram as cram;
let data = [];
let reader = cram::Reader::new(&data[..]);
assert!(reader.get_ref().is_empty());

pub fn get_mut(&mut self) -> &mut R

Returns a mutable reference to the underlying reader.

Examples

use noodles_cram as cram;
let data = [];
let mut reader = cram::Reader::new(&data[..]);
assert!(reader.get_mut().is_empty());

pub fn into_inner(self) -> R

Unwraps and returns the underlying reader.

Examples

use noodles_cram as cram;
let data = [];
let reader = cram::Reader::new(&data[..]);
assert!(reader.into_inner().is_empty());

pub fn read_file_definition(&mut self) -> Result<FileDefinition>

Reads the CRAM file definition.

The CRAM magic number is also checked.

The position of the stream is expected to be at the start.

Examples

use noodles_cram as cram;
let mut reader = File::open("sample.cram").map(cram::Reader::new)?;
let file_definition = reader.read_file_definition()?;

pub fn read_file_header(&mut self) -> Result<String>

Reads the raw SAM header.

The position of the stream is expected to be at the CRAM header container, i.e., directly after the file definition.

This returns the raw SAM header as a String. It can subsequently be parsed as a noodles_sam::Header.

Examples

use noodles_cram as cram;

let mut reader = File::open("sample.cram").map(cram::Reader::new)?;
reader.read_file_definition()?;

let header = reader.read_file_header()?;

pub fn read_data_container(&mut self) -> Result<Option<DataContainer>>

Reads a data container.

This returns None if the container header is the EOF container header, which signals the end of the stream.

Examples

use noodles_cram as cram;

let mut reader = File::open("sample.cram").map(cram::Reader::new)?;
reader.read_file_definition()?;
reader.read_file_header()?;

while let Some(container) = reader.read_data_container()? {
    // ...
}

pub fn records<'a>(
    &'a mut self,
    reference_sequence_repository: &'a Repository,
    header: &'a Header
) -> Records<'a, R>

Returns a iterator over records starting from the current stream position.

The stream is expected to be at the start of a data container.

Examples

use noodles_cram as cram;
use noodles_fasta as fasta;

let repository = fasta::Repository::default();

let mut reader = File::open("sample.cram").map(cram::Reader::new)?;
reader.read_file_definition()?;

let header = reader.read_file_header()?.parse()?;

for result in reader.records(&repository, &header) {
    let record = result?;
    println!("{:?}", record);
}

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

pub fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seeks the underlying reader to the given position.

Positions typically come from the associated CRAM index file.

Examples

use std::io::SeekFrom;
use noodles_cram as cram;

let mut reader = File::open("sample.cram").map(cram::Reader::new)?;
reader.seek(SeekFrom::Start(17711))?;

pub fn position(&mut self) -> Result<u64>

Returns the current position of the underlying reader.

Examples

use noodles_cram as cram;
let data = Cursor::new(Vec::new());
let mut reader = cram::Reader::new(data);
let position = reader.position()?;
assert_eq!(position, 0);

pub fn query<'a>(
    &'a mut self,
    reference_sequence_repository: &'a Repository,
    header: &'a Header,
    index: &'a Index,
    region: &Region
) -> Result<Query<'_, R>>

Returns an iterator over records that intersects the given region.

Examples

use noodles_cram::{self as cram, crai};
use noodles_fasta as fasta;

let mut reader = File::open("sample.cram").map(cram::Reader::new)?;
reader.read_file_definition()?;

let repository = fasta::Repository::default();
let header = reader.read_file_header()?.parse()?;
let index = crai::read("sample.cram.crai")?;
let region = "sq0:8-13".parse()?;
let query = reader.query(&repository, &header, &index, &region)?;

for result in query {
    let record = result?;
    // ...
}

Trait Implementations

impl<R> AlignmentReader for Reader<R> where
    R: Read, 

fn read_alignment_header(&mut self) -> Result<Header>

Reads a SAM header.

fn alignment_records<'a>(
    &'a mut self,
    reference_sequence_repository: &'a Repository,
    header: &'a Header
) -> Box<dyn Iterator<Item = Result<Record>> + 'a>

Returns an iterator over records.