cusbf::detail::FastxBufferReader Class Reference

FASTA/FASTQ parser over a contiguous in-memory buffer. More...

#include <fastx_buffer_reader.hpp>

Public Member Functions
	FastxBufferReader (std::string_view data, std::string_view source_name="<buffer>")
	Constructs a reader over a contiguous in-memory FASTA/FASTQ buffer.
Result< bool >	nextRecord (FastxRecord &record)
	Reads the next record into record.
std::string_view	buffer () const noexcept
	Entire mmap or owned buffer backing this reader.
Result< std::optional< RecordRange > >	appendNextRecord (FastxRecord &record, std::string &sequence, std::string_view &buffer)
	Parses one record with optional zero-copy sequence views for single-line FASTA.

Detailed Description

FASTA/FASTQ parser over a contiguous in-memory buffer.

Definition at line 15 of file fastx_buffer_reader.hpp.

Constructor & Destructor Documentation

FastxBufferReader()

cusbf::detail::FastxBufferReader::FastxBufferReader ( std::string_view  data, std::string_view  source_name = "<buffer>"  )

inlineexplicit

Constructs a reader over a contiguous in-memory FASTA/FASTQ buffer.

Parameters

data	Entire file or chunk payload.
source_name	Label used in parse error messages.

Definition at line 23 of file fastx_buffer_reader.hpp.

        : data_(data), source_name_(source_name) {}

Member Function Documentation

appendNextRecord()

Result< std::optional< RecordRange > > cusbf::detail::FastxBufferReader::appendNextRecord ( FastxRecord &  record, std::string &  sequence, std::string_view &  buffer  )

inline

Parses one record with optional zero-copy sequence views for single-line FASTA.

When the sequence fits one mmap line, returns a RecordRange into buffer instead of appending to sequence. Otherwise appends sequence bytes to sequence and returns an owned range offset.

Parameters

record	Output header (sequence may stay empty on zero-copy path).
sequence	Growing buffer for multi-line or owned FASTA sequence data.
buffer	Set to the full mmap view on first zero-copy record.

Returns

Record byte range, std::nullopt at end-of-buffer, or an error.

Definition at line 91 of file fastx_buffer_reader.hpp.

                                                                                       {
        record.header.clear();
        record.sequence.clear();
 
        const auto header = readHeaderLine();
        if (!header) {
            return Err(header.error());
        }
        if (header->empty()) {
            return std::nullopt;
        }
 
        const char header_tag = header->front();
        if (format_ == FastxFormat::unknown) {
            if (header_tag == '>') {
                format_ = FastxFormat::fasta;
            } else if (header_tag == '@') {
                format_ = FastxFormat::fastq;
            } else {
                return Err(
                    parseError("expected FASTA or FASTQ header", fastx_column_at(*header, 0))
                );
            }
        }
 
        const char expected_header = format_ == FastxFormat::fasta ? '>' : '@';
        if (header_tag != expected_header) {
            return Err(parseError(
                "mixed FASTA and FASTQ records are not supported", fastx_column_at(*header, 0)
            ));
        }
 
        record.header.assign(header->substr(1));
        if (format_ == FastxFormat::fasta) {
            const uint64_t sequence_offset = static_cast<uint64_t>(position_);
            const std::string_view line = readLine();
            if (line.empty()) {
                return Err(parseError("FASTA record missing sequence", fastx_column_at(line, 0)));
            }
            if (!line.empty() && line.front() == '>') {
                pending_header_.assign(line);
                return Err(parseError("FASTA record missing sequence", fastx_column_at(line, 0)));
            }
 
            if (position_ < data_.size() && data_[position_] != '>') {
                const uint64_t owned_offset = static_cast<uint64_t>(sequence.size());
                sequence.append(line.data(), line.size());
                CUSBF_TRY(readFastaSequence(sequence));
                return RecordRange{
                    owned_offset,
                    static_cast<uint64_t>(sequence.size()) - owned_offset,
                };
            }
 
            if (position_ < data_.size() && data_[position_] == '>') {
                pending_header_.assign(readLine());
            }
 
            if (buffer.empty()) {
                buffer = data_;
            }
            return RecordRange{sequence_offset, static_cast<uint64_t>(line.size())};
        }
 
        const uint64_t sequence_offset = static_cast<uint64_t>(sequence.size());
        CUSBF_TRY(readFastqSequence(sequence));
        return RecordRange{
            sequence_offset,
            static_cast<uint64_t>(sequence.size()) - sequence_offset,
        };
    }

Here is the call graph for this function:

buffer()

std::string_view cusbf::detail::FastxBufferReader::buffer ( ) const

inlinenoexcept

Entire mmap or owned buffer backing this reader.

Definition at line 74 of file fastx_buffer_reader.hpp.

                                                         {
        return data_;
    }

Here is the caller graph for this function:

nextRecord()

Result< bool > cusbf::detail::FastxBufferReader::nextRecord ( FastxRecord &  record )

inline

Reads the next record into record.

Parameters

record

Output record, cleared before fill.

Returns

false at end-of-buffer, true when a record was read, or an error.

Definition at line 32 of file fastx_buffer_reader.hpp.

                                                               {
        record.header.clear();
        record.sequence.clear();
 
        const auto header = readHeaderLine();
        if (!header) {
            return Err(header.error());
        }
        if (header->empty()) {
            return false;
        }
 
        const char header_tag = header->front();
        if (format_ == FastxFormat::unknown) {
            if (header_tag == '>') {
                format_ = FastxFormat::fasta;
            } else if (header_tag == '@') {
                format_ = FastxFormat::fastq;
            } else {
                return Err(
                    parseError("expected FASTA or FASTQ header", fastx_column_at(*header, 0))
                );
            }
        }
 
        const char expected_header = format_ == FastxFormat::fasta ? '>' : '@';
        if (header_tag != expected_header) {
            return Err(parseError(
                "mixed FASTA and FASTQ records are not supported", fastx_column_at(*header, 0)
            ));
        }
 
        record.header.assign(header->substr(1));
        if (format_ == FastxFormat::fasta) {
            CUSBF_TRY(readFastaSequence(record.sequence));
        } else {
            CUSBF_TRY(readFastqSequence(record.sequence));
        }
        return true;
    }

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• fastx_buffer_reader.hpp