IntoOwned for ownedref

libafl/src/bolts/ownedref.rs

@@ -5,6 +5,13 @@ use alloc::{boxed::Box, vec::Vec};
 use core::{clone::Clone, fmt::Debug};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+/// Trait to convert into an Owned type
+pub trait IntoOwned {
+    fn is_owned(&self) -> bool;
+
+    fn into_owned(self) -> Self;
+}
+
 /// Wrap a reference and convert to a Box on serialize
 #[derive(Clone, Debug)]
 pub enum OwnedRef<'a, T>
@@ -55,6 +62,25 @@ where
     }
 }
 
+impl<'a, T> IntoOwned for OwnedRef<'a, T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedRef::Ref(_) => false,
+            OwnedRef::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedRef::Ref(r) => OwnedRef::Owned(Box::new(r.clone())),
+            OwnedRef::Owned(v) => OwnedRef::Owned(v),
+        }
+    }
+}
+
 /// Wrap a mutable reference and convert to a Box on serialize
 #[derive(Debug)]
 pub enum OwnedRefMut<'a, T: 'a + ?Sized> {
@@ -104,6 +130,25 @@ impl<'a, T: Sized> AsMut<T> for OwnedRefMut<'a, T> {
     }
 }
 
+impl<'a, T> IntoOwned for OwnedRefMut<'a, T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedRefMut::Ref(_) => false,
+            OwnedRefMut::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedRefMut::Ref(r) => OwnedRefMut::Owned(Box::new(r.clone())),
+            OwnedRefMut::Owned(v) => OwnedRefMut::Owned(v),
+        }
+    }
+}
+
 /// Wrap a slice and convert to a Vec on serialize
 #[derive(Clone, Debug)]
 pub enum OwnedSlice<'a, T: 'a + Sized> {
@@ -144,6 +189,25 @@ impl<'a, T: Sized> OwnedSlice<'a, T> {
     }
 }
 
+impl<'a, T> IntoOwned for OwnedSlice<'a, T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedSlice::Ref(_) => false,
+            OwnedSlice::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedSlice::Ref(r) => OwnedSlice::Owned(r.to_vec()),
+            OwnedSlice::Owned(v) => OwnedSlice::Owned(v),
+        }
+    }
+}
+
 /// Wrap a mutable slice and convert to a Vec on serialize
 #[derive(Debug)]
 pub enum OwnedSliceMut<'a, T: 'a + Sized> {
@@ -183,7 +247,7 @@ impl<'a, T: Sized> OwnedSliceMut<'a, T> {
         }
     }
 
-    pub fn as_mut_slice(&mut self) -> &[T] {
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
         match self {
             OwnedSliceMut::Ref(r) => r,
             OwnedSliceMut::Owned(v) => v.as_mut_slice(),
@@ -191,6 +255,25 @@ impl<'a, T: Sized> OwnedSliceMut<'a, T> {
     }
 }
 
+impl<'a, T> IntoOwned for OwnedSliceMut<'a, T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedSliceMut::Ref(_) => false,
+            OwnedSliceMut::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedSliceMut::Ref(r) => OwnedSliceMut::Owned(r.to_vec()),
+            OwnedSliceMut::Owned(v) => OwnedSliceMut::Owned(v),
+        }
+    }
+}
+
 /// Wrap a C-style pointer and convert to a Box on serialize
 #[derive(Clone, Debug)]
 pub enum OwnedPtr<T: Sized> {
@@ -228,6 +311,25 @@ impl<T: Sized> AsRef<T> for OwnedPtr<T> {
     }
 }
 
+impl<T> IntoOwned for OwnedPtr<T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedPtr::Ptr(_) => false,
+            OwnedPtr::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedPtr::Ptr(p) => unsafe { OwnedPtr::Owned(Box::new(p.as_ref().unwrap().clone())) },
+            OwnedPtr::Owned(v) => OwnedPtr::Owned(v),
+        }
+    }
+}
+
 /// Wrap a C-style mutable pointer and convert to a Box on serialize
 #[derive(Clone, Debug)]
 pub enum OwnedPtrMut<T: Sized> {
@@ -274,6 +376,27 @@ impl<T: Sized> AsMut<T> for OwnedPtrMut<T> {
     }
 }
 
+impl<T> IntoOwned for OwnedPtrMut<T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedPtrMut::Ptr(_) => false,
+            OwnedPtrMut::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedPtrMut::Ptr(p) => unsafe {
+                OwnedPtrMut::Owned(Box::new(p.as_ref().unwrap().clone()))
+            },
+            OwnedPtrMut::Owned(v) => OwnedPtrMut::Owned(v),
+        }
+    }
+}
+
 /// Wrap a C-style pointer to an array (with size= and convert to a Vec on serialize
 #[derive(Clone, Debug)]
 pub enum OwnedArrayPtr<T: Sized> {
@@ -311,6 +434,27 @@ impl<T: Sized> OwnedArrayPtr<T> {
     }
 }
 
+impl<T> IntoOwned for OwnedArrayPtr<T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedArrayPtr::ArrayPtr(_) => false,
+            OwnedArrayPtr::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedArrayPtr::ArrayPtr(p) => unsafe {
+                OwnedArrayPtr::Owned(core::slice::from_raw_parts(p.0, p.1).to_vec())
+            },
+            OwnedArrayPtr::Owned(v) => OwnedArrayPtr::Owned(v),
+        }
+    }
+}
+
 /// Wrap a C-style mutable pointer to an array (with size= and convert to a Vec on serialize
 #[derive(Clone, Debug)]
 pub enum OwnedArrayPtrMut<T: Sized> {
@@ -354,3 +498,24 @@ impl<T: Sized> OwnedArrayPtrMut<T> {
         }
     }
 }
+
+impl<T> IntoOwned for OwnedArrayPtrMut<T>
+where
+    T: Sized + Clone,
+{
+    fn is_owned(&self) -> bool {
+        match self {
+            OwnedArrayPtrMut::ArrayPtr(_) => false,
+            OwnedArrayPtrMut::Owned(_) => true,
+        }
+    }
+
+    fn into_owned(self) -> Self {
+        match self {
+            OwnedArrayPtrMut::ArrayPtr(p) => unsafe {
+                OwnedArrayPtrMut::Owned(core::slice::from_raw_parts(p.0, p.1).to_vec())
+            },
+            OwnedArrayPtrMut::Owned(v) => OwnedArrayPtrMut::Owned(v),
+        }
+    }
+}