Make creating a HVector from raw bytes a failable operation

Author: el-yawd

helix-db/src/helix_engine/vector_core/mod.rs

@@ -230,10 +230,13 @@ impl<'arena> HVector<'arena> {
     pub fn raw_vector_data_to_vec<'txn>(
         raw_vector_data: &'txn [u8],
         arena: &'arena bumpalo::Bump,
-    ) -> bumpalo::collections::Vec<'arena, f32> {
+    ) -> VectorCoreResult<bumpalo::collections::Vec<'arena, f32>> {
         let mut bump_vec = bumpalo::collections::Vec::<'arena, f32>::new_in(arena);
-        bump_vec.extend_from_slice(bytemuck::cast_slice(raw_vector_data));
-        bump_vec
+        bump_vec.extend_from_slice(bytemuck::try_cast_slice(raw_vector_data).map_err(|err| {
+            VectorError::ConversionError(format!("Error casting raw bytes to &[f32]: {}", err))
+        })?);
+
+        Ok(bump_vec)
     }
 
     pub fn from_raw_vector_data<'txn>(

helix-db/src/protocol/custom_serde/error_handling_tests.rs

@@ -228,7 +228,7 @@ mod error_handling_tests {
     fn test_vector_cast_empty_raw_data_panics() {
         let arena = Bump::new();
         let empty_data: &[u8] = &[];
-        HVector::raw_vector_data_to_vec(empty_data, &arena);
+        HVector::raw_vector_data_to_vec(empty_data, &arena).unwrap();
     }
 
     #[test]
@@ -260,12 +260,12 @@ mod error_handling_tests {
     }
 
     #[test]
-    #[should_panic(expected = "is not a multiple of size_of::<f32>()")]
+    #[should_panic]
     fn test_vector_misaligned_data_bytes_panics() {
         let arena = Bump::new();
         // 7 bytes is not a multiple of 4 (size of f32)
         let misaligned: &[u8] = &[0, 1, 2, 3, 4, 5, 6];
-        HVector::raw_vector_data_to_vec(misaligned, &arena);
+        HVector::raw_vector_data_to_vec(misaligned, &arena).unwrap();
     }
 
     #[test]

helix-db/src/protocol/custom_serde/property_based_tests.rs

@@ -344,7 +344,7 @@ mod property_based_tests {
 
             // Convert to bytes and back
             let bytes = create_vector_bytes(&data);
-            let restored = HVector::raw_vector_data_to_vec( &bytes,&arena);
+            let restored = HVector::raw_vector_data_to_vec( &bytes,&arena).unwrap();
 
             prop_assert_eq!(restored.len(), data.len());
 

helix-db/src/protocol/custom_serde/vector_serde.rs

@@ -94,7 +94,8 @@ impl<'de, 'txn, 'arena> serde::de::DeserializeSeed<'de> for VectorDeSeed<'txn, '
                     .next_element_seed(OptionPropertiesMapDeSeed { arena: self.arena })?
                     .ok_or_else(|| serde::de::Error::custom("Expected properties field"))?;
 
-                let data = HVector::raw_vector_data_to_vec(self.raw_vector_data, self.arena);
+                let data = HVector::raw_vector_data_to_vec(self.raw_vector_data, self.arena)
+                    .map_err(|err| serde::de::Error::custom(err))?;
 
                 Ok(HVector {
                     id: self.id,

helix-db/src/protocol/custom_serde/vector_serde_tests.rs

@@ -175,7 +175,7 @@ mod vector_serialization_tests {
         let original_data: Vec<f32> = (0..128).map(|i| i as f32).collect();
         let raw_bytes = create_vector_bytes(&original_data);
 
-        let casted_data = HVector::raw_vector_data_to_vec(&raw_bytes, &arena);
+        let casted_data = HVector::raw_vector_data_to_vec(&raw_bytes, &arena).unwrap();
 
         assert_eq!(casted_data.len(), 128);
         for (i, &val) in casted_data.iter().enumerate() {
@@ -189,7 +189,7 @@ mod vector_serialization_tests {
         let original_data = vec![3.14159, 2.71828, 1.41421, 1.73205];
         let raw_bytes = create_vector_bytes(&original_data);
 
-        let casted_data = HVector::raw_vector_data_to_vec(&raw_bytes, &arena);
+        let casted_data = HVector::raw_vector_data_to_vec(&raw_bytes, &arena).unwrap();
 
         assert_eq!(casted_data.len(), original_data.len());
         for (orig, casted) in original_data.iter().zip(casted_data.iter()) {