Struct NodeReader 

pub struct NodeReader<R: AsyncRead + AsyncSeek + Len> {
    pub reader: R,
    pub header: Vec<u8>,
    pub item_index: u64,
    /* private fields */
}

Incremental reader that produces typed nodes from an Old Faithful CAR stream.

Fields

reader: R

Underlying stream yielding Old Faithful CAR bytes.

header: Vec<u8>

Cached Old Faithful CAR header data.

item_index: u64

Number of Old Faithful items that have been read so far.

Implementations

impl<R: AsyncRead + Unpin + AsyncSeek + Len> NodeReader<R>

pub const fn new(reader: R) -> NodeReader<R>

Wraps an async reader and primes it for Old Faithful CAR decoding.

pub async fn read_raw_header(&mut self) -> Result<Vec<u8>, SharedError>

Returns the raw Old Faithful CAR header, fetching and caching it on first use.

pub async fn seek_to_slot(&mut self, slot: u64) -> Result<(), FirehoseError>

Seeks the underlying reader to the first Old Faithful CAR section belonging to slot, so that reading forward yields all of the slot’s nodes (transactions, entries, rewards) followed by its Block node. If slot is missing from the index (skipped on-chain), the seek advances to the next present slot.

pub async fn prime_seek_permit(&mut self)

Acquires the global seek-spacing permit ahead of a Self::seek_to_slot call, so the cross-thread pacing wait (which can queue for many seconds when hundreds of threads seek at once) happens outside any timeout the caller wraps the seek in. The permit is consumed by the next seek; an unprimed seek acquires it itself.

pub async fn next(&mut self) -> Result<RawNode, SharedError>

Reads the next raw node from the Old Faithful stream without parsing it.

pub async fn next_parsed(&mut self) -> Result<NodeWithCid, SharedError>

Reads and parses the next node, returning it paired with its Cid.

pub async fn read_until_block(&mut self) -> Result<NodesWithCids, SharedError>

Continues reading nodes until the next block is encountered.

pub const fn get_item_index(&self) -> u64

Returns the number of Old Faithful CAR items that have been yielded so far.