Struct FastqReader 

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

Slab-based FASTQ reader over any Read input.

The reader frames four-line FASTQ records from a reusable byte slab. Records crossing slab boundaries are carried into the next read. Returned batches borrow from the reader and must be consumed before calling next_batch again.

Implementations

impl<R: Read> FastqReader<R>

pub fn new(reader: R) -> Self

Create a reader with FastqConfig::default.

Examples found in repository

examples/fastq_chunk_sink.rs (line 47)

fn main() -> Result<()> {
    let stdin = io::stdin();
    let mut reader = FastqReader::new(stdin.lock());
    let config = FastqChunkConfig::new(10_000_000).min_records(40_000);
    let mut sink = ReadBuffer::default();

    sink.reserve_records(config.estimated_records(150));
    while let Some(stats) = reader.next_chunk_with_sink(config, &mut sink)? {
        let checksum: usize = sink
            .reads
            .iter()
            .map(|read| read.name.len() ^ read.seq.len() ^ read.qual.len())
            .sum();
        eprintln!(
            "chunk first_record={} records={} bases={} checksum={}",
            stats.first_record_index(),
            stats.records(),
            stats.bases(),
            checksum
        );

        // Downstream tools typically hand `sink.reads` to alignment or another
        // processing stage here, then reuse the allocation for the next chunk.
        sink.clear();
        sink.reserve_records(config.estimated_records(150));
    }

    Ok(())
}

pub fn with_config(reader: R, config: FastqConfig) -> Self

Create a reader with explicit configuration.

pub fn into_inner(self) -> R

Return the wrapped reader.

pub fn next_batch(&mut self) -> Result<Option<FastqBatch<'_>>>

Read the next batch of FASTQ records.

Returns Ok(None) at EOF. Format errors include byte offset, record index, and line index when the failing location is known.

pub fn visit_records<F>(&mut self, visit: F) -> Result<()>

where F: FnMut(FastqVisitRecord<'_>) -> Result<()>,

Visit every record in the stream without building a batch side table.

This is the fastest public parse-only path for single-pass consumers. It still honors FastqConfig::validate for record structure, but it yields individual records and does not perform paired-end identifier validation. Use next_batch, interleaved_pairs, or PairedFastqReader when pair validation is required.

pub fn count_records(&mut self) -> Result<FastqStats>

Count remaining records and bases without building record views.

This consumes the reader to EOF. It validates the same four-line FASTQ structure as visit_records when FastqConfig::validate is enabled, but it avoids the per-record visitor callback and borrowed-record construction.

pub fn next_chunk_with_sink<S>( &mut self, config: FastqChunkConfig, sink: &mut S, ) -> Result<Option<FastqChunkStats>>

where S: FastqRecordSink,

Emit one resumable chunk of FASTQ records into a caller-owned sink.

This is the low-overhead path for downstream tools that already have a target output representation. It does not build the RecordRef side table used by next_batch, and it returns after the configured chunk limit so callers can interleave parsing with their own pipeline stages.

Returns Ok(None) only when EOF is reached before emitting another record. A subsequent call resumes at the first unconsumed record.

Examples found in repository

examples/fastq_chunk_sink.rs (line 52)

fn main() -> Result<()> {
    let stdin = io::stdin();
    let mut reader = FastqReader::new(stdin.lock());
    let config = FastqChunkConfig::new(10_000_000).min_records(40_000);
    let mut sink = ReadBuffer::default();

    sink.reserve_records(config.estimated_records(150));
    while let Some(stats) = reader.next_chunk_with_sink(config, &mut sink)? {
        let checksum: usize = sink
            .reads
            .iter()
            .map(|read| read.name.len() ^ read.seq.len() ^ read.qual.len())
            .sum();
        eprintln!(
            "chunk first_record={} records={} bases={} checksum={}",
            stats.first_record_index(),
            stats.records(),
            stats.bases(),
            checksum
        );

        // Downstream tools typically hand `sink.reads` to alignment or another
        // processing stage here, then reuse the allocation for the next chunk.
        sink.clear();
        sink.reserve_records(config.estimated_records(150));
    }

    Ok(())
}

Trait Implementations

impl<R: Debug> Debug for FastqReader<R>

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

Formats the value using the given formatter.