rename crate to tskit

Author: molpopgen

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "tskit_rust"
+name = "tskit"
 version = "0.1.0"
 authors = ["molpopgen <[email protected]>"]
 build = "build.rs"

examples/mutation_metadata_bincode.rs

@@ -1,5 +1,5 @@
-use tskit_rust::metadata;
-use tskit_rust::*;
+use tskit::metadata;
+use tskit::*;
 mod mutation;
 
 use mutation::Mutation;

examples/mutation_metadata_std.rs

@@ -1,5 +1,5 @@
-use tskit_rust::metadata;
-use tskit_rust::*;
+use tskit::metadata;
+use tskit::*;
 mod mutation;
 
 use mutation::Mutation;

src/_macros.rs

@@ -4,7 +4,7 @@
 macro_rules! handle_tsk_return_value {
     ($code: expr) => {{
         if $code < 0 {
-            return Err(crate::error::TskitRustError::ErrorCode { code: $code });
+            return Err(crate::error::TskitError::ErrorCode { code: $code });
         }
         return Ok($code);
     }};
@@ -24,7 +24,7 @@ macro_rules! panic_on_tskit_error {
 macro_rules! unsafe_tsk_column_access {
     ($i: expr, $lo: expr, $hi: expr, $array: expr) => {{
         if $i < $lo || ($i as crate::tsk_size_t) >= $hi {
-            return Err(crate::error::TskitRustError::IndexError {});
+            return Err(crate::error::TskitError::IndexError {});
         }
         return Ok(unsafe { *$array.offset($i as isize) });
     }};
@@ -96,7 +96,7 @@ macro_rules! process_state_input {
 
 #[cfg(test)]
 mod test {
-    use crate::error::TskitRustError;
+    use crate::error::TskitError;
     use crate::TskReturnValue;
 
     #[test]
@@ -110,11 +110,11 @@ mod test {
     }
 
     fn must_not_error(x: TskReturnValue) -> bool {
-        x.map_or_else(|_: TskitRustError| false, |_| true)
+        x.map_or_else(|_: TskitError| false, |_| true)
     }
 
     fn must_error(x: TskReturnValue) -> bool {
-        x.map_or_else(|_: TskitRustError| true, |_| false)
+        x.map_or_else(|_: TskitError| true, |_| false)
     }
 
     #[test]

src/bindings.rs

@@ -11,12 +11,12 @@
 //!
 //! ```
 //! use std::mem::MaybeUninit;
-//! let mut edges: MaybeUninit<tskit_rust::bindings::tsk_edge_table_t> = MaybeUninit::uninit();
+//! let mut edges: MaybeUninit<tskit::bindings::tsk_edge_table_t> = MaybeUninit::uninit();
 //! unsafe {
-//!     let _ = tskit_rust::bindings::tsk_edge_table_init(edges.as_mut_ptr(), 0);
-//!     let _ = tskit_rust::bindings::tsk_edge_table_add_row(edges.as_mut_ptr(), 0., 10., 0, 1, std::ptr::null(), 0);
+//!     let _ = tskit::bindings::tsk_edge_table_init(edges.as_mut_ptr(), 0);
+//!     let _ = tskit::bindings::tsk_edge_table_add_row(edges.as_mut_ptr(), 0., 10., 0, 1, std::ptr::null(), 0);
 //!     assert_eq!((*edges.as_ptr()).num_rows, 1);
-//!     tskit_rust::bindings::tsk_edge_table_free(edges.as_mut_ptr());
+//!     tskit::bindings::tsk_edge_table_free(edges.as_mut_ptr());
 //! }
 //! ```
 //!

src/edge_table.rs

@@ -1,6 +1,6 @@
 use crate::bindings as ll_bindings;
 use crate::metadata;
-use crate::{tsk_id_t, tsk_size_t, TskitRustError};
+use crate::{tsk_id_t, tsk_size_t, TskitError};
 
 /// An immutable view of an edge table.
 ///
@@ -25,46 +25,46 @@ impl<'a> EdgeTable<'a> {
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn parent(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitRustError> {
+    pub fn parent(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.parent);
     }
 
     /// Return the ``child`` value from row ``row`` of the table.
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn child(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitRustError> {
+    pub fn child(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.child);
     }
 
     /// Return the ``left`` value from row ``row`` of the table.
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn left(&'a self, row: tsk_id_t) -> Result<f64, TskitRustError> {
+    pub fn left(&'a self, row: tsk_id_t) -> Result<f64, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.left);
     }
 
     /// Return the ``right`` value from row ``row`` of the table.
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn right(&'a self, row: tsk_id_t) -> Result<f64, TskitRustError> {
+    pub fn right(&'a self, row: tsk_id_t) -> Result<f64, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.right);
     }
 
     pub fn metadata<T: metadata::MetadataRoundtrip>(
         &'a self,
         row: tsk_id_t,
-    ) -> Result<Option<T>, TskitRustError> {
+    ) -> Result<Option<T>, TskitError> {
         let buffer = metadata_to_vector!(T, self, row);
         decode_metadata_row!(T, buffer)
     }

src/error.rs

@@ -4,7 +4,7 @@ use crate::TskReturnValue;
 use thiserror::Error;
 
 #[derive(Error, Debug, PartialEq)]
-pub enum TskitRustError {
+pub enum TskitError {
     /// Used when bad input is encountered.
     #[error("we received {} but expected {}",*got, *expected)]
     ValueError { got: String, expected: String },
@@ -34,16 +34,16 @@ pub enum TskitRustError {
 ///
 /// ```
 /// let rv = 0;  // All good!
-/// tskit_rust::error::panic_on_tskit_error(rv);
+/// tskit::error::panic_on_tskit_error(rv);
 /// let rv = 1;  // Probably something like a new node id.
-/// tskit_rust::error::panic_on_tskit_error(rv);
+/// tskit::error::panic_on_tskit_error(rv);
 /// ```
 ///
 /// This will panic:
 ///
 /// ```should_panic
 /// let rv = -202; // "Node out of bounds error"
-/// tskit_rust::error::panic_on_tskit_error(rv);
+/// tskit::error::panic_on_tskit_error(rv);
 /// ```
 pub fn panic_on_tskit_error(code: i32) {
     panic_on_tskit_error!(code);
@@ -54,7 +54,7 @@ pub fn panic_on_tskit_error(code: i32) {
 ///
 /// tskit returns 0 when there's no error:
 /// ```
-/// let x = tskit_rust::error::get_tskit_error_message(0);
+/// let x = tskit::error::get_tskit_error_message(0);
 /// assert_eq!(x, "Normal exit condition. This is not an error!");
 /// ```
 ///
@@ -63,14 +63,14 @@ pub fn panic_on_tskit_error(code: i32) {
 /// to ever do so by client code.
 ///
 /// ```
-/// let x = tskit_rust::error::get_tskit_error_message(1);
+/// let x = tskit::error::get_tskit_error_message(1);
 /// assert_eq!(x, "Unknown error");
 /// ```
 ///
 /// Values < 0 may have known causes:
 ///
 /// ```
-/// let x = tskit_rust::error::get_tskit_error_message(-207);
+/// let x = tskit::error::get_tskit_error_message(-207);
 /// assert_eq!(x, "Individual out of bounds");
 /// ```
 pub fn get_tskit_error_message(code: i32) -> String {
@@ -81,7 +81,7 @@ pub fn get_tskit_error_message(code: i32) -> String {
 /// Given an instance of [``TskReturnValue``](crate::TskReturnValue),
 /// obtain the tskit error message if there is indeed an error.
 pub fn extract_error_message(x: TskReturnValue) -> Option<String> {
-    x.map_or_else(|e: TskitRustError| Some(format!("{}", e)), |_| None)
+    x.map_or_else(|e: TskitError| Some(format!("{}", e)), |_| None)
 }
 
 #[cfg(test)]
@@ -107,7 +107,7 @@ mod test {
     fn test_error_formatting() {
         let x = mock_error();
         let mut s: String = "nope!".to_string();
-        x.map_or_else(|e: TskitRustError| s = format!("{}", e), |_| ());
+        x.map_or_else(|e: TskitError| s = format!("{}", e), |_| ());
         assert_eq!(s, "Individual out of bounds");
     }
 

src/lib.rs

@@ -36,7 +36,7 @@ pub use bindings::tsk_size_t;
 pub const TSK_NULL: tsk_id_t = -1;
 
 pub use edge_table::EdgeTable;
-pub use error::TskitRustError;
+pub use error::TskitError;
 pub use mutation_table::MutationTable;
 pub use node_table::NodeTable;
 pub use population_table::PopulationTable;
@@ -46,9 +46,9 @@ pub use table_collection::TableCollection;
 ///
 /// When an error from the tskit C API is detected,
 /// the error message is stored for diplay.
-pub type TskReturnValue = Result<i32, TskitRustError>;
+pub type TskReturnValue = Result<i32, TskitError>;
 
-/// Get the tskit_rust version number.
+/// Get the tskit version number.
 pub fn version() -> &'static str {
     return env!("CARGO_PKG_VERSION");
 }

src/metadata.rs

@@ -52,9 +52,9 @@ pub(crate) fn char_column_to_vector(
     row: tsk_id_t,
     num_rows: tsk_size_t,
     column_length: tsk_size_t,
-) -> Result<Option<Vec<u8>>, crate::TskitRustError> {
+) -> Result<Option<Vec<u8>>, crate::TskitError> {
     if row < 0 || (row as tsk_size_t) >= num_rows {
-        return Err(crate::TskitRustError::IndexError {});
+        return Err(crate::TskitError::IndexError {});
     }
     if column_length == 0 {
         return Ok(None);

src/mutation_table.rs

@@ -1,6 +1,6 @@
 use crate::bindings as ll_bindings;
 use crate::metadata;
-use crate::{tsk_id_t, tsk_size_t, TskitRustError};
+use crate::{tsk_id_t, tsk_size_t, TskitError};
 
 /// An immutable view of site table.
 ///
@@ -25,39 +25,39 @@ impl<'a> MutationTable<'a> {
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn site(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitRustError> {
+    pub fn site(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.site);
     }
 
     /// Return the ``node`` value from row ``row`` of the table.
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn node(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitRustError> {
+    pub fn node(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.node);
     }
 
     /// Return the ``parent`` value from row ``row`` of the table.
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn parent(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitRustError> {
+    pub fn parent(&'a self, row: tsk_id_t) -> Result<tsk_id_t, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.parent);
     }
 
     /// Return the ``time`` value from row ``row`` of the table.
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn time(&'a self, row: tsk_id_t) -> Result<f64, TskitRustError> {
+    pub fn time(&'a self, row: tsk_id_t) -> Result<f64, TskitError> {
         unsafe_tsk_column_access!(row, 0, self.num_rows(), self.table_.time);
     }
 
@@ -69,9 +69,9 @@ impl<'a> MutationTable<'a> {
     ///
     /// # Errors
     ///
-    /// Will return [``IndexError``](crate::TskitRustError::IndexError)
+    /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn derived_state(&'a self, row: tsk_id_t) -> Result<Option<Vec<u8>>, TskitRustError> {
+    pub fn derived_state(&'a self, row: tsk_id_t) -> Result<Option<Vec<u8>>, TskitError> {
         metadata::char_column_to_vector(
             self.table_.derived_state,
             self.table_.derived_state_offset,
@@ -84,7 +84,7 @@ impl<'a> MutationTable<'a> {
     pub fn metadata<T: metadata::MetadataRoundtrip>(
         &'a self,
         row: tsk_id_t,
-    ) -> Result<Option<T>, TskitRustError> {
+    ) -> Result<Option<T>, TskitError> {
         let buffer = metadata_to_vector!(T, self, row);
         decode_metadata_row!(T, buffer)
     }