Table iteration

src/edge_table.rs

@@ -2,6 +2,42 @@ use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::{tsk_id_t, tsk_size_t, TskitError};
 
+pub struct EdgeTableRow {
+    pub left: f64,
+    pub right: f64,
+    pub parent: tsk_id_t,
+    pub child: tsk_id_t,
+    pub metadata: Option<Vec<u8>>,
+}
+
+pub type EdgeTableIterator<'a> = crate::table_iterator::TableIterator<'a, EdgeTable<'a>>;
+
+impl<'a> Iterator for EdgeTableIterator<'a> {
+    type Item = EdgeTableRow;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.table.num_rows() as tsk_id_t {
+            let rv = EdgeTableRow {
+                left: self.table.left(self.pos).unwrap(),
+                right: self.table.right(self.pos).unwrap(),
+                parent: self.table.parent(self.pos).unwrap(),
+                child: self.table.child(self.pos).unwrap(),
+                metadata: match self.decode_metadata {
+                    true => match metadata_to_vector!(self.table, self.pos).unwrap() {
+                        Some(x) => Some(x),
+                        None => None,
+                    },
+                    false => None,
+                },
+            };
+            self.pos += 1;
+            Some(rv)
+        } else {
+            None
+        }
+    }
+}
+
 /// An immutable view of an edge table.
 ///
 /// These are not created directly.
@@ -68,4 +104,18 @@ impl<'a> EdgeTable<'a> {
         let buffer = metadata_to_vector!(self, row)?;
         decode_metadata_row!(T, buffer)
     }
+
+    /// 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) -> EdgeTableIterator {
+        crate::table_iterator::make_table_iterator(self, decode_metadata)
+    }
 }

src/ffi.rs

@@ -44,7 +44,7 @@ impl<T: Copy> WrappedTskArray<T> {
         self.len_
     }
 
-    pub fn iter<'a>(&'a self) -> WrappedTskArrayIter<'a, T> {
+    pub fn iter(&self) -> WrappedTskArrayIter<T> {
         WrappedTskArrayIter {
             inner: self,
             pos: 0,

src/lib.rs

@@ -16,6 +16,7 @@ mod node_table;
 mod population_table;
 mod site_table;
 mod table_collection;
+mod table_iterator;
 mod trees;
 pub mod types;
 
@@ -36,12 +37,12 @@ pub use bindings::tsk_size_t;
 /// "Null" identifier value.
 pub const TSK_NULL: tsk_id_t = -1;
 
-pub use edge_table::EdgeTable;
+pub use edge_table::{EdgeTable, EdgeTableRow};
 pub use error::TskitError;
-pub use mutation_table::MutationTable;
-pub use node_table::NodeTable;
-pub use population_table::PopulationTable;
-pub use site_table::SiteTable;
+pub use mutation_table::{MutationTable, MutationTableRow};
+pub use node_table::{NodeTable, NodeTableRow};
+pub use population_table::{PopulationTable, PopulationTableRow};
+pub use site_table::{SiteTable, SiteTableRow};
 pub use table_collection::TableCollection;
 pub use trees::{NodeIterator, NodeTraversalOrder, Tree, TreeFlags, TreeSequence};
 

src/mutation_table.rs

@@ -2,6 +2,45 @@ use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::{tsk_id_t, tsk_size_t, TskitError};
 
+/// Row of a [`MutationTable`]
+pub struct MutationTableRow {
+    pub site: tsk_id_t,
+    pub node: tsk_id_t,
+    pub parent: tsk_id_t,
+    pub time: f64,
+    pub derived_state: Option<Vec<u8>>,
+    pub metadata: Option<Vec<u8>>,
+}
+
+pub type MutationTableIterator<'a> = crate::table_iterator::TableIterator<'a, MutationTable<'a>>;
+
+impl<'a> Iterator for MutationTableIterator<'a> {
+    type Item = MutationTableRow;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.table.num_rows() as tsk_id_t {
+            let rv = MutationTableRow {
+                site: self.table.site(self.pos).unwrap(),
+                node: self.table.node(self.pos).unwrap(),
+                parent: self.table.parent(self.pos).unwrap(),
+                time: self.table.time(self.pos).unwrap(),
+                derived_state: self.table.derived_state(self.pos).unwrap(),
+                metadata: match self.decode_metadata {
+                    true => match metadata_to_vector!(self.table, self.pos).unwrap() {
+                        Some(x) => Some(x),
+                        None => None,
+                    },
+                    false => None,
+                },
+            };
+            self.pos += 1;
+            Some(rv)
+        } else {
+            None
+        }
+    }
+}
+
 /// An immutable view of site table.
 ///
 /// These are not created directly.
@@ -88,4 +127,18 @@ impl<'a> MutationTable<'a> {
         let buffer = metadata_to_vector!(self, row)?;
         decode_metadata_row!(T, buffer)
     }
+
+    /// 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) -> MutationTableIterator {
+        crate::table_iterator::make_table_iterator(self, decode_metadata)
+    }
 }

src/node_table.rs

@@ -2,6 +2,43 @@ use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::{tsk_flags_t, tsk_id_t, TskitError};
 
+/// Row of a [`NodeTable`]
+pub struct NodeTableRow {
+    pub time: f64,
+    pub flags: tsk_flags_t,
+    pub population: tsk_id_t,
+    pub individual: tsk_id_t,
+    pub metadata: Option<Vec<u8>>,
+}
+
+pub type NodeTableIterator<'a> = crate::table_iterator::TableIterator<'a, NodeTable<'a>>;
+
+impl<'a> Iterator for NodeTableIterator<'a> {
+    type Item = NodeTableRow;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.table.num_rows() as tsk_id_t {
+            let rv = NodeTableRow {
+                time: self.table.time(self.pos).unwrap(),
+                flags: self.table.flags(self.pos).unwrap(),
+                population: self.table.population(self.pos).unwrap(),
+                individual: self.table.individual(self.pos).unwrap(),
+                metadata: match self.decode_metadata {
+                    true => match metadata_to_vector!(self.table, self.pos).unwrap() {
+                        Some(x) => Some(x),
+                        None => None,
+                    },
+                    false => None,
+                },
+            };
+            self.pos += 1;
+            Some(rv)
+        } else {
+            None
+        }
+    }
+}
+
 /// An immtable view of a node table.
 ///
 /// These are not created directly.
@@ -78,4 +115,18 @@ impl<'a> NodeTable<'a> {
         let buffer = metadata_to_vector!(self, row)?;
         decode_metadata_row!(T, buffer)
     }
+
+    /// Return an iterator over rows of the table.
+    /// The value of the iterator is [`NodeTableRow`].
+    ///
+    /// # Parameters
+    ///
+    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
+    ///    will be provided in [`NodeTableRow::metadata`].
+    ///    The meta data are *not* decoded.
+    ///    Rows with no metadata will contain the value `None`.
+    ///
+    pub fn iter(&self, decode_metadata: bool) -> NodeTableIterator {
+        crate::table_iterator::make_table_iterator(self, decode_metadata)
+    }
 }

src/population_table.rs

@@ -3,6 +3,36 @@ use crate::metadata;
 use crate::TskitError;
 use crate::{tsk_id_t, tsk_size_t};
 
+/// Row of a [`PopulationTable`]
+pub struct PopulationTableRow {
+    pub metadata: Option<Vec<u8>>,
+}
+
+pub type PopulationTableIterator<'a> =
+    crate::table_iterator::TableIterator<'a, PopulationTable<'a>>;
+
+impl<'a> Iterator for PopulationTableIterator<'a> {
+    type Item = PopulationTableRow;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.table.num_rows() as tsk_id_t {
+            let rv = PopulationTableRow {
+                metadata: match self.decode_metadata {
+                    true => match metadata_to_vector!(self.table, self.pos).unwrap() {
+                        Some(x) => Some(x),
+                        None => None,
+                    },
+                    false => None,
+                },
+            };
+            self.pos += 1;
+            Some(rv)
+        } else {
+            None
+        }
+    }
+}
+
 /// An immutable view of site table.
 ///
 /// These are not created directly.
@@ -29,4 +59,18 @@ impl<'a> PopulationTable<'a> {
         let buffer = metadata_to_vector!(self, row)?;
         decode_metadata_row!(T, buffer)
     }
+
+    /// Return an iterator over rows of the table.
+    /// The value of the iterator is [`PopulationTableRow`].
+    ///
+    /// # Parameters
+    ///
+    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
+    ///    will be provided in [`PopulationTableRow::metadata`].
+    ///    The meta data are *not* decoded.
+    ///    Rows with no metadata will contain the value `None`.
+    ///
+    pub fn iter(&self, decode_metadata: bool) -> PopulationTableIterator {
+        crate::table_iterator::make_table_iterator(self, decode_metadata)
+    }
 }

src/site_table.rs

@@ -3,6 +3,39 @@ use crate::metadata;
 use crate::TskitError;
 use crate::{tsk_id_t, tsk_size_t};
 
+/// Row of a [`SiteTable`]
+pub struct SiteTableRow {
+    pub position: f64,
+    pub ancestral_state: Option<Vec<u8>>,
+    pub metadata: Option<Vec<u8>>,
+}
+
+pub type SiteTableIterator<'a> = crate::table_iterator::TableIterator<'a, SiteTable<'a>>;
+
+impl<'a> Iterator for SiteTableIterator<'a> {
+    type Item = SiteTableRow;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.table.num_rows() as tsk_id_t {
+            let rv = SiteTableRow {
+                position: self.table.position(self.pos).unwrap(),
+                ancestral_state: self.table.ancestral_state(self.pos).unwrap(),
+                metadata: match self.decode_metadata {
+                    true => match metadata_to_vector!(self.table, self.pos).unwrap() {
+                        Some(x) => Some(x),
+                        None => None,
+                    },
+                    false => None,
+                },
+            };
+            self.pos += 1;
+            Some(rv)
+        } else {
+            None
+        }
+    }
+}
+
 /// An immutable view of site table.
 ///
 /// These are not created directly.
@@ -59,4 +92,18 @@ impl<'a> SiteTable<'a> {
         let buffer = metadata_to_vector!(self, row)?;
         decode_metadata_row!(T, buffer)
     }
+
+    /// Return an iterator over rows of the table.
+    /// The value of the iterator is [`SiteTableRow`].
+    ///
+    /// # Parameters
+    ///
+    /// * `decode_metadata`: if `true`, then a *copy* of row metadata
+    ///    will be provided in [`SiteTableRow::metadata`].
+    ///    The meta data are *not* decoded.
+    ///    Rows with no metadata will contain the value `None`.
+    ///
+    pub fn iter(&self, decode_metadata: bool) -> SiteTableIterator {
+        crate::table_iterator::make_table_iterator(self, decode_metadata)
+    }
 }