Struct GffReader 

pub struct GffReader { /* private fields */ }

GFF/GTF file reader (streaming, memory-efficient)

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

This follows the same design as VcfReader - one obvious way to read a file.

Implementations

impl GffReader

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

Open a GFF/GTF file - handles .gff, .gtf, .gff.gz, .gtf.gz automatically

Memory Behavior

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

Example

use genomicframe_core::formats::gff::GffReader;
use genomicframe_core::core::GenomicRecordIterator;

// Works with multi-GB files using only ~10KB RAM
let mut reader = GffReader::from_path("gencode.v45.gff3.gz")?;

while let Some(record) = reader.next_record()? {
    if record.feature_type == "exon" {
        println!("{:?}", record);
    }
}

pub fn header(&self) -> &GffHeader

Get the GFF header metadata

Trait Implementations

impl GenomicReader for GffReader

type Metadata = GffHeader

Metadata type for this reader

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

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

impl GenomicRecordIterator for GffReader

type Record = GffRecord

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