Fixes for FFI.

src/ffi/static_data/libraries/growth_rate_library.rs

@@ -0,0 +1,45 @@
+use crate::defines::LevelInt;
+use crate::ffi::{BorrowedPtr, ExternPointer, OwnedPtr};
+use crate::static_data::{GrowthRate, GrowthRateLibrary};
+use std::ffi::{c_char, CStr};
+use std::ptr::drop_in_place;
+
+#[no_mangle]
+extern "C" fn growth_rate_library_new(capacity: usize) -> OwnedPtr<GrowthRateLibrary> {
+    Box::into_raw(Box::new(GrowthRateLibrary::new(capacity)))
+}
+
+#[no_mangle]
+unsafe extern "C" fn growth_rate_library_drop(ptr: OwnedPtr<GrowthRateLibrary>) {
+    drop_in_place(ptr)
+}
+
+#[no_mangle]
+unsafe extern "C" fn growth_rate_library_calculate_level(
+    ptr: ExternPointer<GrowthRateLibrary>,
+    growth_rate: BorrowedPtr<c_char>,
+    experience: u32,
+) -> LevelInt {
+    ptr.as_ref()
+        .calculate_level(&CStr::from_ptr(growth_rate).into(), experience)
+}
+
+#[no_mangle]
+unsafe extern "C" fn growth_rate_library_calculate_experience(
+    ptr: ExternPointer<GrowthRateLibrary>,
+    growth_rate: BorrowedPtr<c_char>,
+    level: LevelInt,
+) -> u32 {
+    ptr.as_ref()
+        .calculate_experience(&CStr::from_ptr(growth_rate).into(), level)
+}
+
+#[no_mangle]
+unsafe extern "C" fn growth_rate_library_add_growth_rate(
+    ptr: ExternPointer<GrowthRateLibrary>,
+    name: BorrowedPtr<c_char>,
+    growth_rate: OwnedPtr<Box<dyn GrowthRate>>,
+) {
+    ptr.as_mut()
+        .add_growth_rate(&CStr::from_ptr(name).into(), *Box::from_raw(growth_rate));
+}

src/ffi/static_data/libraries/library_settings.rs

@@ -0,0 +1,19 @@
+use crate::defines::LevelInt;
+use crate::ffi::{ExternPointer, OwnedPtr};
+use crate::static_data::LibrarySettings;
+use std::ptr::drop_in_place;
+
+#[no_mangle]
+extern "C" fn library_settings_new(max_level: LevelInt) -> OwnedPtr<LibrarySettings> {
+    Box::into_raw(Box::new(LibrarySettings::new(max_level)))
+}
+
+#[no_mangle]
+unsafe extern "C" fn library_settings_drop(ptr: OwnedPtr<LibrarySettings>) {
+    drop_in_place(ptr)
+}
+
+#[no_mangle]
+extern "C" fn library_settings_maximum_level(ptr: ExternPointer<LibrarySettings>) -> LevelInt {
+    ptr.as_ref().maximum_level()
+}

src/ffi/static_data/libraries/mod.rs

@@ -0,0 +1,72 @@
+mod growth_rate_library;
+mod library_settings;
+mod nature_library;
+mod static_data;
+mod type_library;
+
+use crate::ffi::{BorrowedPtr, OwnedPtr};
+use crate::static_data::*;
+use std::ffi::{c_char, CStr};
+use std::ptr::drop_in_place;
+use std::sync::Arc;
+
+macro_rules! library_interface {
+    ($library_type:ty, $return_type:ty) => {
+        paste::paste! {
+            #[no_mangle]
+            extern "C" fn [< $library_type:snake _new >](capacity: usize) -> OwnedPtr<$library_type> {
+                Box::into_raw(Box::new($library_type::new(capacity)))
+            }
+
+            #[no_mangle]
+            unsafe extern "C" fn [< $library_type:snake _drop >](ptr: OwnedPtr<$library_type>) {
+                drop_in_place(ptr);
+            }
+
+            #[no_mangle]
+            unsafe extern "C" fn [< $library_type:snake _add >](ptr: OwnedPtr<$library_type>, key: BorrowedPtr<c_char>, value: OwnedPtr<$return_type>) {
+                let lib = ptr.as_mut().unwrap();
+                lib.add(&CStr::from_ptr(key).into(), *Box::from_raw(value));
+            }
+
+            #[no_mangle]
+            unsafe extern "C" fn [< $library_type:snake _remove >](ptr: OwnedPtr<$library_type>, key: BorrowedPtr<c_char>) {
+                let lib = ptr.as_mut().unwrap();
+                lib.remove(&CStr::from_ptr(key).into());
+            }
+
+            #[no_mangle]
+            unsafe extern "C" fn [< $library_type:snake _get >](ptr: OwnedPtr<$library_type>, key: BorrowedPtr<c_char>) -> BorrowedPtr<$return_type> {
+                let lib = ptr.as_mut().unwrap();
+                let v = lib.get(&CStr::from_ptr(key).into());
+                if let Some(value) = v {
+                    Arc::as_ptr(value)
+                } else {
+                    std::ptr::null()
+                }
+            }
+
+            #[no_mangle]
+            unsafe extern "C" fn [< $library_type:snake _get_key_by_index >](ptr: OwnedPtr<$library_type>, index: usize) -> OwnedPtr<c_char> {
+                let lib = ptr.as_mut().unwrap();
+                let v = lib.get_key_by_index(index);
+                if let Some(value) = v {
+                    std::ffi::CString::new(value.str()).unwrap().into_raw()
+                } else {
+                    std::ptr::null_mut()
+                }
+            }
+
+            #[no_mangle]
+            unsafe extern "C" fn [< $library_type:snake _len >](ptr: OwnedPtr<$library_type>) -> usize {
+                let lib = ptr.as_mut().unwrap();
+                lib.len()
+            }
+        }
+    };
+}
+
+library_interface!(SpeciesLibrary, Species);
+library_interface!(MoveLibrary, MoveData);
+library_interface!(AbilityLibrary, Ability);
+library_interface!(ItemLibrary, Item);

src/ffi/static_data/libraries/nature_library.rs

@@ -0,0 +1,48 @@
+use crate::ffi::{BorrowedPtr, ExternPointer, OwnedPtr};
+use crate::static_data::{Nature, NatureLibrary};
+use std::ffi::{c_char, CStr, CString};
+use std::ptr::drop_in_place;
+use std::sync::Arc;
+
+#[no_mangle]
+extern "C" fn nature_library_new(capacity: usize) -> OwnedPtr<NatureLibrary> {
+    Box::into_raw(Box::new(NatureLibrary::new(capacity)))
+}
+
+#[no_mangle]
+unsafe extern "C" fn nature_library_drop(ptr: OwnedPtr<NatureLibrary>) {
+    drop_in_place(ptr);
+}
+
+#[no_mangle]
+unsafe extern "C" fn nature_library_load_nature(
+    ptr: ExternPointer<NatureLibrary>,
+    name: BorrowedPtr<c_char>,
+    nature: OwnedPtr<Nature>,
+) {
+    ptr.as_mut()
+        .load_nature(CStr::from_ptr(name).into(), *Box::from_raw(nature))
+}
+
+#[no_mangle]
+unsafe extern "C" fn nature_library_get_nature(
+    ptr: ExternPointer<NatureLibrary>,
+    name: BorrowedPtr<c_char>,
+) -> BorrowedPtr<Nature> {
+    if let Some(nature) = ptr.as_ref().get_nature(&CStr::from_ptr(name).into()) {
+        Arc::into_raw(nature.clone())
+    } else {
+        std::ptr::null()
+    }
+}
+
+#[no_mangle]
+unsafe extern "C" fn nature_library_get_nature_name(
+    ptr: ExternPointer<NatureLibrary>,
+    nature: BorrowedPtr<Nature>,
+) -> OwnedPtr<c_char> {
+    let arc = Arc::from_raw(nature);
+    CString::new(ptr.as_ref().get_nature_name(&arc).str())
+        .unwrap()
+        .into_raw()
+}

src/ffi/static_data/libraries/static_data.rs

@@ -0,0 +1,56 @@
+use crate::ffi::{BorrowedPtr, ExternPointer, OwnedPtr};
+use crate::static_data::{
+    AbilityLibrary, GrowthRateLibrary, ItemLibrary, LibrarySettings, MoveLibrary, NatureLibrary, SpeciesLibrary,
+    StaticData, TypeLibrary,
+};
+use std::ptr::drop_in_place;
+
+#[no_mangle]
+unsafe extern "C" fn static_data_new(settings: OwnedPtr<LibrarySettings>) -> OwnedPtr<StaticData> {
+    Box::into_raw(Box::new(StaticData::new(*Box::from_raw(settings))))
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_drop(ptr: OwnedPtr<StaticData>) {
+    drop_in_place(ptr)
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_settings(data: ExternPointer<StaticData>) -> BorrowedPtr<LibrarySettings> {
+    data.as_mut().settings() as *const LibrarySettings
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_species(data: ExternPointer<StaticData>) -> BorrowedPtr<SpeciesLibrary> {
+    data.as_mut().species_mut() as *mut SpeciesLibrary
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_moves(data: ExternPointer<StaticData>) -> BorrowedPtr<MoveLibrary> {
+    data.as_mut().moves_mut() as *mut MoveLibrary
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_items(data: ExternPointer<StaticData>) -> BorrowedPtr<ItemLibrary> {
+    data.as_mut().items_mut() as *mut ItemLibrary
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_growth_rates(data: ExternPointer<StaticData>) -> BorrowedPtr<GrowthRateLibrary> {
+    data.as_mut().growth_rates_mut() as *mut GrowthRateLibrary
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_types(data: ExternPointer<StaticData>) -> BorrowedPtr<TypeLibrary> {
+    data.as_mut().types_mut() as *mut TypeLibrary
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_natures(data: ExternPointer<StaticData>) -> BorrowedPtr<NatureLibrary> {
+    data.as_mut().natures_mut() as *mut NatureLibrary
+}
+
+#[no_mangle]
+unsafe extern "C" fn static_data_abilities(data: ExternPointer<StaticData>) -> BorrowedPtr<AbilityLibrary> {
+    data.as_mut().abilities_mut() as *mut AbilityLibrary
+}

src/ffi/static_data/libraries/type_library.rs

@@ -0,0 +1,82 @@
+use crate::ffi::{BorrowedPtr, ExternPointer, OwnedPtr};
+use crate::static_data::{TypeIdentifier, TypeLibrary};
+use std::ffi::{c_char, CStr, CString};
+use std::ptr::drop_in_place;
+
+#[no_mangle]
+extern "C" fn type_library_new(capacity: usize) -> OwnedPtr<TypeLibrary> {
+    Box::into_raw(Box::new(TypeLibrary::new(capacity)))
+}
+
+#[no_mangle]
+unsafe extern "C" fn type_library_drop(ptr: OwnedPtr<TypeLibrary>) {
+    drop_in_place(ptr);
+}
+
+#[no_mangle]
+unsafe extern "C" fn type_library_get_type_id(
+    ptr: ExternPointer<TypeLibrary>,
+    key: BorrowedPtr<c_char>,
+    found: *mut bool,
+) -> TypeIdentifier {
+    if let Some(v) = ptr.as_ref().get_type_id(&CStr::from_ptr(key).into()) {
+        *found = true;
+        v
+    } else {
+        *found = false;
+        TypeIdentifier::default()
+    }
+}
+
+#[no_mangle]
+unsafe extern "C" fn type_library_get_type_name(
+    ptr: ExternPointer<TypeLibrary>,
+    type_id: TypeIdentifier,
+    found: *mut bool,
+) -> *mut c_char {
+    if let Some(v) = ptr.as_ref().get_type_name(type_id) {
+        *found = true;
+        CString::new(v.str()).unwrap().into_raw()
+    } else {
+        *found = false;
+        std::ptr::null_mut()
+    }
+}
+
+#[no_mangle]
+extern "C" fn type_library_get_single_effectiveness(
+    ptr: ExternPointer<TypeLibrary>,
+    attacking: TypeIdentifier,
+    defending: TypeIdentifier,
+) -> f32 {
+    ptr.as_ref().get_single_effectiveness(attacking, defending)
+}
+
+#[no_mangle]
+unsafe extern "C" fn type_library_get_effectiveness(
+    ptr: ExternPointer<TypeLibrary>,
+    attacking: TypeIdentifier,
+    defending: OwnedPtr<TypeIdentifier>,
+    defending_length: usize,
+) -> f32 {
+    let v = std::slice::from_raw_parts(defending, defending_length);
+    ptr.as_ref().get_effectiveness(attacking, v)
+}
+
+#[no_mangle]
+unsafe extern "C" fn type_library_register_type(
+    ptr: ExternPointer<TypeLibrary>,
+    name: BorrowedPtr<c_char>,
+) -> TypeIdentifier {
+    ptr.as_mut().register_type(&CStr::from_ptr(name).into())
+}
+
+#[no_mangle]
+unsafe extern "C" fn type_library_set_effectiveness(
+    ptr: ExternPointer<TypeLibrary>,
+    attacking: TypeIdentifier,
+    defending: TypeIdentifier,
+    effectiveness: f32,
+) {
+    ptr.as_mut().set_effectiveness(attacking, defending, effectiveness);
+}

src/ffi/static_data/mod.rs

@@ -12,6 +12,7 @@ mod move_data;
 mod nature;
 mod species;
 mod statistic_set;
+mod libraries;
 
 #[no_mangle]
 extern "C" fn effect_parameter_new_bool(value: u8) -> OwnedPtr<EffectParameter> {