Struct 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 containers, and 4) an end-of-file (EOF) container.

Examples

use noodles_cram as cram;
use noodles_fasta as fasta;

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

for result in reader.records(&header) {
    let record = result?;
    // ...
}

Implementations

impl<R> Reader<R>

pub fn get_ref(&self) -> &R

Returns a reference to the underlying reader.

Examples

use noodles_cram as cram;
let reader = cram::io::Reader::new(io::empty());
let _inner = reader.get_ref();

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

Returns a mutable reference to the underlying reader.

Examples

use noodles_cram as cram;
let mut reader = cram::io::Reader::new(io::empty());
let _inner = reader.get_mut();

pub fn into_inner(self) -> R

Unwraps and returns the underlying reader.

Examples

use noodles_cram as cram;
let reader = cram::io::Reader::new(io::empty());
let _inner = reader.into_inner();

impl<R> Reader<R>

where R: Read,

pub fn new(inner: R) -> Self

Creates a CRAM reader.

Examples

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

pub fn header_reader(&mut self) -> Reader<&mut R>

Returns a CRAM header reader.

Examples

use noodles_cram as cram;

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

let mut header_reader = reader.header_reader();
header_reader.read_magic_number()?;
header_reader.read_format_version()?;
header_reader.read_file_id()?;

let mut container_reader = header_reader.container_reader()?;

let _raw_header = {
    let mut raw_sam_header_reader = container_reader.raw_sam_header_reader()?;
    let mut raw_header = String::new();
    raw_sam_header_reader.read_to_string(&mut raw_header)?;
    raw_sam_header_reader.discard_to_end()?;
    raw_header
};

container_reader.discard_to_end()?;
Ok::<_, std::io::Error>(())

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::io::Reader::new)?;
let file_definition = reader.read_file_definition()?;

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

Reads the SAM header.

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

Examples

use noodles_cram as cram;

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

let header = reader.read_file_header()?;

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

Reads the SAM header.

This verifies the CRAM magic number, discards the file definition, and reads and parses the file header as a SAM header.

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::io::Reader::new)?;
let header = reader.read_header()?;

pub fn read_container(&mut self, container: &mut Container) -> Result<usize>

Reads a container.

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

Examples

use noodles_cram::{self as cram, io::reader::Container};

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

let mut container = Container::default();

while reader.read_container(&mut container)? != 0 {
    // ...
}

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

👎Deprecated since 0.78.0: Use Reader::read_container instead.

Reads a container.

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

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

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

Examples

use noodles_cram as cram;
use noodles_fasta as fasta;

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

for result in reader.records(&header) {
    let record = result?;
    // ...
}

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 noodles_cram as cram;
let mut reader = cram::io::Reader::new(io::empty());
reader.seek(SeekFrom::Start(0))?;

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

Returns the current position of the underlying reader.

Examples

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

pub fn query<'a>( &'a mut self, header: &'a Header, index: &'a Index, region: &Region, ) -> Result<Query<'a, 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::io::Reader::new)?;

let header = reader.read_header()?;
let index = crai::fs::read("sample.cram.crai")?;
let region = "sq0:8-13".parse()?;
let query = reader.query(&header, &index, &region)?;

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

Trait Implementations

impl<R> Read<R> 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, header: &'a Header, ) -> Box<dyn Iterator<Item = Result<Box<dyn Record>>> + 'a>

Returns an iterator over records.