Function read_map_data_fast

cpp/fory/serialization/map_serializer.h:562–691

/// Read map data for non-polymorphic, non-shared-ref maps
template <typename K, typename V, typename MapType>
inline MapType read_map_data_fast(ReadContext &ctx, uint32_t length) {
  static_assert(!is_polymorphic_v<K> && !is_polymorphic_v<V>,
                "Fast path is for non-polymorphic types only");
  static_assert(!is_shared_ref_v<K> && !is_shared_ref_v<V>,
                "Fast path is for non-shared-ref types only");

  MapType result;
  if (length == 0) {
    return result;
  }
  if (FORY_PREDICT_FALSE(!reserve_map(result, ctx, length))) {
    return result;
  }

  uint32_t len_counter = 0;

  while (len_counter < length) {
    uint8_t header = ctx.read_uint8(ctx.error());
    if (FORY_PREDICT_FALSE(ctx.has_error())) {
      return MapType{};
    }

    // Handle null entries - insert with default-constructed key/value
    if ((header & KEY_NULL) && (header & VALUE_NULL)) {
      // Both null - insert with default values
      result.emplace(K{}, V{});
      len_counter++;
      continue;
    }
    if (header & KEY_NULL) {
      // Null key, non-null value
      // Java writes: header, then type info (if not declared), then value data
      bool value_declared = (header & DECL_VALUE_TYPE) != 0;
      bool track_value_ref = (header & TRACKING_VALUE_REF) != 0;

      // Read type info if not declared
      if (!value_declared) {
        read_type_info<V>(ctx);
        if (FORY_PREDICT_FALSE(ctx.has_error())) {
          return MapType{};
        }
      }

      // Read value - consume ref flag if tracking, then read data
      V value;
      if (track_value_ref) {
        value = Serializer<V>::read(ctx, RefMode::Tracking, false);
      } else {
        value = Serializer<V>::read_data(ctx);
      }
      if (FORY_PREDICT_FALSE(ctx.has_error())) {
        return MapType{};
      }
      result.emplace(K{}, std::move(value));
      len_counter++;
      continue;
    }
    if (header & VALUE_NULL) {