streamline API for creating table row objects (#126)

Closes #117

Author: molpopgen

src/_macros.rs

@@ -156,11 +156,8 @@ macro_rules! decode_metadata_row {
 }
 
 macro_rules! table_row_decode_metadata {
-    ($decode_metadata: ident, $table: ident, $pos: ident) => {
-        match $decode_metadata {
-            true => metadata_to_vector!($table, $pos).unwrap().map(|x| x),
-            false => None,
-        }
+    ($table: ident, $pos: ident) => {
+        metadata_to_vector!($table, $pos).unwrap().map(|x| x)
     };
 }
 
@@ -191,11 +188,11 @@ macro_rules! err_if_not_tracking_samples {
 // Here, we convert the None type to an Error,
 // as it applies $row is out of range.
 macro_rules! table_row_access {
-    ($row: expr, $decode_metadata: expr, $table: expr, $row_fn: ident) => {
+    ($row: expr, $table: expr, $row_fn: ident) => {
         if $row < 0 {
             Err(TskitError::IndexError)
         } else {
-            match $row_fn($table, $row, $decode_metadata) {
+            match $row_fn($table, $row) {
                 Some(x) => Ok(x),
                 None => Err(TskitError::IndexError),
             }

src/edge_table.rs

@@ -23,19 +23,15 @@ impl PartialEq for EdgeTableRow {
     }
 }
 
-fn make_edge_table_row(
-    table: &EdgeTable,
-    pos: tsk_id_t,
-    decode_metadata: bool,
-) -> Option<EdgeTableRow> {
+fn make_edge_table_row(table: &EdgeTable, pos: tsk_id_t) -> Option<EdgeTableRow> {
     if pos < table.num_rows() as tsk_id_t {
         let rv = EdgeTableRow {
             id: pos,
             left: table.left(pos).unwrap(),
             right: table.right(pos).unwrap(),
             parent: table.parent(pos).unwrap(),
             child: table.child(pos).unwrap(),
-            metadata: table_row_decode_metadata!(decode_metadata, table, pos),
+            metadata: table_row_decode_metadata!(table, pos),
         };
         Some(rv)
     } else {
@@ -50,7 +46,7 @@ impl<'a> Iterator for EdgeTableRefIterator<'a> {
     type Item = EdgeTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_edge_table_row(self.table, self.pos, self.decode_metadata);
+        let rv = make_edge_table_row(self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -60,7 +56,7 @@ impl<'a> Iterator for EdgeTableIterator<'a> {
     type Item = EdgeTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_edge_table_row(&self.table, self.pos, self.decode_metadata);
+        let rv = make_edge_table_row(&self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -136,31 +132,20 @@ impl<'a> EdgeTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`EdgeTableRow`].
     ///
-    /// # Parameters
-    ///
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`EdgeTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
-    ///
-    pub fn iter(&self, decode_metadata: bool) -> EdgeTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(&self, decode_metadata)
+    pub fn iter(&self) -> EdgeTableRefIterator {
+        crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(&self)
     }
 
     /// Return row `r` of the table.
     ///
     /// # Parameters
     ///
     /// * `r`: the row id.
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`EdgeTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
     ///
     /// # Errors
     ///
     /// [`TskitError::IndexError`] if `r` is out of range.
-    pub fn row(&self, r: tsk_id_t, decode_metadata: bool) -> Result<EdgeTableRow, TskitError> {
-        table_row_access!(r, decode_metadata, self, make_edge_table_row)
+    pub fn row(&self, r: tsk_id_t) -> Result<EdgeTableRow, TskitError> {
+        table_row_access!(r, self, make_edge_table_row)
     }
 }

src/individual_table.rs

@@ -47,18 +47,14 @@ pub struct IndividualTable<'a> {
     table_: &'a ll_bindings::tsk_individual_table_t,
 }
 
-fn make_individual_table_row(
-    table: &IndividualTable,
-    pos: tsk_id_t,
-    decode_metadata: bool,
-) -> Option<IndividualTableRow> {
+fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<IndividualTableRow> {
     if pos < table.num_rows() as tsk_id_t {
         let rv = IndividualTableRow {
             id: pos,
             flags: table.flags(pos).unwrap(),
             location: table.location(pos).unwrap(),
             parents: table.parents(pos).unwrap(),
-            metadata: table_row_decode_metadata!(decode_metadata, table, pos),
+            metadata: table_row_decode_metadata!(table, pos),
         };
         Some(rv)
     } else {
@@ -139,35 +135,20 @@ impl<'a> IndividualTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`IndividualTableRow`].
     ///
-    /// # Parameters
-    ///
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`IndividualTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
-    ///
-    pub fn iter(&self, decode_metadata: bool) -> IndividualTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(&self, decode_metadata)
+    pub fn iter(&self) -> IndividualTableRefIterator {
+        crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(&self)
     }
 
     /// Return row `r` of the table.
     ///
     /// # Parameters
     ///
     /// * `r`: the row id.
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`IndividualTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
     ///
     /// # Errors
     ///
     /// [`TskitError::IndexError`] if `r` is out of range.
-    pub fn row(
-        &self,
-        r: tsk_id_t,
-        decode_metadata: bool,
-    ) -> Result<IndividualTableRow, TskitError> {
-        table_row_access!(r, decode_metadata, self, make_individual_table_row)
+    pub fn row(&self, r: tsk_id_t) -> Result<IndividualTableRow, TskitError> {
+        table_row_access!(r, self, make_individual_table_row)
     }
 }

src/migration_table.rs

@@ -27,11 +27,7 @@ impl PartialEq for MigrationTableRow {
     }
 }
 
-fn make_migration_table_row(
-    table: &MigrationTable,
-    pos: tsk_id_t,
-    decode_metadata: bool,
-) -> Option<MigrationTableRow> {
+fn make_migration_table_row(table: &MigrationTable, pos: tsk_id_t) -> Option<MigrationTableRow> {
     if pos < table.num_rows() as tsk_id_t {
         Some(MigrationTableRow {
             id: pos,
@@ -41,7 +37,7 @@ fn make_migration_table_row(
             source: table.source(pos).unwrap(),
             dest: table.dest(pos).unwrap(),
             time: table.time(pos).unwrap(),
-            metadata: table_row_decode_metadata!(decode_metadata, table, pos),
+            metadata: table_row_decode_metadata!(table, pos),
         })
     } else {
         None
@@ -56,7 +52,7 @@ impl<'a> Iterator for MigrationTableRefIterator<'a> {
     type Item = MigrationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_migration_table_row(self.table, self.pos, self.decode_metadata);
+        let rv = make_migration_table_row(self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -66,7 +62,7 @@ impl<'a> Iterator for MigrationTableIterator<'a> {
     type Item = crate::migration_table::MigrationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_migration_table_row(&self.table, self.pos, self.decode_metadata);
+        let rv = make_migration_table_row(&self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -160,32 +156,20 @@ impl<'a> MigrationTable<'a> {
 
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MigrationTableRow`].
-    ///
-    /// # Parameters
-    ///
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`MigrationTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
-    ///
-    pub fn iter(&self, decode_metadata: bool) -> MigrationTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(&self, decode_metadata)
+    pub fn iter(&self) -> MigrationTableRefIterator {
+        crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(&self)
     }
 
     /// Return row `r` of the table.
     ///
     /// # Parameters
     ///
     /// * `r`: the row id.
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`MigrationTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
     ///
     /// # Errors
     ///
     /// [`TskitError::IndexError`] if `r` is out of range.
-    pub fn row(&self, r: tsk_id_t, decode_metadata: bool) -> Result<MigrationTableRow, TskitError> {
-        table_row_access!(r, decode_metadata, self, make_migration_table_row)
+    pub fn row(&self, r: tsk_id_t) -> Result<MigrationTableRow, TskitError> {
+        table_row_access!(r, self, make_migration_table_row)
     }
 }

src/mutation_table.rs

@@ -25,11 +25,7 @@ impl PartialEq for MutationTableRow {
     }
 }
 
-fn make_mutation_table_row(
-    table: &MutationTable,
-    pos: tsk_id_t,
-    decode_metadata: bool,
-) -> Option<MutationTableRow> {
+fn make_mutation_table_row(table: &MutationTable, pos: tsk_id_t) -> Option<MutationTableRow> {
     if pos < table.num_rows() as tsk_id_t {
         let rv = MutationTableRow {
             id: pos,
@@ -38,7 +34,7 @@ fn make_mutation_table_row(
             parent: table.parent(pos).unwrap(),
             time: table.time(pos).unwrap(),
             derived_state: table.derived_state(pos).unwrap(),
-            metadata: table_row_decode_metadata!(decode_metadata, table, pos),
+            metadata: table_row_decode_metadata!(table, pos),
         };
         Some(rv)
     } else {
@@ -52,7 +48,7 @@ impl<'a> Iterator for MutationTableRefIterator<'a> {
     type Item = MutationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_mutation_table_row(&self.table, self.pos, self.decode_metadata);
+        let rv = make_mutation_table_row(&self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -62,7 +58,7 @@ impl<'a> Iterator for MutationTableIterator<'a> {
     type Item = MutationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_mutation_table_row(&self.table, self.pos, self.decode_metadata);
+        let rv = make_mutation_table_row(&self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -157,32 +153,20 @@ impl<'a> MutationTable<'a> {
 
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MutationTableRow`].
-    ///
-    /// # Parameters
-    ///
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`MutationTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
-    ///
-    pub fn iter(&self, decode_metadata: bool) -> MutationTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&MutationTable<'a>>(&self, decode_metadata)
+    pub fn iter(&self) -> MutationTableRefIterator {
+        crate::table_iterator::make_table_iterator::<&MutationTable<'a>>(&self)
     }
 
     /// Return row `r` of the table.
     ///
     /// # Parameters
     ///
     /// * `r`: the row id.
-    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
-    ///    will be provided in [`MutationTableRow::metadata`].
-    ///    The meta data are *not* decoded.
-    ///    Rows with no metadata will contain the value `None`.
     ///
     /// # Errors
     ///
     /// [`TskitError::IndexError`] if `r` is out of range.
-    pub fn row(&self, r: tsk_id_t, decode_metadata: bool) -> Result<MutationTableRow, TskitError> {
-        table_row_access!(r, decode_metadata, self, make_mutation_table_row)
+    pub fn row(&self, r: tsk_id_t) -> Result<MutationTableRow, TskitError> {
+        table_row_access!(r, self, make_mutation_table_row)
     }
 }