Struct noodles::bcf::async::io::Reader

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

An async BCF reader.

Examples

use futures::TryStreamExt;
use noodles_bcf as bcf;
use tokio::fs::File;

let mut reader = File::open("sample.bcf").await.map(bcf::r#async::io::Reader::new)?;
reader.read_header().await?;

let mut records = reader.records();

while let Some(record) = records.try_next().await? {
    // ...
}

Implementations

impl<R> Reader<R>

where R: AsyncRead + Unpin,

pub fn get_ref(&self) -> &R

Returns a reference to the underlying reader.

Examples

use noodles_bcf as bcf;
let data = [];
let reader = bcf::r#async::io::Reader::from(&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_bcf as bcf;
let data = [];
let mut reader = bcf::r#async::io::Reader::from(&data[..]);
assert!(reader.get_mut().is_empty());

pub fn into_inner(self) -> R

Returns the underlying reader.

Examples

use noodles_bcf as bcf;
let data = [];
let reader = bcf::r#async::io::Reader::from(&data[..]);
assert!(reader.into_inner().is_empty());

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

Reads the VCF header.

The BCF magic number is checked, and the file format version is discarded.

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

Examples

use noodles_bcf as bcf;
use tokio::fs::File;

let mut reader = File::open("sample.bcf").await.map(bcf::r#async::io::Reader::new)?;
let header = reader.read_header().await?;

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

Reads a single record without decoding (most of) its feilds.

The stream is expected to be directly after the header or at the start of another record.

It is more ergonomic to read records using a stream (see Self::records), but using this method directly allows the reuse of a single Record buffer.

If successful, the record size is returned. If a record size of 0 is returned, the stream reached EOF.

use noodles_bcf as bcf;
use tokio::fs::File;

let mut reader = File::open("sample.bcf").await.map(bcf::r#async::io::Reader::new)?;
reader.read_header().await?;

let mut record = bcf::Record::default();
reader.read_record(&mut record).await?;

pub fn records(&mut self) -> impl Stream<Item = Result<Record, Error>>

Returns an (async) stream over lazy records starting from the current (input) stream position.

The (input) stream is expected to be directly after the header or at the start of another record.

Examples

use futures::TryStreamExt;
use noodles_bcf as bcf;
use tokio::fs::File;

let mut reader = File::open("sample.bcf").await.map(bcf::r#async::io::Reader::new)?;
reader.read_header().await?;

let mut records = reader.records();

while let Some(record) = records.try_next().await? {
    // ...
}

impl<R> Reader<Reader<R>>

where R: AsyncRead + Unpin,

pub fn new(inner: R) -> Reader<Reader<R>>

Creates an async BCF reader.

Examples

use noodles_bcf as bcf;
let data = [];
let reader = bcf::r#async::io::Reader::new(&data[..]);

impl<R> Reader<Reader<R>>

where R: AsyncRead + AsyncSeek + Unpin,

pub fn query<I>( &mut self, header: &Header, index: &I, region: &Region ) -> Result<impl Stream<Item = Result<Record, Error>>, Error>

where I: BinningIndex,

Returns a stream over records that intersect the given region.

Examples

use futures::TryStreamExt;
use noodles_bcf as bcf;
use noodles_core::Region;
use noodles_csi as csi;
use tokio::fs::File;

let mut reader = File::open("sample.bcf").await.map(bcf::r#async::io::Reader::new)?;
let header = reader.read_header().await?;

let index = csi::r#async::read("sample.bcf.csi").await?;
let region = "sq0:8-13".parse()?;
let mut query = reader.query(&header, &index, &region)?;

while let Some(record) = query.try_next().await? {
    // ...
}

Trait Implementations

impl<R> From<R> for Reader<R>

fn from(inner: R) -> Reader<R>

Converts to this type from the input type.