refactor: use sys::LowLevelPointerManager to manage ownership of C API types.

* All tables now have a single rust type behind them.
* OwnedXTable is now a type alias for XTable.
* remove several internal types and macros

Author: molpopgen

src/_macros.rs

@@ -380,56 +380,6 @@ macro_rules! handle_metadata_return {
     };
 }
 
-macro_rules! build_owned_tables {
-    ($name: ty, $deref: ident, $lltype: ty, $tsktable: ty) => {
-        impl $name {
-            fn new() -> Self {
-                let table = <$lltype>::new();
-                Self { table }
-            }
-
-            /// Clear the table.
-            pub fn clear(&mut self) -> $crate::TskReturnValue {
-                self.table.clear().map_err(|e| e.into())
-            }
-        }
-
-        impl Default for $name {
-            fn default() -> Self {
-                Self::new()
-            }
-        }
-
-        impl std::ops::Deref for $name {
-            type Target = $deref;
-
-            fn deref(&self) -> &Self::Target {
-                // SAFETY: that T* and &T have same layout,
-                // and Target is repr(transparent).
-                unsafe { std::mem::transmute(&self.table) }
-            }
-        }
-
-        impl std::ops::DerefMut for $name {
-            fn deref_mut(&mut self) -> &mut Self::Target {
-                // SAFETY: that T* and &T have same layout,
-                // and Target is repr(transparent).
-                unsafe { std::mem::transmute(&mut self.table) }
-            }
-        }
-
-        impl $name {
-            pub fn as_ptr(&self) -> *const $tsktable {
-                self.table.as_ptr()
-            }
-
-            pub fn as_mut_ptr(&mut self) -> *mut $tsktable {
-                self.table.as_mut_ptr()
-            }
-        }
-    };
-}
-
 macro_rules! node_table_add_row_details {
     ($flags: ident,
      $time: ident,
@@ -929,25 +879,6 @@ macro_rules! provenance_table_add_row {
     };
 }
 
-macro_rules! build_owned_table_type {
-    ($(#[$attr:meta])* => $name: ident,
-    $deref_type: ident,
-    $lltype: ty,
-    $tsktable: ty) => {
-        $(#[$attr])*
-        pub struct $name {
-            table: $lltype
-        }
-
-        build_owned_tables!(
-            $name,
-            $deref_type,
-            $lltype,
-            $tsktable
-        );
-    };
-}
-
 macro_rules! raw_metadata_getter_for_tables {
     ($idtype: ty) => {
         fn raw_metadata<I: Into<$idtype>>(&self, row: I) -> Option<&[u8]> {

src/edge_table.rs

@@ -137,29 +137,86 @@ impl<'a> streaming_iterator::StreamingIterator for EdgeTableRowView<'a> {
     }
 }
 
-/// An immutable view of an edge table.
+/// An edge table.
 ///
-/// These are not created directly but are accessed
-/// by types implementing [`std::ops::Deref`] to
-/// [`crate::table_views::TableViews`]
+/// # Examples
+///
+/// ## Standalone tables
+///
+/// ```
+/// use tskit::EdgeTable;
+///
+/// let mut edges = EdgeTable::default();
+/// let rowid = edges.add_row(1., 2., 0, 1).unwrap();
+/// assert_eq!(rowid, 0);
+/// assert_eq!(edges.num_rows(), 1);
+///
+/// edges.clear().unwrap();
+/// assert_eq!(edges.num_rows(), 0);
+/// ```
+///
+/// An example with metadata.
+/// This requires the cargo feature `"derive"` for `tskit`.
+///
+/// ```
+/// # #[cfg(any(feature="doc", feature="derive"))] {
+/// use tskit::EdgeTable;
+///
+/// #[derive(serde::Serialize,
+///          serde::Deserialize,
+///          tskit::metadata::EdgeMetadata)]
+/// #[serializer("serde_json")]
+/// struct EdgeMetadata {
+///     value: i32,
+/// }
+///
+/// let metadata = EdgeMetadata{value: 42};
+///
+/// let mut edges = EdgeTable::default();
+///
+/// let rowid = edges.add_row_with_metadata(0., 1., 5, 10, &metadata).unwrap();
+/// assert_eq!(rowid, 0);
+///
+/// match edges.metadata::<EdgeMetadata>(rowid) {
+///     // rowid is in range, decoding succeeded
+///     Some(Ok(decoded)) => assert_eq!(decoded.value, 42),
+///     // rowid is in range, decoding failed
+///     Some(Err(e)) => panic!("error decoding metadata: {:?}", e),
+///     None => panic!("row id out of range")
+/// }
+/// # }
+/// ```
 #[repr(transparent)]
 #[derive(Debug)]
 pub struct EdgeTable {
-    table_: sys::LLEdgeTableRef,
+    table_: sys::LLEdgeTable,
 }
 
 impl EdgeTable {
+    pub(crate) fn as_ptr(&self) -> *const ll_bindings::tsk_edge_table_t {
+        self.table_.as_ptr()
+    }
+
+    pub(crate) fn as_mut_ptr(&mut self) -> *mut ll_bindings::tsk_edge_table_t {
+        self.table_.as_mut_ptr()
+    }
+
     pub(crate) fn new_from_table(
         edges: *mut ll_bindings::tsk_edge_table_t,
     ) -> Result<Self, TskitError> {
-        let table_ = sys::LLEdgeTableRef::new_from_table(edges)?;
+        let table_ = sys::LLEdgeTable::new_non_owning(edges)?;
         Ok(EdgeTable { table_ })
     }
 
     pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_edge_table_t {
         self.table_.as_ref()
     }
 
+    pub fn new() -> Result<Self, TskitError> {
+        let table_ = sys::LLEdgeTable::new_owning(0)?;
+        Ok(Self { table_ })
+    }
+
     /// Return the number of rows
     pub fn num_rows(&self) -> crate::SizeType {
         self.as_ref().num_rows.into()
@@ -283,6 +340,13 @@ impl EdgeTable {
         Some(view)
     }
 
+    pub fn clear(&mut self) -> Result<(), TskitError> {
+        self.table_.clear().map_err(|e| e.into())
+    }
+
+    edge_table_add_row!(=> add_row, self, self.as_mut_ptr());
+    edge_table_add_row_with_metadata!(=> add_row_with_metadata, self, self.as_mut_ptr());
+
     build_table_column_slice_getter!(
         /// Get the left column as a slice
         => left, left_slice, Position);
@@ -309,61 +373,10 @@ impl EdgeTable {
         => child, child_slice_raw, ll_bindings::tsk_id_t);
 }
 
-build_owned_table_type!(
-    /// A standalone edge table that owns its data.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tskit::OwningEdgeTable;
-    ///
-    /// let mut edges = OwningEdgeTable::default();
-    /// let rowid = edges.add_row(1., 2., 0, 1).unwrap();
-    /// assert_eq!(rowid, 0);
-    /// assert_eq!(edges.num_rows(), 1);
-    ///
-    /// edges.clear().unwrap();
-    /// assert_eq!(edges.num_rows(), 0);
-    /// ```
-    ///
-    /// An example with metadata.
-    /// This requires the cargo feature `"derive"` for `tskit`.
-    ///
-    /// ```
-    /// # #[cfg(any(feature="doc", feature="derive"))] {
-    /// use tskit::OwningEdgeTable;
-    ///
-    /// #[derive(serde::Serialize,
-    ///          serde::Deserialize,
-    ///          tskit::metadata::EdgeMetadata)]
-    /// #[serializer("serde_json")]
-    /// struct EdgeMetadata {
-    ///     value: i32,
-    /// }
-    ///
-    /// let metadata = EdgeMetadata{value: 42};
-    ///
-    /// let mut edges = OwningEdgeTable::default();
-    ///
-    /// let rowid = edges.add_row_with_metadata(0., 1., 5, 10, &metadata).unwrap();
-    /// assert_eq!(rowid, 0);
-    ///
-    /// match edges.metadata::<EdgeMetadata>(rowid) {
-    ///     // rowid is in range, decoding succeeded
-    ///     Some(Ok(decoded)) => assert_eq!(decoded.value, 42),
-    ///     // rowid is in range, decoding failed
-    ///     Some(Err(e)) => panic!("error decoding metadata: {:?}", e),
-    ///     None => panic!("row id out of range")
-    /// }
-    /// # }
-    /// ```
-    => OwningEdgeTable,
-    EdgeTable,
-    crate::sys::LLOwningEdgeTable,
-    crate::bindings::tsk_edge_table_t
-);
-
-impl OwningEdgeTable {
-    edge_table_add_row!(=> add_row, self, self.as_mut_ptr());
-    edge_table_add_row_with_metadata!(=> add_row_with_metadata, self, self.as_mut_ptr());
+impl Default for EdgeTable {
+    fn default() -> Self {
+        Self::new().unwrap()
+    }
 }
+
+pub type OwningEdgeTable = EdgeTable;

src/error.rs

@@ -40,8 +40,11 @@ pub enum TskitError {
 impl From<crate::sys::Error> for TskitError {
     fn from(error: sys::Error) -> Self {
         match error {
-            sys::Error::Message(msg) => TskitError::LibraryError(msg),
             sys::Error::Code(code) => TskitError::ErrorCode { code },
+            sys::Error::Message(msg) => TskitError::LibraryError(msg),
+            sys::Error::NullPointer => {
+                TskitError::LibraryError("null pointer encountered".to_owned())
+            }
         }
     }
 }