SYS-OSS/FRET-LibAFL
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor ownedref

Browse Source
This commit is contained in:
Andrea Fioraldi 2021-04-26 10:17:42 +02:00
parent f25862cb90
commit 1829fcf191
4 changed files with 107 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
libafl/src/bolts/ownedref.rs
View File

@ -7,64 +7,74 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
/// Wrap a reference and convert to a Box on serialize /// Wrap a reference and convert to a Box on serialize
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum Ptr<'a, T: 'a + ?Sized> { pub enum OwnedRef<'a, T>
where
T: 'a + ?Sized,
{
Ref(&'a T), Ref(&'a T),
Owned(Box<T>), Owned(Box<T>),
} }
impl<'a, T: 'a + ?Sized + Serialize> Serialize for Ptr<'a, T> { impl<'a, T> Serialize for OwnedRef<'a, T>
where
T: 'a + ?Sized + Serialize,
{
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
{ {
match self { match self {
Ptr::Ref(r) => r.serialize(se), OwnedRef::Ref(r) => r.serialize(se),
Ptr::Owned(b) => b.serialize(se), OwnedRef::Owned(b) => b.serialize(se),
} }
} }
} }
impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for Ptr<'a, T> impl<'de, 'a, T> Deserialize<'de> for OwnedRef<'a, T>
where where
T: 'a + ?Sized,
Box<T>: Deserialize<'de>, Box<T>: Deserialize<'de>,
{ {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(deserializer).map(Ptr::Owned) Deserialize::deserialize(deserializer).map(OwnedRef::Owned)
} }
} }
impl<'a, T: Sized> AsRef<T> for Ptr<'a, T> { impl<'a, T> AsRef<T> for OwnedRef<'a, T>
where
T: Sized,
{
fn as_ref(&self) -> &T { fn as_ref(&self) -> &T {
match self { match self {
Ptr::Ref(r) => r, OwnedRef::Ref(r) => r,
Ptr::Owned(v) => v.as_ref(), OwnedRef::Owned(v) => v.as_ref(),
} }
} }
} }
/// Wrap a mutable reference and convert to a Box on serialize /// Wrap a mutable reference and convert to a Box on serialize
#[derive(Debug)] #[derive(Debug)]
pub enum PtrMut<'a, T: 'a + ?Sized> { pub enum OwnedRefMut<'a, T: 'a + ?Sized> {
Ref(&'a mut T), Ref(&'a mut T),
Owned(Box<T>), Owned(Box<T>),
} }
impl<'a, T: 'a + ?Sized + Serialize> Serialize for PtrMut<'a, T> { impl<'a, T: 'a + ?Sized + Serialize> Serialize for OwnedRefMut<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
{ {
match self { match self {
PtrMut::Ref(r) => r.serialize(se), OwnedRefMut::Ref(r) => r.serialize(se),
PtrMut::Owned(b) => b.serialize(se), OwnedRefMut::Owned(b) => b.serialize(se),
} }
} }
} }
impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for PtrMut<'a, T> impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for OwnedRefMut<'a, T>
where where
Box<T>: Deserialize<'de>, Box<T>: Deserialize<'de>,
{ {
@ -72,48 +82,48 @@ where
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(deserializer).map(PtrMut::Owned) Deserialize::deserialize(deserializer).map(OwnedRefMut::Owned)
} }
} }
impl<'a, T: Sized> AsRef<T> for PtrMut<'a, T> { impl<'a, T: Sized> AsRef<T> for OwnedRefMut<'a, T> {
fn as_ref(&self) -> &T { fn as_ref(&self) -> &T {
match self { match self {
PtrMut::Ref(r) => r, OwnedRefMut::Ref(r) => r,
PtrMut::Owned(v) => v.as_ref(), OwnedRefMut::Owned(v) => v.as_ref(),
} }
} }
} }
impl<'a, T: Sized> AsMut<T> for PtrMut<'a, T> { impl<'a, T: Sized> AsMut<T> for OwnedRefMut<'a, T> {
fn as_mut(&mut self) -> &mut T { fn as_mut(&mut self) -> &mut T {
match self { match self {
PtrMut::Ref(r) => r, OwnedRefMut::Ref(r) => r,
PtrMut::Owned(v) => v.as_mut(), OwnedRefMut::Owned(v) => v.as_mut(),
} }
} }
} }
/// Wrap a slice and convert to a Vec on serialize /// Wrap a slice and convert to a Vec on serialize
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum Slice<'a, T: 'a + Sized> { pub enum OwnedSlice<'a, T: 'a + Sized> {
Ref(&'a [T]), Ref(&'a [T]),
Owned(Vec<T>), Owned(Vec<T>),
} }
impl<'a, T: 'a + Sized + Serialize> Serialize for Slice<'a, T> { impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedSlice<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
{ {
match self { match self {
Slice::Ref(r) => r.serialize(se), OwnedSlice::Ref(r) => r.serialize(se),
Slice::Owned(b) => b.serialize(se), OwnedSlice::Owned(b) => b.serialize(se),
} }
} }
} }
impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for Slice<'a, T> impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for OwnedSlice<'a, T>
where where
Vec<T>: Deserialize<'de>, Vec<T>: Deserialize<'de>,
{ {
@ -121,39 +131,39 @@ where
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(deserializer).map(Slice::Owned) Deserialize::deserialize(deserializer).map(OwnedSlice::Owned)
} }
} }
impl<'a, T: Sized> Slice<'a, T> { impl<'a, T: Sized> OwnedSlice<'a, T> {
pub fn as_slice(&self) -> &[T] { pub fn as_slice(&self) -> &[T] {
match self { match self {
Slice::Ref(r) => r, OwnedSlice::Ref(r) => r,
Slice::Owned(v) => v.as_slice(), OwnedSlice::Owned(v) => v.as_slice(),
} }
} }
} }
/// Wrap a mutable slice and convert to a Vec on serialize /// Wrap a mutable slice and convert to a Vec on serialize
#[derive(Debug)] #[derive(Debug)]
pub enum SliceMut<'a, T: 'a + Sized> { pub enum OwnedSliceMut<'a, T: 'a + Sized> {
Ref(&'a mut [T]), Ref(&'a mut [T]),
Owned(Vec<T>), Owned(Vec<T>),
} }
impl<'a, T: 'a + Sized + Serialize> Serialize for SliceMut<'a, T> { impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedSliceMut<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
{ {
match self { match self {
SliceMut::Ref(r) => r.serialize(se), OwnedSliceMut::Ref(r) => r.serialize(se),
SliceMut::Owned(b) => b.serialize(se), OwnedSliceMut::Owned(b) => b.serialize(se),
} }
} }
} }
impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for SliceMut<'a, T> impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for OwnedSliceMut<'a, T>
where where
Vec<T>: Deserialize<'de>, Vec<T>: Deserialize<'de>,
{ {
@ -161,34 +171,34 @@ where
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(deserializer).map(SliceMut::Owned) Deserialize::deserialize(deserializer).map(OwnedSliceMut::Owned)
} }
} }
impl<'a, T: Sized> SliceMut<'a, T> { impl<'a, T: Sized> OwnedSliceMut<'a, T> {
pub fn as_slice(&self) -> &[T] { pub fn as_slice(&self) -> &[T] {
match self { match self {
SliceMut::Ref(r) => r, OwnedSliceMut::Ref(r) => r,
SliceMut::Owned(v) => v.as_slice(), OwnedSliceMut::Owned(v) => v.as_slice(),
} }
} }
pub fn as_mut_slice(&mut self) -> &[T] { pub fn as_mut_slice(&mut self) -> &[T] {
match self { match self {
SliceMut::Ref(r) => r, OwnedSliceMut::Ref(r) => r,
SliceMut::Owned(v) => v.as_mut_slice(), OwnedSliceMut::Owned(v) => v.as_mut_slice(),
} }
} }
} }
/// Wrap a C-style pointer and convert to a Box on serialize /// Wrap a C-style pointer and convert to a Box on serialize
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum Cptr<T: Sized> { pub enum OwnedPtr<T: Sized> {
Cptr(*const T), Ptr(*const T),
Owned(Box<T>), Owned(Box<T>),
} }
impl<T: Sized + Serialize> Serialize for Cptr<T> { impl<T: Sized + Serialize> Serialize for OwnedPtr<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -197,7 +207,7 @@ impl<T: Sized + Serialize> Serialize for Cptr<T> {
} }
} }
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for Cptr<T> impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedPtr<T>
where where
Vec<T>: Deserialize<'de>, Vec<T>: Deserialize<'de>,
{ {
@ -205,27 +215,27 @@ where
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(de).map(Cptr::Owned) Deserialize::deserialize(de).map(OwnedPtr::Owned)
} }
} }
impl<T: Sized> AsRef<T> for Cptr<T> { impl<T: Sized> AsRef<T> for OwnedPtr<T> {
fn as_ref(&self) -> &T { fn as_ref(&self) -> &T {
match self { match self {
Cptr::Cptr(p) => unsafe { p.as_ref().unwrap() }, OwnedPtr::Ptr(p) => unsafe { p.as_ref().unwrap() },
Cptr::Owned(v) => v.as_ref(), OwnedPtr::Owned(v) => v.as_ref(),
} }
} }
} }
/// Wrap a C-style mutable pointer and convert to a Box on serialize /// Wrap a C-style mutable pointer and convert to a Box on serialize
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum CptrMut<T: Sized> { pub enum OwnedPtrMut<T: Sized> {
Cptr(*mut T), Ptr(*mut T),
Owned(Box<T>), Owned(Box<T>),
} }
impl<T: Sized + Serialize> Serialize for CptrMut<T> { impl<T: Sized + Serialize> Serialize for OwnedPtrMut<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -234,7 +244,7 @@ impl<T: Sized + Serialize> Serialize for CptrMut<T> {
} }
} }
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for CptrMut<T> impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedPtrMut<T>
where where
Vec<T>: Deserialize<'de>, Vec<T>: Deserialize<'de>,
{ {
@ -242,36 +252,36 @@ where
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(de).map(CptrMut::Owned) Deserialize::deserialize(de).map(OwnedPtrMut::Owned)
} }
} }
impl<T: Sized> AsRef<T> for CptrMut<T> { impl<T: Sized> AsRef<T> for OwnedPtrMut<T> {
fn as_ref(&self) -> &T { fn as_ref(&self) -> &T {
match self { match self {
CptrMut::Cptr(p) => unsafe { p.as_ref().unwrap() }, OwnedPtrMut::Ptr(p) => unsafe { p.as_ref().unwrap() },
CptrMut::Owned(b) => b.as_ref(), OwnedPtrMut::Owned(b) => b.as_ref(),
} }
} }
} }
impl<T: Sized> AsMut<T> for CptrMut<T> { impl<T: Sized> AsMut<T> for OwnedPtrMut<T> {
fn as_mut(&mut self) -> &mut T { fn as_mut(&mut self) -> &mut T {
match self { match self {
CptrMut::Cptr(p) => unsafe { p.as_mut().unwrap() }, OwnedPtrMut::Ptr(p) => unsafe { p.as_mut().unwrap() },
CptrMut::Owned(b) => b.as_mut(), OwnedPtrMut::Owned(b) => b.as_mut(),
} }
} }
} }
/// Wrap a C-style pointer to an array (with size= and convert to a Vec on serialize /// Wrap a C-style pointer to an array (with size= and convert to a Vec on serialize
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum Array<T: Sized> { pub enum OwnedArrayPtr<T: Sized> {
Cptr((*const T, usize)), ArrayPtr((*const T, usize)),
Owned(Vec<T>), Owned(Vec<T>),
} }
impl<T: Sized + Serialize> Serialize for Array<T> { impl<T: Sized + Serialize> Serialize for OwnedArrayPtr<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -280,7 +290,7 @@ impl<T: Sized + Serialize> Serialize for Array<T> {
} }
} }
impl<'de, T: Sized + Serialize> Deserialize<'de> for Array<T> impl<'de, T: Sized + Serialize> Deserialize<'de> for OwnedArrayPtr<T>
where where
Vec<T>: Deserialize<'de>, Vec<T>: Deserialize<'de>,
{ {
@ -288,27 +298,27 @@ where
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(de).map(Array::Owned) Deserialize::deserialize(de).map(OwnedArrayPtr::Owned)
} }
} }
impl<T: Sized> Array<T> { impl<T: Sized> OwnedArrayPtr<T> {
pub fn as_slice(&self) -> &[T] { pub fn as_slice(&self) -> &[T] {
match self { match self {
Array::Cptr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, OwnedArrayPtr::ArrayPtr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) },
Array::Owned(v) => v.as_slice(), OwnedArrayPtr::Owned(v) => v.as_slice(),
} }
} }
} }
/// Wrap a C-style mutable pointer to an array (with size= and convert to a Vec on serialize /// Wrap a C-style mutable pointer to an array (with size= and convert to a Vec on serialize
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum ArrayMut<T: Sized> { pub enum OwnedArrayPtrMut<T: Sized> {
Cptr((*mut T, usize)), ArrayPtr((*mut T, usize)),
Owned(Vec<T>), Owned(Vec<T>),
} }
impl<T: Sized + Serialize> Serialize for ArrayMut<T> { impl<T: Sized + Serialize> Serialize for OwnedArrayPtrMut<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -317,7 +327,7 @@ impl<T: Sized + Serialize> Serialize for ArrayMut<T> {
} }
} }
impl<'de, T: Sized + Serialize> Deserialize<'de> for ArrayMut<T> impl<'de, T: Sized + Serialize> Deserialize<'de> for OwnedArrayPtrMut<T>
where where
Vec<T>: Deserialize<'de>, Vec<T>: Deserialize<'de>,
{ {
@ -325,22 +335,22 @@ where
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
Deserialize::deserialize(de).map(ArrayMut::Owned) Deserialize::deserialize(de).map(OwnedArrayPtrMut::Owned)
} }
} }
impl<T: Sized> ArrayMut<T> { impl<T: Sized> OwnedArrayPtrMut<T> {
pub fn as_slice(&self) -> &[T] { pub fn as_slice(&self) -> &[T] {
match self { match self {
ArrayMut::Cptr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) }, OwnedArrayPtrMut::ArrayPtr(p) => unsafe { core::slice::from_raw_parts(p.0, p.1) },
ArrayMut::Owned(v) => v.as_slice(), OwnedArrayPtrMut::Owned(v) => v.as_slice(),
} }
} }
pub fn as_mut_slice(&mut self) -> &mut [T] { pub fn as_mut_slice(&mut self) -> &mut [T] {
match self { match self {
ArrayMut::Cptr(p) => unsafe { core::slice::from_raw_parts_mut(p.0, p.1) }, OwnedArrayPtrMut::ArrayPtr(p) => unsafe { core::slice::from_raw_parts_mut(p.0, p.1) },
ArrayMut::Owned(v) => v.as_mut_slice(), OwnedArrayPtrMut::Owned(v) => v.as_mut_slice(),
} }
} }
} }

7
libafl/src/inputs/bytes.rs
View File

@ -12,7 +12,8 @@ use std::{
}; };
use crate::{ use crate::{
inputs::{HasBytesVec, HasLen, HasTargetBytes, Input, TargetBytes}, bolts::ownedref::OwnedSlice,
inputs::{HasBytesVec, HasLen, HasTargetBytes, Input},
Error, Error,
}; };
@ -69,8 +70,8 @@ impl HasBytesVec for BytesInput {
impl HasTargetBytes for BytesInput { impl HasTargetBytes for BytesInput {
#[inline] #[inline]
fn target_bytes(&self) -> TargetBytes { fn target_bytes(&self) -> OwnedSlice<u8> {
TargetBytes::Ref(&self.bytes) OwnedSlice::Ref(&self.bytes)
} }
} }

22
libafl/src/inputs/mod.rs
View File

@ -14,7 +14,7 @@ use std::{
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::Error; use crate::{bolts::ownedref::OwnedSlice, Error};
/// An input for the target /// An input for the target
pub trait Input: Clone + serde::Serialize + serde::de::DeserializeOwned + Debug { pub trait Input: Clone + serde::Serialize + serde::de::DeserializeOwned + Debug {
@ -60,22 +60,8 @@ pub trait Input: Clone + serde::Serialize + serde::de::DeserializeOwned + Debug
pub struct NopInput {} pub struct NopInput {}
impl Input for NopInput {} impl Input for NopInput {}
impl HasTargetBytes for NopInput { impl HasTargetBytes for NopInput {
fn target_bytes(&self) -> TargetBytes { fn target_bytes(&self) -> OwnedSlice<u8> {
TargetBytes::Owned(vec![0]) OwnedSlice::Owned(vec![0])
}
}
pub enum TargetBytes<'a> {
Ref(&'a [u8]),
Owned(Vec<u8>),
}
impl<'a> TargetBytes<'a> {
pub fn as_slice(&self) -> &[u8] {
match self {
TargetBytes::Ref(r) => r,
TargetBytes::Owned(v) => v.as_slice(),
}
} }
} }
@ -84,7 +70,7 @@ impl<'a> TargetBytes<'a> {
/// Instead, it can be used as bytes input for a target /// Instead, it can be used as bytes input for a target
pub trait HasTargetBytes { pub trait HasTargetBytes {
/// Target bytes, that can be written to a target /// Target bytes, that can be written to a target
fn target_bytes(&self) -> TargetBytes; fn target_bytes(&self) -> OwnedSlice<u8>;
} }
/// Contains an internal bytes Vector /// Contains an internal bytes Vector

22
libafl/src/observers/map.rs
View File

@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
use crate::{ use crate::{
bolts::{ bolts::{
ownedref::{ArrayMut, Cptr}, ownedref::{OwnedArrayPtrMut, OwnedPtr},
tuples::Named, tuples::Named,
}, },
observers::Observer, observers::Observer,
@ -63,7 +63,7 @@ pub struct StdMapObserver<T>
where where
T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned, T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned,
{ {
map: ArrayMut<T>, map: OwnedArrayPtrMut<T>,
initial: T, initial: T,
name: String, name: String,
} }
@ -127,7 +127,7 @@ where
assert!(map.len() >= len); assert!(map.len() >= len);
let initial = if map.is_empty() { T::default() } else { map[0] }; let initial = if map.is_empty() { T::default() } else { map[0] };
Self { Self {
map: ArrayMut::Cptr((map.as_mut_ptr(), len)), map: OwnedArrayPtrMut::ArrayPtr((map.as_mut_ptr(), len)),
name: name.to_string(), name: name.to_string(),
initial, initial,
} }
@ -137,7 +137,7 @@ where
pub fn new_owned(name: &'static str, map: Vec<T>) -> Self { pub fn new_owned(name: &'static str, map: Vec<T>) -> Self {
let initial = if map.is_empty() { T::default() } else { map[0] }; let initial = if map.is_empty() { T::default() } else { map[0] };
Self { Self {
map: ArrayMut::Owned(map), map: OwnedArrayPtrMut::Owned(map),
name: name.to_string(), name: name.to_string(),
initial, initial,
} }
@ -149,7 +149,7 @@ where
pub unsafe fn new_from_ptr(name: &'static str, map_ptr: *mut T, len: usize) -> Self { pub unsafe fn new_from_ptr(name: &'static str, map_ptr: *mut T, len: usize) -> Self {
let initial = if len > 0 { *map_ptr } else { T::default() }; let initial = if len > 0 { *map_ptr } else { T::default() };
StdMapObserver { StdMapObserver {
map: ArrayMut::Cptr((map_ptr, len)), map: OwnedArrayPtrMut::ArrayPtr((map_ptr, len)),
name: name.to_string(), name: name.to_string(),
initial, initial,
} }
@ -164,8 +164,8 @@ pub struct VariableMapObserver<T>
where where
T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned, T: Default + Copy + 'static + serde::Serialize + serde::de::DeserializeOwned,
{ {
map: ArrayMut<T>, map: OwnedArrayPtrMut<T>,
size: Cptr<usize>, size: OwnedPtr<usize>,
initial: T, initial: T,
name: String, name: String,
} }
@ -233,8 +233,8 @@ where
pub fn new(name: &'static str, map: &'static mut [T], size: *const usize) -> Self { pub fn new(name: &'static str, map: &'static mut [T], size: *const usize) -> Self {
let initial = if map.is_empty() { T::default() } else { map[0] }; let initial = if map.is_empty() { T::default() } else { map[0] };
Self { Self {
map: ArrayMut::Cptr((map.as_mut_ptr(), map.len())), map: OwnedArrayPtrMut::ArrayPtr((map.as_mut_ptr(), map.len())),
size: Cptr::Cptr(size), size: OwnedPtr::Ptr(size),
name: name.into(), name: name.into(),
initial, initial,
} }
@ -251,8 +251,8 @@ where
) -> Self { ) -> Self {
let initial = if max_len > 0 { *map_ptr } else { T::default() }; let initial = if max_len > 0 { *map_ptr } else { T::default() };
VariableMapObserver { VariableMapObserver {
map: ArrayMut::Cptr((map_ptr, max_len)), map: OwnedArrayPtrMut::ArrayPtr((map_ptr, max_len)),
size: Cptr::Cptr(size_ptr), size: OwnedPtr::Ptr(size_ptr),
name: name.into(), name: name.into(),
initial, initial,
} }