Class ArrayCursor

src/lib/json_buffer.ts:1491–1550

}

class ArrayCursor implements IterableIterator<any> {
  private index = 0;
  private len: number;
  private start: number;

  // Optimization 1: Cache views locally to avoid 'this.buffer' lookups in the hot loop
  private u32: Uint32Array;
  private f64: Float64Array;

  constructor(private buffer: SharedJsonBufferImpl<any>, ptr: number) {
    buffer.resolvePtr(ptr);
    this.len = buffer.scratchLen;
    this.start = buffer.scratchStart;
    this.u32 = buffer.u32;
    this.f64 = buffer.f64;

    // Direct check: Type Array is 6
    if (this.u32[buffer.scratchPtr >> 2] !== 6) {
      throw new Error("Iterator must be used on an Array");
    }
  }

  [Symbol.iterator]() {
    return this;
  }

  next(): IteratorResult<any> {
    // Bounds check
    if (this.index >= this.len) {
      return { done: true, value: undefined };
    }

    // Optimization 2: Bitwise shift for *8.
    // Calculate offset: start + (index * 8)
    const offset = this.start + (this.index++ << 3);

    // Direct memory read
    const type = this.u32[offset >> 2]!;

    // Optimization 3: Inline Primitive Handling (Zero Allocation Path)
    // TYPE_NUMBER (3) is the most common primitive, check it first.
    if (type === 3) {
      const payload = this.u32[(offset + 4) >> 2]!;
      return { done: false, value: this.f64[payload >> 3] };
    }

    // TYPE_NULL (0), TYPE_TRUE (1), TYPE_FALSE (2)
    if (type <= 2) {
      // Nested ternary is faster than switch for 3 values
      const val = type === 1 ? true : (type === 2 ? false : null);
      return { done: false, value: val };
    }

    // Fallback: Objects (5, 6) & Strings (4)
    // We MUST delegate to readSlot here to get the correct Proxy or String.
    // This maintains correctness (distinct objects) while isolating the cost
    // only to complex types.
    return { done: false, value: this.buffer.readSlot(offset) };