Function read_struct_fields_impl_fast

cpp/fory/serialization/struct_serializer.h:4233–4278

/// Used when compatible mode is enabled but the remote schema matches locally.
template <typename T, size_t... Indices>
FORY_ALWAYS_INLINE void
read_struct_fields_impl_fast(T &obj, ReadContext &ctx,
                             std::index_sequence<Indices...>) {
  using Helpers = CompileTimeFieldHelpers<T>;
  constexpr size_t fixed_count = Helpers::leading_fixed_count;
  constexpr size_t fixed_bytes = Helpers::leading_fixed_size_bytes;
  constexpr size_t varint_count = Helpers::varint_count;
  constexpr size_t total_count = sizeof...(Indices);

  Buffer &buffer = ctx.buffer();

  // Phase 1: Read leading fixed-size primitives if any
  if constexpr (fixed_count > 0 && fixed_bytes > 0) {
    if (FORY_PREDICT_FALSE(!buffer.ensure_readable(
            static_cast<uint32_t>(fixed_bytes), ctx.error()))) {
      return;
    }
    // Fast read fixed-size primitives
    read_fixed_primitive_fields<T>(obj, buffer,
                                   std::make_index_sequence<fixed_count>{});
  }

  // Phase 2: Read consecutive varint primitives (int32, int64) if any
  if constexpr (varint_count > 0) {
    if (FORY_PREDICT_FALSE(buffer.has_input_stream())) {
      // Stream-backed buffers may not have all varint bytes materialized yet.
      // Fall back to per-field readers that propagate stream read errors.
      read_remaining_fields<T, fixed_count, total_count>(obj, ctx);
      return;
    }
    // Track offset locally for batch varint reading
    uint32_t offset = buffer.reader_index();
    // Fast read varint primitives (bounds checking happens in
    // get_var_uint32/64)
    read_varint_primitive_fields<T, fixed_count>(
        obj, buffer, offset, std::make_index_sequence<varint_count>{});
    // Update reader_index once after all varints
    buffer.reader_index(offset);
  }

  // Phase 3: Read remaining fields (if any) with normal path
  constexpr size_t fast_count = fixed_count + varint_count;
  if constexpr (fast_count < total_count) {
    read_remaining_fields<T, fast_count, total_count>(obj, ctx);
  }
}

/// Read struct fields with schema evolution (compatible mode)
/// Reads fields in remote schema order, dispatching by field_id to local fields