Function write_map_data

rust/fory-core/src/serializer/map.rs:48–154

(
    iter: I,
    length: usize,
    context: &mut WriteContext,
    has_generics: bool,
)

}

pub fn write_map_data<'a, K, V, I>(
    iter: I,
    length: usize,
    context: &mut WriteContext,
    has_generics: bool,
) -> Result<(), Error>
where
    K: Serializer,
    V: Serializer,
    I: Iterator<Item = (&'a K, &'a V)>,
{
    context.writer.write_var_u32(length as u32);
    if length == 0 {
        return Ok(());
    }
    let reserved_space = (K::fory_reserved_space() + SIZE_OF_REF_AND_TYPE) * length
        + (V::fory_reserved_space() + SIZE_OF_REF_AND_TYPE) * length;
    context.writer.reserve(reserved_space);

    if K::fory_is_polymorphic()
        || K::fory_is_shared_ref()
        || V::fory_is_polymorphic()
        || V::fory_is_shared_ref()
    {
        return write_map_data_dyn_ref(iter, context, has_generics);
    }
    let mut header_offset = 0;
    let mut pair_counter: u8 = 0;
    let mut need_write_header = true;
    let key_static_type_id = K::fory_static_type_id();
    let val_static_type_id = V::fory_static_type_id();
    let is_key_declared = has_generics && !need_to_write_type_for_field(key_static_type_id);
    let is_val_declared = has_generics && !need_to_write_type_for_field(val_static_type_id);
    for (key, value) in iter {
        let key_is_none = key.fory_is_none();
        let value_is_none = value.fory_is_none();

        if key_is_none || value_is_none {
            if !need_write_header && pair_counter > 0 {
                write_chunk_size(context, header_offset, pair_counter);
                pair_counter = 0;
                need_write_header = true;
            }

            if key_is_none && value_is_none {
                context.writer.write_u8(KEY_NULL | VALUE_NULL);
                continue;
            }

            if value_is_none {
                let mut chunk_header = VALUE_NULL;
                if is_key_declared {
                    chunk_header |= DECL_KEY_TYPE;
                    context.writer.write_u8(chunk_header);
                } else {
                    context.writer.write_u8(chunk_header);
                    K::fory_write_type_info(context)?;
                }