checkpoint

veilid-core/src/veilid_api/debug.rs

@@ -4,7 +4,6 @@
 use super::*;
 use data_encoding::BASE64URL_NOPAD;
 use routing_table::*;
-use rpc_processor::*;
 
 #[derive(Default, Debug)]
 struct DebugCache {

veilid-core/src/veilid_api/serialize_helpers.rs

@@ -1,5 +1,9 @@
 use super::*;
+pub use bytecheck::CheckBytes;
 use core::fmt::Debug;
+pub use rkyv::Archive as RkyvArchive;
+pub use rkyv::Deserialize as RkyvDeserialize;
+pub use rkyv::Serialize as RkyvSerialize;
 
 // XXX: Don't trace these functions as they are used in the transfer of API logs, which will recurse!
 
@@ -128,3 +132,79 @@ pub mod arc_serialize {
         Ok(Arc::new(T::deserialize(d)?))
     }
 }
+
+pub fn to_rkyv<T>(v: &T) -> EyreResult<Vec<u8>>
+where
+    T: RkyvSerialize<rkyv::ser::serializers::AllocSerializer<1024>>,
+{
+    Ok(rkyv::to_bytes::<T, 1024>(v)
+        .wrap_err("failed to freeze object")?
+        .to_vec())
+}
+
+pub fn from_rkyv<T>(v: Vec<u8>) -> EyreResult<T>
+where
+    T: RkyvArchive,
+    <T as RkyvArchive>::Archived:
+        for<'t> bytecheck::CheckBytes<rkyv::validation::validators::DefaultValidator<'t>>,
+    <T as RkyvArchive>::Archived:
+        rkyv::Deserialize<T, rkyv::de::deserializers::SharedDeserializeMap>,
+{
+    match rkyv::from_bytes::<T>(&v) {
+        Ok(v) => Ok(v),
+        Err(e) => {
+            bail!("failed to deserialize frozen object: {}", e);
+        }
+    }
+}
+
+pub struct RkyvEnumSet;
+
+impl<T> rkyv::with::ArchiveWith<EnumSet<T>> for RkyvEnumSet
+where
+    T: EnumSetType + EnumSetTypeWithRepr,
+    <T as EnumSetTypeWithRepr>::Repr: rkyv::Archive,
+{
+    type Archived = rkyv::Archived<<T as EnumSetTypeWithRepr>::Repr>;
+    type Resolver = rkyv::Resolver<<T as EnumSetTypeWithRepr>::Repr>;
+
+    #[inline]
+    unsafe fn resolve_with(
+        field: &EnumSet<T>,
+        pos: usize,
+        resolver: Self::Resolver,
+        out: *mut Self::Archived,
+    ) {
+        let r = field.as_repr();
+        r.resolve(pos, resolver, out);
+    }
+}
+
+impl<T, S> rkyv::with::SerializeWith<EnumSet<T>, S> for RkyvEnumSet
+where
+    S: rkyv::Fallible + ?Sized,
+    T: EnumSetType + EnumSetTypeWithRepr,
+    <T as EnumSetTypeWithRepr>::Repr: rkyv::Serialize<S>,
+{
+    fn serialize_with(field: &EnumSet<T>, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+        let r = field.as_repr();
+        r.serialize(serializer)
+    }
+}
+
+impl<T, D>
+    rkyv::with::DeserializeWith<rkyv::Archived<<T as EnumSetTypeWithRepr>::Repr>, EnumSet<T>, D>
+    for RkyvEnumSet
+where
+    D: rkyv::Fallible + ?Sized,
+    T: EnumSetType + EnumSetTypeWithRepr,
+    <T as EnumSetTypeWithRepr>::Repr: rkyv::Archive,
+    rkyv::Archived<<T as EnumSetTypeWithRepr>::Repr>: rkyv::Deserialize<EnumSet<T>, D>,
+{
+    fn deserialize_with(
+        field: &rkyv::Archived<<T as EnumSetTypeWithRepr>::Repr>,
+        deserializer: &mut D,
+    ) -> Result<EnumSet<T>, D::Error> {
+        Ok(field.deserialize(deserializer)?.into())
+    }
+}