Compute an error when encoding/decoding in bytes

Kerollmops · Kerollmops · commit 39f360e0ae77 · 2022-07-06T18:08:12.000+02:00
diff --git a/heed-traits/src/lib.rs b/heed-traits/src/lib.rs
@@ -1,13 +1,17 @@
 use std::borrow::Cow;
+use std::error::Error as StdError;
+
+/// A boxed `Send + Sync + 'static` error.
+pub type BoxedError = Box<dyn StdError + Send + Sync + 'static>;
 
 pub trait BytesEncode<'a> {
     type EItem: ?Sized + 'a;
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<'a, [u8]>>;
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError>;
 }
 
 pub trait BytesDecode<'a> {
     type DItem: 'a;
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem>;
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError>;
 }
diff --git a/heed-types/Cargo.toml b/heed-types/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 
 [dependencies]
 bincode = { version = "1.2.1", optional = true }
-bytemuck = { version = "1.5.0", features = ["extern_crate_alloc"] }
+bytemuck = { version = "1.5.0", features = ["extern_crate_alloc", "extern_crate_std"] }
 byteorder = "1.4.2"
 heed-traits = { version = "0.7.0", path = "../heed-traits" }
 serde = { version = "1.0.117", optional = true }
diff --git a/heed-types/src/cow_slice.rs b/heed-types/src/cow_slice.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use bytemuck::{pod_collect_to_vec, try_cast_slice, AnyBitPattern, NoUninit, PodCastError};
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 /// Describes a slice that must be [memory aligned] and
 /// will be reallocated if it is not.
@@ -23,19 +23,19 @@ pub struct CowSlice<T>(std::marker::PhantomData<T>);
 impl<'a, T: NoUninit> BytesEncode<'a> for CowSlice<T> {
     type EItem = [T];
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
-        try_cast_slice(item).map(Cow::Borrowed).ok()
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        try_cast_slice(item).map(Cow::Borrowed).map_err(Into::into)
     }
 }
 
 impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for CowSlice<T> {
     type DItem = Cow<'a, [T]>;
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {
         match try_cast_slice(bytes) {
-            Ok(items) => Some(Cow::Borrowed(items)),
-            Err(PodCastError::AlignmentMismatch) => Some(Cow::Owned(pod_collect_to_vec(bytes))),
-            Err(_) => None,
+            Ok(items) => Ok(Cow::Borrowed(items)),
+            Err(PodCastError::AlignmentMismatch) => Ok(Cow::Owned(pod_collect_to_vec(bytes))),
+            Err(error) => Err(error.into()),
         }
     }
 }
diff --git a/heed-types/src/cow_type.rs b/heed-types/src/cow_type.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use bytemuck::{bytes_of, bytes_of_mut, try_from_bytes, AnyBitPattern, NoUninit, PodCastError};
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 /// Describes a type that must be [memory aligned] and
 /// will be reallocated if it is not.
@@ -29,23 +29,23 @@ pub struct CowType<T>(std::marker::PhantomData<T>);
 impl<'a, T: NoUninit> BytesEncode<'a> for CowType<T> {
     type EItem = T;
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
-        Some(Cow::Borrowed(bytes_of(item)))
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        Ok(Cow::Borrowed(bytes_of(item)))
     }
 }
 
 impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for CowType<T> {
     type DItem = Cow<'a, T>;
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {
         match try_from_bytes(bytes) {
-            Ok(item) => Some(Cow::Borrowed(item)),
+            Ok(item) => Ok(Cow::Borrowed(item)),
             Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) => {
                 let mut item = T::zeroed();
                 bytes_of_mut(&mut item).copy_from_slice(bytes);
-                Some(Cow::Owned(item))
+                Ok(Cow::Owned(item))
             }
-            Err(_) => None,
+            Err(error) => Err(error.into()),
         }
     }
 }
diff --git a/heed-types/src/lib.rs b/heed-types/src/lib.rs
@@ -37,6 +37,8 @@ mod serde_bincode;
 #[cfg(feature = "serde-json")]
 mod serde_json;
 
+use heed_traits::BoxedError;
+
 pub use self::cow_slice::CowSlice;
 pub use self::cow_type::CowType;
 pub use self::integer::*;
@@ -62,8 +64,8 @@ pub struct DecodeIgnore;
 impl heed_traits::BytesDecode<'_> for DecodeIgnore {
     type DItem = ();
 
-    fn bytes_decode(_bytes: &[u8]) -> Option<Self::DItem> {
-        Some(())
+    fn bytes_decode(_bytes: &[u8]) -> Result<Self::DItem, BoxedError> {
+        Ok(())
     }
 }
 
diff --git a/heed-types/src/owned_slice.rs b/heed-types/src/owned_slice.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use bytemuck::{try_cast_slice, AnyBitPattern, NoUninit};
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 use crate::CowSlice;
 
@@ -23,15 +23,15 @@ pub struct OwnedSlice<T>(std::marker::PhantomData<T>);
 impl<'a, T: NoUninit> BytesEncode<'a> for OwnedSlice<T> {
     type EItem = [T];
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
-        try_cast_slice(item).map(Cow::Borrowed).ok()
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        try_cast_slice(item).map(Cow::Borrowed).map_err(Into::into)
     }
 }
 
 impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for OwnedSlice<T> {
     type DItem = Vec<T>;
 
-    fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {
+    fn bytes_decode(bytes: &[u8]) -> Result<Self::DItem, BoxedError> {
         CowSlice::<T>::bytes_decode(bytes).map(Cow::into_owned)
     }
 }
diff --git a/heed-types/src/owned_type.rs b/heed-types/src/owned_type.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use bytemuck::{bytes_of, AnyBitPattern, NoUninit};
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 use crate::CowType;
 
@@ -29,15 +29,15 @@ pub struct OwnedType<T>(std::marker::PhantomData<T>);
 impl<'a, T: NoUninit> BytesEncode<'a> for OwnedType<T> {
     type EItem = T;
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
-        Some(Cow::Borrowed(bytes_of(item)))
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        Ok(Cow::Borrowed(bytes_of(item)))
     }
 }
 
 impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for OwnedType<T> {
     type DItem = T;
 
-    fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {
+    fn bytes_decode(bytes: &[u8]) -> Result<Self::DItem, BoxedError> {
         CowType::<T>::bytes_decode(bytes).map(Cow::into_owned)
     }
 }
diff --git a/heed-types/src/serde_bincode.rs b/heed-types/src/serde_bincode.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 use serde::{Deserialize, Serialize};
 
 /// Describes a type that is [`Serialize`]/[`Deserialize`] and uses `bincode` to do so.
@@ -14,8 +14,8 @@ where
 {
     type EItem = T;
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
-        bincode::serialize(item).map(Cow::Owned).ok()
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        bincode::serialize(item).map(Cow::Owned).map_err(Into::into)
     }
 }
 
@@ -25,8 +25,8 @@ where
 {
     type DItem = T;
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
-        bincode::deserialize(bytes).ok()
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {
+        bincode::deserialize(bytes).map_err(Into::into)
     }
 }
 
diff --git a/heed-types/src/serde_json.rs b/heed-types/src/serde_json.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 use serde::{Deserialize, Serialize};
 
 /// Describes a type that is [`Serialize`]/[`Deserialize`] and uses `serde_json` to do so.
@@ -14,8 +14,8 @@ where
 {
     type EItem = T;
 
-    fn bytes_encode(item: &Self::EItem) -> Option<Cow<[u8]>> {
-        serde_json::to_vec(item).map(Cow::Owned).ok()
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        serde_json::to_vec(item).map(Cow::Owned).map_err(Into::into)
     }
 }
 
@@ -25,8 +25,8 @@ where
 {
     type DItem = T;
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
-        serde_json::from_slice(bytes).ok()
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {
+        serde_json::from_slice(bytes).map_err(Into::into)
     }
 }
 
diff --git a/heed-types/src/str.rs b/heed-types/src/str.rs
@@ -1,22 +1,22 @@
 use std::borrow::Cow;
 
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 /// Describes an [`prim@str`].
 pub struct Str;
 
 impl BytesEncode<'_> for Str {
     type EItem = str;
 
-    fn bytes_encode(item: &Self::EItem) -> Option<Cow<[u8]>> {
-        Some(Cow::Borrowed(item.as_bytes()))
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        Ok(Cow::Borrowed(item.as_bytes()))
     }
 }
 
 impl<'a> BytesDecode<'a> for Str {
     type DItem = &'a str;
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
-        std::str::from_utf8(bytes).ok()
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {
+        std::str::from_utf8(bytes).map_err(Into::into)
     }
 }
diff --git a/heed-types/src/unaligned_slice.rs b/heed-types/src/unaligned_slice.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use bytemuck::{try_cast_slice, AnyBitPattern, NoUninit};
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 /// Describes a type that is totally borrowed and doesn't
 /// depends on any [memory alignment].
@@ -16,16 +16,16 @@ pub struct UnalignedSlice<T>(std::marker::PhantomData<T>);
 impl<'a, T: NoUninit> BytesEncode<'a> for UnalignedSlice<T> {
     type EItem = [T];
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
-        try_cast_slice(item).map(Cow::Borrowed).ok()
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        try_cast_slice(item).map(Cow::Borrowed).map_err(Into::into)
     }
 }
 
 impl<'a, T: AnyBitPattern> BytesDecode<'a> for UnalignedSlice<T> {
     type DItem = &'a [T];
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
-        try_cast_slice(bytes).ok()
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {
+        try_cast_slice(bytes).map_err(Into::into)
     }
 }
 
diff --git a/heed-types/src/unaligned_type.rs b/heed-types/src/unaligned_type.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use bytemuck::{bytes_of, try_from_bytes, AnyBitPattern, NoUninit};
-use heed_traits::{BytesDecode, BytesEncode};
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 /// Describes a slice that is totally borrowed and doesn't
 /// depends on any [memory alignment].
@@ -22,16 +22,16 @@ pub struct UnalignedType<T>(std::marker::PhantomData<T>);
 impl<'a, T: NoUninit> BytesEncode<'a> for UnalignedType<T> {
     type EItem = T;
 
-    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
-        Some(Cow::Borrowed(bytes_of(item)))
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        Ok(Cow::Borrowed(bytes_of(item)))
     }
 }
 
 impl<'a, T: AnyBitPattern> BytesDecode<'a> for UnalignedType<T> {
     type DItem = &'a T;
 
-    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
-        try_from_bytes(bytes).ok()
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {
+        try_from_bytes(bytes).map_err(Into::into)
     }
 }
 
diff --git a/heed-types/src/unit.rs b/heed-types/src/unit.rs
@@ -1,26 +1,27 @@
 use std::borrow::Cow;
 
-use heed_traits::{BytesDecode, BytesEncode};
+use bytemuck::PodCastError;
+use heed_traits::{BoxedError, BytesDecode, BytesEncode};
 
 /// Describes the `()` type.
 pub struct Unit;
 
 impl BytesEncode<'_> for Unit {
     type EItem = ();
 
-    fn bytes_encode(_item: &Self::EItem) -> Option<Cow<[u8]>> {
-        Some(Cow::Borrowed(&[]))
+    fn bytes_encode(_item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+        Ok(Cow::Borrowed(&[]))
     }
 }
 
 impl BytesDecode<'_> for Unit {
     type DItem = ();
 
-    fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {
+    fn bytes_decode(bytes: &[u8]) -> Result<Self::DItem, BoxedError> {
         if bytes.is_empty() {
-            Some(())
+            Ok(())
         } else {
-            None
+            Err(PodCastError::SizeMismatch.into())
         }
     }
 }
diff --git a/heed/src/db/polymorph.rs b/heed/src/db/polymorph.rs
diff --git a/heed/src/iter/iter.rs b/heed/src/iter/iter.rs
diff --git a/heed/src/iter/prefix.rs b/heed/src/iter/prefix.rs
diff --git a/heed/src/iter/range.rs b/heed/src/iter/range.rs
diff --git a/heed/src/lazy_decode.rs b/heed/src/lazy_decode.rs
diff --git a/heed/src/lib.rs b/heed/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`	`3`	`use bytemuck::{pod_collect_to_vec, try_cast_slice, AnyBitPattern, NoUninit, PodCastError};`
`4`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`4`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`5`	`5`
`6`	`6`	`/// Describes a slice that must be [memory aligned] and`
`7`	`7`	`/// will be reallocated if it is not.`
`@@ -23,19 +23,19 @@ pub struct CowSlice<T>(std::marker::PhantomData<T>);`
`23`	`23`	`impl<'a, T: NoUninit> BytesEncode<'a> for CowSlice<T> {`
`24`	`24`	`type EItem = [T];`
`25`	`25`
`26`		`- fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {`
`27`		`- try_cast_slice(item).map(Cow::Borrowed).ok()`
	`26`	`+ fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`27`	`+ try_cast_slice(item).map(Cow::Borrowed).map_err(Into::into)`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for CowSlice<T> {`
`32`	`32`	`type DItem = Cow<'a, [T]>;`
`33`	`33`
`34`		`- fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {`
	`34`	`+ fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {`
`35`	`35`	`match try_cast_slice(bytes) {`
`36`		`- Ok(items) => Some(Cow::Borrowed(items)),`
`37`		`- Err(PodCastError::AlignmentMismatch) => Some(Cow::Owned(pod_collect_to_vec(bytes))),`
`38`		`- Err(_) => None,`
	`36`	`+ Ok(items) => Ok(Cow::Borrowed(items)),`
	`37`	`+ Err(PodCastError::AlignmentMismatch) => Ok(Cow::Owned(pod_collect_to_vec(bytes))),`
	`38`	`+ Err(error) => Err(error.into()),`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`	`3`	`use bytemuck::{bytes_of, bytes_of_mut, try_from_bytes, AnyBitPattern, NoUninit, PodCastError};`
`4`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`4`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`5`	`5`
`6`	`6`	`/// Describes a type that must be [memory aligned] and`
`7`	`7`	`/// will be reallocated if it is not.`
`@@ -29,23 +29,23 @@ pub struct CowType<T>(std::marker::PhantomData<T>);`
`29`	`29`	`impl<'a, T: NoUninit> BytesEncode<'a> for CowType<T> {`
`30`	`30`	`type EItem = T;`
`31`	`31`
`32`		`- fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {`
`33`		`- Some(Cow::Borrowed(bytes_of(item)))`
	`32`	`+ fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`33`	`+ Ok(Cow::Borrowed(bytes_of(item)))`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for CowType<T> {`
`38`	`38`	`type DItem = Cow<'a, T>;`
`39`	`39`
`40`		`- fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {`
	`40`	`+ fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {`
`41`	`41`	`match try_from_bytes(bytes) {`
`42`		`- Ok(item) => Some(Cow::Borrowed(item)),`
	`42`	`+ Ok(item) => Ok(Cow::Borrowed(item)),`
`43`	`43`	`Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) => {`
`44`	`44`	`let mut item = T::zeroed();`
`45`	`45`	`bytes_of_mut(&mut item).copy_from_slice(bytes);`
`46`		`- Some(Cow::Owned(item))`
	`46`	`+ Ok(Cow::Owned(item))`
`47`	`47`	`}`
`48`		`- Err(_) => None,`
	`48`	`+ Err(error) => Err(error.into()),`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`	`3`	`use bytemuck::{try_cast_slice, AnyBitPattern, NoUninit};`
`4`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`4`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`5`	`5`
`6`	`6`	`use crate::CowSlice;`
`7`	`7`
`@@ -23,15 +23,15 @@ pub struct OwnedSlice<T>(std::marker::PhantomData<T>);`
`23`	`23`	`impl<'a, T: NoUninit> BytesEncode<'a> for OwnedSlice<T> {`
`24`	`24`	`type EItem = [T];`
`25`	`25`
`26`		`- fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {`
`27`		`- try_cast_slice(item).map(Cow::Borrowed).ok()`
	`26`	`+ fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`27`	`+ try_cast_slice(item).map(Cow::Borrowed).map_err(Into::into)`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for OwnedSlice<T> {`
`32`	`32`	`type DItem = Vec<T>;`
`33`	`33`
`34`		`- fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {`
	`34`	`+ fn bytes_decode(bytes: &[u8]) -> Result<Self::DItem, BoxedError> {`
`35`	`35`	`CowSlice::<T>::bytes_decode(bytes).map(Cow::into_owned)`
`36`	`36`	`}`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`	`3`	`use bytemuck::{bytes_of, AnyBitPattern, NoUninit};`
`4`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`4`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`5`	`5`
`6`	`6`	`use crate::CowType;`
`7`	`7`
`@@ -29,15 +29,15 @@ pub struct OwnedType<T>(std::marker::PhantomData<T>);`
`29`	`29`	`impl<'a, T: NoUninit> BytesEncode<'a> for OwnedType<T> {`
`30`	`30`	`type EItem = T;`
`31`	`31`
`32`		`- fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {`
`33`		`- Some(Cow::Borrowed(bytes_of(item)))`
	`32`	`+ fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`33`	`+ Ok(Cow::Borrowed(bytes_of(item)))`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`impl<'a, T: AnyBitPattern + NoUninit> BytesDecode<'a> for OwnedType<T> {`
`38`	`38`	`type DItem = T;`
`39`	`39`
`40`		`- fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {`
	`40`	`+ fn bytes_decode(bytes: &[u8]) -> Result<Self::DItem, BoxedError> {`
`41`	`41`	`CowType::<T>::bytes_decode(bytes).map(Cow::into_owned)`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`3`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`4`	`4`	`use serde::{Deserialize, Serialize};`
`5`	`5`
`6`	`6`	/// Describes a type that is [`Serialize`]/[`Deserialize`] and uses `bincode` to do so.
`@@ -14,8 +14,8 @@ where`
`14`	`14`	`{`
`15`	`15`	`type EItem = T;`
`16`	`16`
`17`		`- fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {`
`18`		`- bincode::serialize(item).map(Cow::Owned).ok()`
	`17`	`+ fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`18`	`+ bincode::serialize(item).map(Cow::Owned).map_err(Into::into)`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`@@ -25,8 +25,8 @@ where`
`25`	`25`	`{`
`26`	`26`	`type DItem = T;`
`27`	`27`
`28`		`- fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {`
`29`		`- bincode::deserialize(bytes).ok()`
	`28`	`+ fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {`
	`29`	`+ bincode::deserialize(bytes).map_err(Into::into)`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -1,22 +1,22 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`3`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`4`	`4`
`5`	`5`	/// Describes an [`prim@str`].
`6`	`6`	`pub struct Str;`
`7`	`7`
`8`	`8`	`impl BytesEncode<'_> for Str {`
`9`	`9`	`type EItem = str;`
`10`	`10`
`11`		`- fn bytes_encode(item: &Self::EItem) -> Option<Cow<[u8]>> {`
`12`		`- Some(Cow::Borrowed(item.as_bytes()))`
	`11`	`+ fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`12`	`+ Ok(Cow::Borrowed(item.as_bytes()))`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`impl<'a> BytesDecode<'a> for Str {`
`17`	`17`	`type DItem = &'a str;`
`18`	`18`
`19`		`- fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {`
`20`		`- std::str::from_utf8(bytes).ok()`
	`19`	`+ fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {`
	`20`	`+ std::str::from_utf8(bytes).map_err(Into::into)`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`	`3`	`use bytemuck::{bytes_of, try_from_bytes, AnyBitPattern, NoUninit};`
`4`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`4`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`5`	`5`
`6`	`6`	`/// Describes a slice that is totally borrowed and doesn't`
`7`	`7`	`/// depends on any [memory alignment].`
`@@ -22,16 +22,16 @@ pub struct UnalignedType<T>(std::marker::PhantomData<T>);`
`22`	`22`	`impl<'a, T: NoUninit> BytesEncode<'a> for UnalignedType<T> {`
`23`	`23`	`type EItem = T;`
`24`	`24`
`25`		`- fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {`
`26`		`- Some(Cow::Borrowed(bytes_of(item)))`
	`25`	`+ fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`26`	`+ Ok(Cow::Borrowed(bytes_of(item)))`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`impl<'a, T: AnyBitPattern> BytesDecode<'a> for UnalignedType<T> {`
`31`	`31`	`type DItem = &'a T;`
`32`	`32`
`33`		`- fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {`
`34`		`- try_from_bytes(bytes).ok()`
	`33`	`+ fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, BoxedError> {`
	`34`	`+ try_from_bytes(bytes).map_err(Into::into)`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -1,26 +1,27 @@`
`1`	`1`	`use std::borrow::Cow;`
`2`	`2`
`3`		`-use heed_traits::{BytesDecode, BytesEncode};`
	`3`	`+use bytemuck::PodCastError;`
	`4`	`+use heed_traits::{BoxedError, BytesDecode, BytesEncode};`
`4`	`5`
`5`	`6`	/// Describes the `()` type.
`6`	`7`	`pub struct Unit;`
`7`	`8`
`8`	`9`	`impl BytesEncode<'_> for Unit {`
`9`	`10`	`type EItem = ();`
`10`	`11`
`11`		`- fn bytes_encode(_item: &Self::EItem) -> Option<Cow<[u8]>> {`
`12`		`- Some(Cow::Borrowed(&[]))`
	`12`	`+ fn bytes_encode(_item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {`
	`13`	`+ Ok(Cow::Borrowed(&[]))`
`13`	`14`	`}`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`impl BytesDecode<'_> for Unit {`
`17`	`18`	`type DItem = ();`
`18`	`19`
`19`		`- fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {`
	`20`	`+ fn bytes_decode(bytes: &[u8]) -> Result<Self::DItem, BoxedError> {`
`20`	`21`	`if bytes.is_empty() {`
`21`		`- Some(())`
	`22`	`+ Ok(())`
`22`	`23`	`} else {`
`23`		`- None`
	`24`	`+ Err(PodCastError::SizeMismatch.into())`
`24`	`25`	`}`
`25`	`26`	`}`
`26`	`27`	`}`