Struct LazyNucleotideSequences 

pub struct LazyNucleotideSequences { /* private fields */ }

A lazy-loaded set of nucleotide sequences based on indexed FASTA files

Implementations

impl LazyNucleotideSequences

pub fn new( filepath: impl Into<PathBuf>, seqnames: Option<Vec<String>>, ) -> Result<Self, GRangesError>

Create a new LazyNucleotideSequences, which can lazyily retrieve regions and whole sequences from an indexed FASTA file.

Arguments

• filepath - the path to the bgzipped and indexed FASTA file.
• seqnames - optional vector of sequences to consider (i.e. used for iterators over sequences).

pub fn is_empty(&self) -> bool

Check of the lazy-loading cache is empty.

pub fn clear(&self)

Clear the lazy-loading cache.

pub fn seqlens(&self) -> IndexMap<String, Position>

Get an IndexMap of the sequence names and their lengths.

pub fn is_loaded(&self, key: &str) -> bool

Return a bool indicating whether the specified key is cached.

Arguments

• key: a &str key passed to the loader function.

Trait Implementations

impl Debug for LazyNucleotideSequences

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

Formats the value using the given formatter.

impl Sequences for LazyNucleotideSequences

fn seqnames(&self) -> Vec<String>

Retrieve all sequence names.

fn get_sequence( &self, seqname: &str, ) -> Result<Self::Container<'_>, GRangesError>

Retrieve the Nucleotides for a particular sequence name.

fn region_map<V, F>( &self, func: &F, seqname: &str, start: Position, end: Position, ) -> Result<V, GRangesError>

where F: for<'b> Fn(&'b [u8]) -> V,

Apply an arbitrary function to the specified region.

Arguments

• func: a function that takes Bytes and processes them, returning a generic type V.
• seqname: the sequence name of the region to apply the function to.
• start: the start position of the region to apply the function to.
• end: the end position of the region to apply the function to.

fn get_sequence_length(&self, seqname: &str) -> Result<Position, GRangesError>

Get the length of a particular sequence.

type Container<'a> = Ref<'a, Nucleotides>

type Slice<'a> = &'a [u8]

fn seqlens(&self) -> Result<IndexMap<String, Position>, GRangesError>

fn region_map_into_granges<'b, C, F, V, T: 'b>( &self, granges: &'b impl AsGRangesRef<'b, C, T>, func: &F, ) -> Result<GRanges<VecRangesIndexed, Vec<V>>, GRangesError>

where V: Clone, C: IterableRangeContainer + 'b, F: Fn(<Self as Sequences>::Slice<'_>) -> V,

Create a new GRanges<C, Vec<V>> by apply the function func on the genomic ranges from granges.