Add trait to define what it means to wrap a tskit type.

Author: molpopgen

src/_macros.rs

@@ -30,6 +30,34 @@ macro_rules! unsafe_tsk_column_access {
     }};
 }
 
+macro_rules! build_tskit_type {
+    ($name: ident, $ll_name: ty, $drop: ident) => {
+        impl Drop for $name {
+            fn drop(&mut self) {
+                let rv = unsafe { $drop(&mut *self.inner) };
+                panic_on_tskit_error!(rv);
+            }
+        }
+
+        impl crate::ffi::TskitType<$ll_name> for $name {
+            fn wrap() -> Self {
+                let temp: std::mem::MaybeUninit<$ll_name> = std::mem::MaybeUninit::uninit();
+                $name {
+                    inner: unsafe { Box::<$ll_name>::new(temp.assume_init()) },
+                }
+            }
+
+            fn as_ptr(&self) -> *const $ll_name {
+                &*self.inner
+            }
+
+            fn as_mut_ptr(&mut self) -> *mut $ll_name {
+                &mut *self.inner
+            }
+        }
+    };
+}
+
 #[cfg(test)]
 mod test {
     use crate::error::TskitRustError;

src/ffi.rs

@@ -0,0 +1,56 @@
+//! Define traits related to wrapping tskit stuff
+
+/// Define what it means to wrap a tskit struct.
+/// The implementation of Drop should call the
+/// tsk_foo_free() function corresponding
+/// to tsk_foo_t.
+pub trait TskitType<T>: Drop {
+    /// Encapsulate tsk_foo_t and return rust
+    /// object.  Best practices seem to
+    /// suggest using Box for this.
+    fn wrap() -> Self;
+    /// Return const pointer
+    fn as_ptr(&self) -> *const T;
+    /// Return mutable pointer
+    fn as_mut_ptr(&mut self) -> *mut T;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::bindings as ll_bindings;
+    use ll_bindings::tsk_table_collection_free;
+
+    pub struct TableCollectionMock {
+        inner: Box<ll_bindings::tsk_table_collection_t>,
+    }
+
+    build_tskit_type!(
+        TableCollectionMock,
+        ll_bindings::tsk_table_collection_t,
+        tsk_table_collection_free
+    );
+
+    impl TableCollectionMock {
+        fn new(len: f64) -> Self {
+            let mut s = Self::wrap();
+
+            let rv = unsafe { ll_bindings::tsk_table_collection_init(s.as_mut_ptr(), 0) };
+            assert_eq!(rv, 0);
+
+            s.inner.sequence_length = len;
+
+            s
+        }
+
+        fn sequence_length(&self) -> f64 {
+            unsafe { (*self.as_ptr()).sequence_length }
+        }
+    }
+
+    #[test]
+    fn test_create_mock_type() {
+        let t = TableCollectionMock::new(10.);
+        assert_eq!(t.sequence_length() as i64, 10);
+    }
+}

src/lib.rs

@@ -9,6 +9,7 @@ pub mod bindings;
 mod _macros; // Starts w/_ to be sorted at front by rustfmt!
 mod edge_table;
 pub mod error;
+pub mod ffi;
 mod mutation_table;
 mod node_table;
 mod population_table;
@@ -53,4 +54,3 @@ pub fn version() -> &'static str {
 
 // Testing modules
 mod test_tsk_variables;
-