Function write_map_data_fast

cpp/fory/serialization/map_serializer.h:125–205

/// This is the optimized fast path for common cases like map<string, int>
template <typename K, typename V, typename MapType>
inline void write_map_data_fast(const MapType &map, WriteContext &ctx,
                                bool has_generics) {
  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");

  // write total length
  ctx.write_var_uint32(static_cast<uint32_t>(map.size()));

  if (map.empty()) {
    return;
  }

  // Determine if keys/values are declared types (no type info needed)
  const bool is_key_declared =
      has_generics && !need_to_write_type_for_field<K>();
  const bool is_val_declared =
      has_generics && !need_to_write_type_for_field<V>();

  // State for chunked writing
  size_t header_offset = 0;
  uint8_t pair_counter = 0;
  bool need_write_header = true;

  for (const auto &[key, value] : map) {
    // For fast path, we assume no null values (primitives/strings)
    // If nullability is needed, use the slow path

    if (need_write_header) {
      ctx.enter_flush_barrier();
      // reserve space for header (1 byte) + chunk size (1 byte)
      header_offset = ctx.buffer().writer_index();
      ctx.write_uint16(0); // Placeholder for header and chunk size
      uint8_t chunk_header = 0;
      if (is_key_declared) {
        chunk_header |= DECL_KEY_TYPE;
      } else {
        write_type_info<K>(ctx);
      }
      if (is_val_declared) {
        chunk_header |= DECL_VALUE_TYPE;
      } else {
        write_type_info<V>(ctx);
      }

      // write chunk header at reserved position
      ctx.buffer().unsafe_put_byte(header_offset, chunk_header);
      need_write_header = false;
    }

    // write key and value data
    if (has_generics && is_generic_type_v<K>) {
      Serializer<K>::write_data_generic(key, ctx, true);
    } else {
      Serializer<K>::write_data(key, ctx);
    }