Method deserialize

src/models/serializer/inverted/versioned_vec.rs:73–150

(
        _dim_bufman: &BufferManager,
        data_bufmans: &BufferManagerFactory<VersionNumber>,
        file_offset: FileOffset,
        version: VersionNumber,
        _cache: &InvertedIndexCache,

    }

    fn deserialize(
        _dim_bufman: &BufferManager,
        data_bufmans: &BufferManagerFactory<VersionNumber>,
        file_offset: FileOffset,
        version: VersionNumber,
        _cache: &InvertedIndexCache,
    ) -> Result<Self, BufIoError> {
        let mut version_data: HashMap<VersionNumber, (FileOffset, Vec<u64>, VersionNumber)> =
            HashMap::new();
        let mut current_offset = file_offset;
        let mut current_version = version;

        // Read all versions into version_data
        while current_offset.0 != u32::MAX {
            let bufman = data_bufmans.get(current_version)?;
            let cursor = bufman.open_cursor()?;
            bufman.seek_with_cursor(cursor, current_offset.0 as u64)?;
            let next_offset = FileOffset(bufman.read_u32_with_cursor(cursor)?);
            let next_version = VersionNumber::from(bufman.read_u32_with_cursor(cursor)?);
            let version = VersionNumber::from(bufman.read_u32_with_cursor(cursor)?);
            let len = bufman.read_u32_with_cursor(cursor)? as usize;
            let mut list = Vec::with_capacity(len);
            for _ in 0..len {
                list.push(bufman.read_u64_with_cursor(cursor)?);
            }
            version_data.insert(version, (current_offset, list, next_version));
            current_offset = next_offset;
            current_version = next_version;
            bufman.close_cursor(cursor)?;
        }

        // Collect delete operations
        let mut deletes = Vec::new();
        for (_, list, _) in version_data.values() {
            for &item in list {
                if (item & (1 << 63)) != 0 {
                    let target_version = VersionNumber::from(((item >> 32) & 0x7FFFFFFF) as u32);
                    let target_index = (item & 0xFFFFFFFF) as usize;
                    deletes.push((target_version, target_index));
                }
            }
        }

        // Apply delete operations
        for (target_version, target_index) in deletes {
            if let Some((_, target_list, _)) = version_data.get_mut(&target_version) {
                if target_index < target_list.len() {
                    target_list[target_index] = u64::MAX;
                }
            }
        }

        // Build the VersionedVec chain
        let mut versions = Vec::new();
        let mut current_version = version;
        while let Some((_, _, next_version)) = version_data.get(&current_version) {
            versions.push(current_version);
            if *next_version == VersionNumber::from(u32::MAX) {