Struct noodles_cram::AsyncReader

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

An async CRAM reader.

Implementations

impl<R> Reader<R> where
    R: AsyncRead + Unpin, 

pub fn new(inner: R) -> Self

Creates an async CRAM reader.

Examples

use noodles_cram as cram;
let data = [];
let reader = cram::AsyncReader::new(&data[..]);

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

Reads the CRAM file definition.

This also checks the magic number.

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

Examples

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

pub async 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;
use tokio::fs::File;

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

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

pub async 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;
use tokio::fs::File;

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

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

impl<R> Reader<R> where
    R: AsyncRead + AsyncSeek + Unpin, 

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

Seeks the underlying reader to the given position.

Positions typically come from an associated CRAM index file.

Examples

use std::io::{Cursor, SeekFrom};
use noodles_cram as cram;
let mut reader = cram::AsyncReader::new(Cursor::new(Vec::new()));
reader.seek(SeekFrom::Start(0)).await?;

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

Returns the current position of the underlying reader.

Examples

use std::io::{Cursor, SeekFrom};
use noodles_cram as cram;
let mut reader = cram::AsyncReader::new(Cursor::new(Vec::new()));
assert_eq!(reader.position().await?, 0);