feat: Use try_reserve to handle allocation error in lender

Author: jhg

README.md

@@ -34,7 +34,8 @@ impl Counter {
 /// Ownership will NOT control the heap-allocated memory until own it back.
 #[no_mangle]
 pub extern fn counter_new(value: u8) -> *mut Counter {
-    return opaque_pointer::raw(Counter::new());
+    return opaque_pointer::raw(Counter::new())
+            .expect("Error trying to lend a pointer");
 }
 
 /// Drop (free memory of) Rust's Counter object as usually.

src/lender.rs

@@ -9,6 +9,8 @@ use lazy_static::lazy_static;
 use std::collections::HashSet;
 use std::sync::{RwLock, RwLockWriteGuard};
 
+use crate::error::PointerError;
+
 lazy_static! {
     static ref LENT_POINTERS: RwLock<HashSet<usize>> = RwLock::new(HashSet::new());
 }
@@ -35,9 +37,14 @@ pub(super) fn is_lent<T>(pointer: *const T) -> bool {
 /// If the [`RwLock`] used is poisoned, but it only happens if a panic happens
 /// while holding it. And it's specially reviewed and in a small module to
 /// avoid panics while holding it.
-pub(super) fn lend<T>(pointer: *const T) {
-    // Use try_reserve in nightly until it is available in stable
-    writable_lent_pointers().insert(pointer as usize);
+pub(super) fn lend<T>(pointer: *const T) -> Result<(), PointerError> {
+    let mut lent_pointers = writable_lent_pointers();
+    if let Err(error) = lent_pointers.try_reserve(1) {
+        log::error!("Can not alloc memory to lent a pointer: {error}");
+        return Err(PointerError::from(error));
+    }
+    lent_pointers.insert(pointer as usize);
+    return Ok(());
 }
 
 /// Use only when [`own_back`](crate::own_back) memory.

src/lib.rs

@@ -34,11 +34,11 @@ mod validation;
 /// To back to manage the memory with ownership use [`own_back<T>()`].
 #[cfg(any(feature = "alloc", feature = "std"))]
 #[inline]
-pub fn raw<T>(data: T) -> *mut T {
+pub fn raw<T>(data: T) -> Result<*mut T, PointerError> {
     let pointer = Box::into_raw(Box::new(data));
     #[cfg(all(feature = "std", feature = "lender"))]
-    lender::lend(pointer);
-    return pointer;
+    lender::lend(pointer)?;
+    return Ok(pointer);
 }
 
 /// Call to [`own_back<T>()`] ignoring the result.
@@ -47,7 +47,7 @@ pub fn raw<T>(data: T) -> *mut T {
 ///
 /// ```no_run
 /// # let value = 0;
-/// # let pointer = opaque_pointer::raw(value);
+/// # let pointer = opaque_pointer::raw(value).unwrap();
 /// std::mem::drop(unsafe { opaque_pointer::own_back(pointer) });
 /// ```
 ///

tests/pointer.rs

@@ -19,7 +19,7 @@ impl TestIt {
 
 #[test]
 fn own_back() {
-    let pointer = opaque_pointer::raw(TestIt::new(2));
+    let pointer = opaque_pointer::raw(TestIt::new(2)).unwrap();
     let test_it = unsafe { opaque_pointer::own_back(pointer).unwrap() };
     assert_eq!(test_it.get(), 2);
 }
@@ -37,15 +37,15 @@ fn own_back_invalid_pointer() {
 
 #[test]
 fn immutable_reference() {
-    let pointer = opaque_pointer::raw(TestIt::new(2));
+    let pointer = opaque_pointer::raw(TestIt::new(2)).unwrap();
     let object = unsafe { opaque_pointer::object(pointer).unwrap() };
     assert_eq!(object.get(), 2);
     unsafe { opaque_pointer::own_back(pointer).unwrap() };
 }
 
 #[test]
 fn mutable_reference() {
-    let pointer = opaque_pointer::raw(TestIt::new(2));
+    let pointer = opaque_pointer::raw(TestIt::new(2)).unwrap();
     let object = unsafe { opaque_pointer::mut_object(pointer).unwrap() };
     object.add(3);
     assert_eq!(object.get(), 5);