Struct VcfReader 

pub struct VcfReader { /* private fields */ }

VCF file reader (streaming, memory-efficient)

The only way to create a VcfReader is VcfReader::from_path().

This is intentionally simple - there’s one obvious way to read a VCF file.

Implementations

impl VcfReader

pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>

Open a VCF file - handles .vcf and .vcf.gz automatically

Memory Behavior

• Opens file handle (~8KB buffer)
• Parses header (~1-10KB typically)
• Does NOT load variants into memory
• Variants are parsed on-demand as you iterate

Example

use genomicframe_core::formats::vcf::VcfReader;
use genomicframe_core::core::GenomicRecordIterator;

// Works with multi-GB files using only ~10KB RAM
let mut reader = VcfReader::from_path("variants.vcf.gz")?;

while let Some(variant) = reader.next_record()? {
    if variant.is_pass() {
        println!("{:?}", variant);
    }
}

pub fn header(&self) -> &VcfHeader

Get the VCF header metadata

pub fn annotate_with(self, index: AnnotationIndex) -> AnnotatingIterator

Create an annotating iterator that enriches variants with genomic context

This is the ergonomic way to annotate variants from BED files, GFF files, etc.

Example

use genomicframe_core::formats::vcf::VcfReader;
use genomicframe_core::interval::annotation::AnnotationIndex;

// Load gene annotations
let genes = AnnotationIndex::from_bed("genes.bed", |r| {
    r.name.clone().unwrap_or_default()
})?;

// Annotate variants as they're read
let mut reader = VcfReader::from_path("variants.vcf.gz")?;
for annotated in reader.annotate_with(genes) {
    let annotated = annotated?;
    if annotated.is_annotated() {
        println!("{:?} overlaps {}", annotated.record.position(),
                 annotated.all_annotations().join(", "));
    }
}

Trait Implementations

impl GenomicReader for VcfReader

type Metadata = VcfHeader

Metadata type for this reader

fn metadata(&self) -> &Self::Metadata

Get metadata about the genomic data (headers, contigs, etc.)

impl GenomicRecordIterator for VcfReader

type Record = VcfRecord

The record type yielded by this iterator

fn next_raw(&mut self) -> Result<Option<Vec<u8>>>

Advance to the next raw record

fn next_record(&mut self) -> Result<Option<Self::Record>>

Advance to the next record

fn collect_all(self) -> Result<Vec<Self::Record>>

where Self: Sized,

Consume the iterator and collect all records into a vector

fn chunks(self, chunk_size: usize) -> ChunkedIterator<Self>

where Self: Sized,

Process records in chunks for memory-efficient batch operations