Complete refactor of the FFI to use handles instead of pointers.

src/ffi/static_data/move_data.rs

@@ -1,4 +1,5 @@
-use crate::ffi::{ffi_arc_dyn_getter, BorrowedPtr, ExternPointer, IdentifiablePointer, NativeResult, OwnedPtr};
+use crate::ffi::ffi_handle::{FFIHandle, FromFFIHandle};
+use crate::ffi::{ffi_handle_arc_dyn_getter, ExternPointer, FFIResult, NonOwnedPtrString, OwnedPtrString};
 use crate::static_data::{
     EffectParameter, MoveCategory, MoveData, MoveDataImpl, MoveTarget, SecondaryEffect, SecondaryEffectImpl,
     TypeIdentifier,
@@ -7,7 +8,6 @@ use crate::StringKey;
 use anyhow::anyhow;
 use hashbrown::HashSet;
 use std::ffi::{c_char, CStr, CString};
-use std::ptr::drop_in_place;
 use std::sync::Arc;
 
 /// Instantiates a new move.
@@ -21,27 +21,27 @@ unsafe extern "C" fn move_data_new(
     base_usages: u8,
     target: MoveTarget,
     priority: i8,
-    secondary_effect: *mut Box<dyn SecondaryEffect>,
+    secondary_effect: FFIHandle<Arc<dyn SecondaryEffect>>,
     flags: *const *const c_char,
     flags_length: usize,
-) -> NativeResult<IdentifiablePointer<Arc<dyn MoveData>>> {
+) -> FFIResult<FFIHandle<Arc<dyn MoveData>>> {
     let flags = std::slice::from_raw_parts(flags, flags_length);
     let name: StringKey = match CStr::from_ptr(name).to_str() {
         Ok(name) => name.into(),
-        Err(_) => return NativeResult::err_from_str("Unable to convert name to string"),
+        Err(_) => return FFIResult::err_from_str("Unable to convert name to string"),
     };
     let mut flags_set: HashSet<StringKey> = HashSet::with_capacity(flags_length);
     for flag in flags {
         let flag = match CStr::from_ptr(*flag).to_str() {
             Ok(flag) => flag,
-            Err(_) => return NativeResult::err_from_str("Unable to convert flag to string"),
+            Err(_) => return FFIResult::err_from_str("Unable to convert flag to string"),
         };
         flags_set.insert(flag.into());
     }
-    let secondary_effect = if secondary_effect.is_null() {
+    let secondary_effect = if secondary_effect.is_none() {
         None
     } else {
-        Some(*Box::from_raw(secondary_effect))
+        Some(secondary_effect.from_ffi_handle())
     };
     let a: Arc<dyn MoveData> = Arc::new(MoveDataImpl::new(
         &name,
@@ -55,39 +55,37 @@ unsafe extern "C" fn move_data_new(
         secondary_effect,
         flags_set,
     ));
-    NativeResult::ok(a.into())
-}
-
-/// Drops a reference counted move.
-#[no_mangle]
-unsafe extern "C" fn move_data_drop(ptr: OwnedPtr<Arc<dyn MoveData>>) {
-    drop_in_place(ptr)
+    FFIResult::ok(FFIHandle::get_handle(a.into()))
 }
 
 /// The name of the move.
 #[no_mangle]
-unsafe extern "C" fn move_data_name(ptr: ExternPointer<Arc<dyn MoveData>>) -> NativeResult<OwnedPtr<c_char>> {
-    let name = ptr.as_ref().name();
+unsafe extern "C" fn move_data_name(ptr: FFIHandle<Arc<dyn MoveData>>) -> FFIResult<OwnedPtrString> {
+    let move_data = ptr.from_ffi_handle();
+    let name = move_data.name();
     match CString::new(name.str()) {
-        Ok(name) => NativeResult::ok(name.into_raw()),
-        Err(_) => NativeResult::err_from_str("Unable to convert name to string"),
+        Ok(name) => FFIResult::ok(name.into_raw()),
+        Err(_) => FFIResult::err_from_str("Unable to convert name to string"),
     }
 }
 
-ffi_arc_dyn_getter!(MoveData, move_type, TypeIdentifier);
-ffi_arc_dyn_getter!(MoveData, category, MoveCategory);
-ffi_arc_dyn_getter!(MoveData, base_power, u8);
-ffi_arc_dyn_getter!(MoveData, accuracy, u8);
-ffi_arc_dyn_getter!(MoveData, base_usages, u8);
-ffi_arc_dyn_getter!(MoveData, target, MoveTarget);
-ffi_arc_dyn_getter!(MoveData, priority, i8);
+ffi_handle_arc_dyn_getter!(MoveData, move_type, TypeIdentifier);
+ffi_handle_arc_dyn_getter!(MoveData, category, MoveCategory);
+ffi_handle_arc_dyn_getter!(MoveData, base_power, u8);
+ffi_handle_arc_dyn_getter!(MoveData, accuracy, u8);
+ffi_handle_arc_dyn_getter!(MoveData, base_usages, u8);
+ffi_handle_arc_dyn_getter!(MoveData, target, MoveTarget);
+ffi_handle_arc_dyn_getter!(MoveData, priority, i8);
 
 /// The optional secondary effect the move has.
 #[no_mangle]
 unsafe extern "C" fn move_data_secondary_effect(
-    ptr: ExternPointer<Arc<dyn MoveData>>,
-) -> IdentifiablePointer<Box<dyn SecondaryEffect>> {
-    ptr.as_ref().secondary_effect().into()
+    ptr: FFIHandle<Arc<dyn MoveData>>,
+) -> FFIHandle<Arc<dyn SecondaryEffect>> {
+    match ptr.from_ffi_handle().secondary_effect() {
+        Some(secondary_effect) => FFIHandle::get_handle(secondary_effect.clone().into()),
+        None => FFIHandle::none(),
+    }
 }
 
 /// Arbitrary flags that can be applied to the move.
@@ -101,28 +99,22 @@ unsafe extern "C" fn move_data_has_flag(ptr: ExternPointer<Arc<dyn MoveData>>, f
 #[no_mangle]
 unsafe extern "C" fn secondary_effect_new(
     chance: f32,
-    effect_name: BorrowedPtr<c_char>,
-    parameters: *mut OwnedPtr<Arc<EffectParameter>>,
+    effect_name: NonOwnedPtrString,
+    parameters: *mut FFIHandle<Arc<EffectParameter>>,
     parameters_length: usize,
-) -> IdentifiablePointer<Box<dyn SecondaryEffect>> {
+) -> FFIHandle<Box<dyn SecondaryEffect>> {
     let parameter_slice = std::slice::from_raw_parts(parameters, parameters_length);
     let mut parameters = Vec::with_capacity(parameters_length);
     for parameter in parameter_slice {
-        parameters.push(*Box::from_raw(*parameter))
+        parameters.push(parameter.from_ffi_handle())
     }
 
-    let b: Box<dyn SecondaryEffect> = Box::new(SecondaryEffectImpl::new(
+    let b: Arc<dyn SecondaryEffect> = Arc::new(SecondaryEffectImpl::new(
         chance,
         CStr::from_ptr(effect_name).into(),
         parameters,
     ));
-    b.into()
-}
-
-/// Drop a secondary effect.
-#[no_mangle]
-unsafe extern "C" fn secondary_effect_drop(ptr: OwnedPtr<Box<dyn SecondaryEffect>>) {
-    drop_in_place(ptr)
+    FFIHandle::get_handle(b.into())
 }
 
 /// The chance the effect triggers.
@@ -135,10 +127,10 @@ unsafe extern "C" fn secondary_effect_chance(ptr: ExternPointer<Box<dyn Secondar
 #[no_mangle]
 unsafe extern "C" fn secondary_effect_effect_name(
     ptr: ExternPointer<Box<dyn SecondaryEffect>>,
-) -> NativeResult<OwnedPtr<c_char>> {
+) -> FFIResult<OwnedPtrString> {
     match CString::new(ptr.as_ref().effect_name().str()) {
-        Ok(name) => NativeResult::ok(name.into_raw()),
-        Err(_) => NativeResult::err(anyhow!(
+        Ok(name) => FFIResult::ok(name.into_raw()),
+        Err(_) => FFIResult::err(anyhow!(
             "Unable to convert effect name '{}' to CString",
             ptr.as_ref().effect_name()
         )),
@@ -156,10 +148,10 @@ unsafe extern "C" fn secondary_effect_parameter_length(ptr: ExternPointer<Box<dy
 unsafe extern "C" fn secondary_effect_parameter_get(
     ptr: ExternPointer<Box<dyn SecondaryEffect>>,
     index: usize,
-) -> IdentifiablePointer<Arc<EffectParameter>> {
+) -> FFIHandle<Arc<EffectParameter>> {
     if let Some(v) = ptr.as_ref().parameters().get(index) {
-        v.clone().into()
+        FFIHandle::get_handle(v.clone().into())
     } else {
-        IdentifiablePointer::none()
+        FFIHandle::none()
     }
 }