Struct IndexedReader

pub struct IndexedReader<R>
where
    R: Read + Seek,
{
    pub index: Index,
    /* private fields */
}

A FASTA reader with an index as created by SAMtools (.fai).

Fields

index: Index

Implementations

impl IndexedReader<File>

pub fn from_file<P>(path: &P) -> Result<IndexedReader<File>, Error>

where P: AsRef<Path> + Debug,

Read from a given file path. This assumes the index ref.fasta.fai to be present for FASTA ref.fasta.

impl<R> IndexedReader<R>

where R: Read + Seek,

pub fn new<I>(fasta: R, fai: I) -> Result<IndexedReader<R>, Error>

where I: Read,

Read from a FASTA and its index, both given as io::Read. FASTA has to be io::Seek in addition.

pub fn with_index(fasta: R, index: Index) -> IndexedReader<R>

Read from a FASTA and its index, the first given as io::Read, the second given as index object.

pub fn fetch( &mut self, seq_name: &str, start: u64, stop: u64, ) -> Result<(), Error>

Fetch an interval from the sequence with the given name for reading.

start and stop are 0-based and stop is exclusive - i.e. [start, stop)

Example

use bio::io::fasta::IndexedReader;
// create dummy files
const FASTA_FILE: &[u8] = b">chr1\nGTAGGCTGAAAA\nCCCC";
const FAI_FILE: &[u8] = b"chr1\t16\t6\t12\t13";

let seq_name = "chr1";
let start: u64 = 0; // start is 0-based, inclusive
let stop: u64 = 10; // stop is 0-based, exclusive
                    // load the index
let mut faidx = IndexedReader::new(std::io::Cursor::new(FASTA_FILE), FAI_FILE).unwrap();
// move the pointer in the index to the desired sequence and interval
faidx
    .fetch(seq_name, start, stop)
    .expect("Couldn't fetch interval");
// read the subsequence defined by the interval into a vector
let mut seq = Vec::new();
faidx.read(&mut seq).expect("Couldn't read the interval");
assert_eq!(seq, b"GTAGGCTGAA");

Errors

If the seq_name does not exist within the index.

pub fn fetch_by_rid( &mut self, rid: usize, start: u64, stop: u64, ) -> Result<(), Error>

Fetch an interval from the sequence with the given record index for reading.

start and stop are 0-based and stop is exclusive - i.e. [start, stop)

Example

use bio::io::fasta::IndexedReader;
// create dummy files
const FASTA_FILE: &[u8] = b">chr1\nGTAGGCTGAAAA\nCCCC";
const FAI_FILE: &[u8] = b"chr1\t16\t6\t12\t13";

let rid: usize = 0;
let start: u64 = 0; // start is 0-based, inclusive
let stop: u64 = 10; // stop is 0-based, exclusive
                    // load the index
let mut faidx = IndexedReader::new(std::io::Cursor::new(FASTA_FILE), FAI_FILE).unwrap();
// move the pointer in the index to the desired sequence and interval
faidx
    .fetch_by_rid(rid, start, stop)
    .expect("Couldn't fetch interval");
// read the subsequence defined by the interval into a vector
let mut seq = Vec::new();
faidx.read(&mut seq).expect("Couldn't read the interval");
assert_eq!(seq, b"GTAGGCTGAA");

Errors

If rid does not exist within the index.

pub fn fetch_all(&mut self, seq_name: &str) -> Result<(), Error>

Fetch the whole sequence with the given name for reading.

pub fn fetch_all_by_rid(&mut self, rid: usize) -> Result<(), Error>

Fetch the whole sequence with the given record index for reading.

pub fn read(&mut self, seq: &mut Vec<u8>) -> Result<(), Error>

Read the fetched sequence into the given vector.

pub fn read_iter(&mut self) -> Result<IndexedReaderIterator<'_, R>, Error>

Return an iterator yielding the fetched sequence.

Trait Implementations

impl<R> Debug for IndexedReader<R>

where R: Debug + Read + Seek,

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

Formats the value using the given formatter.