Struct TapeRef 

pub struct TapeRef<'a> { /* private fields */ }

A cursor over the simdjson DOM tape.

TapeRef borrows both the tape and the string buffer slices from a simdjson_sys::dom_ffi::TapeView. It maintains a pos cursor that advances as values are decoded.

The lifetime 'a is tied to the crate::dom::Parser that owns the underlying memory, ensuring the tape remains valid.

Implementations

impl<'a> TapeRef<'a>

pub fn new(tape: &'a [u64], string_buf: &'a [u8]) -> Self

Create a new tape cursor positioned at index 0 (the root r node).

pub fn pos(&self) -> usize

Returns the current position in the tape.

pub fn current_word_public(&self) -> u64

Public accessor for the raw tape word (needed by serde module).

pub fn tape_type(&self) -> Option<TapeType>

Returns the type of the current tape node.

pub fn payload_public(&self) -> u64

Public accessor for payload (needed by serde module).

pub fn scope_close_idx(&self) -> usize

Returns the tape index of the closing } or ] for the current StartObject or StartArray node.

In simdjson’s tape format, the opening bracket ({ or [) stores a packed payload: the lower 32 bits are the next-sibling index (the tape position of the first element after the closing bracket), and the upper 24 bits encode the element count. The closing bracket is therefore at next_sibling - 1.

pub fn scope_count(&self) -> usize

Returns the number of direct children in the current [ / { scope.

simdjson packs the element count into bits 32–55 of the opening bracket’s tape word (mask 0xFFFFFF after a >> 32). This matches simdjson::internal::tape_ref::scope_count.

pub fn skip(&mut self, n: usize)

Advance the cursor by n tape words.

pub fn seek_public(&mut self, pos: usize)

Move the cursor to an absolute tape index.

pub fn get_string(&self) -> Result<&'a str>

Decode the string at the current position.

The string buffer layout is: 4-byte native-endian length prefix followed by raw UTF-8 bytes. The tape word payload is a byte offset into string_buf.

The returned &str has lifetime 'a (tied to the parser), so it can be used for zero-copy deserialization.

pub fn get_int64(&self) -> Result<i64>

Decode the i64 value at the current position.

The actual integer is stored in the next tape word (reinterpreted as i64 bits).

pub fn get_uint64(&self) -> Result<u64>

Decode the u64 value at the current position.

pub fn get_double(&self) -> Result<f64>

Decode the f64 value at the current position.

pub fn parse_value(&mut self) -> Result<Value<'a>>

Parse the value at the current tape position into a zero-copy Value.

After a successful call the cursor is advanced past the parsed value, ready to decode the next element.

pub fn visit<V: TapeVisitor<'a>>( &mut self, visitor: &mut V, ) -> Result<V::Output>

Visit the tape using a TapeVisitor.

This is the low-level API for custom traversal. The visitor receives structured callbacks as the tape is walked.

Trait Implementations

impl<'a> Clone for TapeRef<'a>

fn clone(&self) -> TapeRef<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for TapeRef<'a>

impl<'a> Debug for TapeRef<'a>

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

Formats the value using the given formatter.