Function read_union_configured_map_data

cpp/fory/serialization/union_serializer.h:550–598

template <typename MapType, typename SpecProvider, int8_t KeyNode,
          int8_t ValueNode>
MapType read_union_configured_map_data(ReadContext &ctx) {
  using Key = key_type_t<MapType>;
  using Value = mapped_type_t<MapType>;
  uint32_t length = ctx.read_var_uint32(ctx.error());
  MapType result;
  if (length == 0) {
    return result;
  }
  if (FORY_PREDICT_FALSE(!reserve_map(result, ctx, length))) {
    return result;
  }
  uint32_t read_count = 0;
  while (read_count < length && !ctx.has_error()) {
    uint8_t header = ctx.read_uint8(ctx.error());
    uint8_t chunk_size = ctx.read_uint8(ctx.error());
    if (FORY_PREDICT_FALSE(ctx.has_error())) {
      return result;
    }
    const bool key_decl = (header & DECL_KEY_TYPE) != 0;
    const bool value_decl = (header & DECL_VALUE_TYPE) != 0;
    if (!key_decl) {
      (void)ctx.read_any_type_info(ctx.error());
    }
    if (!value_decl) {
      (void)ctx.read_any_type_info(ctx.error());
    }
    for (uint8_t i = 0; i < chunk_size && read_count < length; ++i) {
      Key key = [&]() {
        if constexpr (KeyNode >= 0) {
          return read_union_configured_value<Key, SpecProvider, KeyNode>(
              ctx, RefMode::None, false);
        } else {
          return Serializer<Key>::read_data(ctx);
        }
      }();
      Value value = [&]() {
        if constexpr (ValueNode >= 0) {
          return read_union_configured_value<Value, SpecProvider, ValueNode>(
              ctx, RefMode::None, false);
        } else {
          return Serializer<Value>::read_data(ctx);
        }
      }();
      result.emplace(std::move(key), std::move(value));
      ++read_count;
    }
  }
  return result;
}

template <typename ValueType, typename SpecProvider, int8_t NodeIndex>
void write_union_configured_value(const ValueType &value, WriteContext &ctx,