Method deserialize

src/models/serializer/raw_vector_embedding.rs:85–166

(bufman: &BufferManager, offset: FileOffset)

    }

    fn deserialize(bufman: &BufferManager, offset: FileOffset) -> Result<Self, BufIoError> {
        let cursor = bufman.open_cursor()?;
        bufman.seek_with_cursor(cursor, offset.0 as u64)?;
        let id = VectorId::from(read_string(bufman, cursor)?);
        let document_id = read_opt_string(bufman, cursor)?.map(DocumentId::from);
        let dense_values_len = read_len(bufman, cursor)? as usize;
        let dense_values = if dense_values_len == 0 {
            None
        } else {
            let mut values = Vec::with_capacity(dense_values_len);
            for _ in 0..dense_values_len {
                values.push(bufman.read_f32_with_cursor(cursor)?);
            }
            Some(values)
        };
        let metadata_len = read_len(bufman, cursor)? as usize;
        let metadata = if metadata_len == 0 {
            None
        } else {
            let mut metadata = HashMap::with_capacity(metadata_len);

            for _ in 0..metadata_len {
                let field = read_string(bufman, cursor)?;
                let val = {
                    let variant = bufman.read_u8_with_cursor(cursor)?;
                    match variant {
                        0 => FieldValue::Int(bufman.read_i32_with_cursor(cursor)?),
                        1 => FieldValue::String(read_string(bufman, cursor)?),
                        other => {
                            return Err(BufIoError::Io(io::Error::new(
                                io::ErrorKind::InvalidData,
                                format!("Invalid FieldValue variant `{}`", other),
                            )))
                        }
                    }
                };
                metadata.insert(field, val);
            }

            Some(metadata)
        };

        let sparse_values_len = read_len(bufman, cursor)? as usize;
        let sparse_values = if sparse_values_len == 0 {
            None
        } else {
            let mut sparse_values = Vec::with_capacity(sparse_values_len);

            for _ in 0..sparse_values_len {
                let index = bufman.read_u32_with_cursor(cursor)?;
                let value = bufman.read_f32_with_cursor(cursor)?;
                let pair = SparsePair(index, value);
                sparse_values.push(pair);
            }

            Some(sparse_values)
        };