Function read_complex_array

rust/fory-core/src/serializer/array.rs:92–140

(context: &mut ReadContext)

/// Read complex (non-primitive) array directly without intermediate Vec allocation
#[inline]
fn read_complex_array<T, const N: usize>(context: &mut ReadContext) -> Result<[T; N], Error>
where
    T: Serializer + ForyDefault,
{
    // Read collection length
    let len = context.reader.read_var_u32()? as usize;
    validate_array_length(len, N)?;
    // Handle zero-sized arrays
    if N == 0 {
        // Safe: std::mem::zeroed() is explicitly safe for zero-sized types
        return Ok(unsafe { std::mem::zeroed() });
    }
    // Handle polymorphic or shared ref types - need to use collection logic
    if T::fory_is_polymorphic() || T::fory_is_shared_ref() {
        return read_complex_array_dyn_ref(context, len);
    }
    // Read header
    let header = context.reader.read_u8()?;
    let declared = (header & DECL_ELEMENT_TYPE) != 0;
    if !declared {
        T::fory_read_type_info(context)?;
    }
    let has_null = (header & HAS_NULL) != 0;
    ensure!(
        (header & IS_SAME_TYPE) != 0,
        Error::type_error("Type inconsistent, target type is not polymorphic")
    );
    // Create uninitialized array
    let mut arr: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
    // Read elements directly into array
    if !has_null {
        for elem_slot in &mut arr[..] {
            let elem = T::fory_read_data(context)?;
            elem_slot.write(elem);
        }
    } else {
        for elem_slot in &mut arr[..] {
            let flag = context.reader.read_i8()?;
            let elem = if flag == RefFlag::Null as i8 {
                T::fory_default()
            } else {
                T::fory_read_data(context)?
            };
            elem_slot.write(elem);
        }
    }
    // Safety: all elements are now initialized
    Ok(unsafe { std::ptr::read(&arr as *const _ as *const [T; N]) })
}

/// Read complex array with dynamic/polymorphic types
#[inline]