remove use of table views in table collection

Author: molpopgen

src/table_collection.rs

@@ -1,4 +1,3 @@
-use delegate::delegate;
 use std::vec;
 
 use crate::error::TskitError;
@@ -7,6 +6,8 @@ use crate::metadata::MigrationMetadata;
 use crate::metadata::MutationMetadata;
 use crate::metadata::PopulationMetadata;
 use crate::metadata::SiteMetadata;
+#[cfg(feature = "provenance")]
+use crate::provenance::ProvenanceTable;
 use crate::sys::bindings as ll_bindings;
 use crate::sys::TableCollection as LLTableCollection;
 use crate::types::Bookmark;
@@ -16,6 +17,7 @@ use crate::MigrationId;
 use crate::MigrationTable;
 use crate::MutationId;
 use crate::MutationTable;
+use crate::NodeTable;
 use crate::PopulationId;
 use crate::Position;
 use crate::SimplificationOptions;
@@ -69,7 +71,15 @@ use ll_bindings::tsk_size_t;
 pub struct TableCollection {
     inner: LLTableCollection,
     idmap: Vec<NodeId>,
-    views: crate::table_views::TableViews,
+    edges: EdgeTable,
+    nodes: NodeTable,
+    sites: SiteTable,
+    mutations: MutationTable,
+    individuals: IndividualTable,
+    populations: PopulationTable,
+    migrations: MigrationTable,
+    #[cfg(feature = "provenance")]
+    provenances: ProvenanceTable,
 }
 
 impl TableCollection {
@@ -1348,14 +1358,176 @@ impl TableCollection {
         handle_tsk_return_value!(rv)
     }
 
-    delegate! {
-        to self.views {
-            /// Get mutable reference to the [``NodeTable``](crate::NodeTable).
-            pub fn nodes_mut(&mut self) -> &mut crate::NodeTable;
-        }
+    /// Get reference to the [``EdgeTable``](crate::EdgeTable).
+    pub fn edges(&self) -> &EdgeTable {
+        &self.edges
+    }
+
+    pub fn edges_mut(&mut self) -> &mut EdgeTable {
+        &mut self.edges
+    }
+
+    /// Get reference to the [``NodeTable``](crate::NodeTable).
+    pub fn nodes(&self) -> &NodeTable {
+        &self.nodes
+    }
+
+    /// Get mutable reference to the [``NodeTable``](crate::NodeTable).
+    pub fn nodes_mut(&mut self) -> &mut NodeTable {
+        &mut self.nodes
+    }
+
+    /// Get reference to the [``SiteTable``](crate::SiteTable).
+    pub fn sites(&self) -> &SiteTable {
+        &self.sites
+    }
+
+    pub fn sites_mut(&mut self) -> &mut SiteTable {
+        &mut self.sites
+    }
+
+    /// Get reference to the [``MutationTable``](crate::MutationTable).
+    pub fn mutations(&self) -> &MutationTable {
+        &self.mutations
+    }
+
+    pub fn mutations_mut(&mut self) -> &mut MutationTable {
+        &mut self.mutations
+    }
+
+    /// Get reference to the [``IndividualTable``](crate::IndividualTable).
+    pub fn individuals(&self) -> &IndividualTable {
+        &self.individuals
+    }
+
+    pub fn individuals_mut(&mut self) -> &mut IndividualTable {
+        &mut self.individuals
+    }
+
+    /// Get reference to the [``PopulationTable``](crate::PopulationTable).
+    pub fn populations(&self) -> &PopulationTable {
+        &self.populations
+    }
+
+    pub fn populations_mut(&mut self) -> &mut PopulationTable {
+        &mut self.populations
+    }
+
+    /// Get reference to the [``MigrationTable``](crate::MigrationTable).
+    pub fn migrations(&self) -> &MigrationTable {
+        &self.migrations
+    }
+
+    pub fn migrations_mut(&mut self) -> &mut MigrationTable {
+        &mut self.migrations
+    }
+
+    #[cfg(feature = "provenance")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
+    /// Get reference to the [``ProvenanceTable``](crate::provenance::ProvenanceTable)
+    pub fn provenances(&self) -> &ProvenanceTable {
+        &self.provenances
+    }
+
+    #[cfg(feature = "provenance")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
+    /// Get reference to the [``ProvenanceTable``](crate::provenance::ProvenanceTable)
+    pub fn provenances_mut(&mut self) -> &mut ProvenanceTable {
+        &mut self.provenances
+    }
+
+    /// Return an iterator over the edges.
+    pub fn edges_iter(&self) -> impl Iterator<Item = crate::EdgeTableRow> + '_ {
+        self.edges.iter()
+    }
+
+    /// Return an iterator over the nodes.
+    pub fn nodes_iter(&self) -> impl Iterator<Item = crate::NodeTableRow> + '_ {
+        self.nodes.iter()
+    }
+
+    /// Return an iterator over the sites.
+    pub fn sites_iter(&self) -> impl Iterator<Item = crate::SiteTableRow> + '_ {
+        self.sites.iter()
+    }
+
+    /// Return an iterator over the mutations.
+    pub fn mutations_iter(&self) -> impl Iterator<Item = crate::MutationTableRow> + '_ {
+        self.mutations.iter()
     }
 
-    delegate_table_view_api!();
+    /// Return an iterator over the individuals.
+    pub fn individuals_iter(&self) -> impl Iterator<Item = crate::IndividualTableRow> + '_ {
+        self.individuals.iter()
+    }
+
+    /// Return an iterator over the populations.
+    pub fn populations_iter(&self) -> impl Iterator<Item = crate::PopulationTableRow> + '_ {
+        self.populations.iter()
+    }
+
+    /// Return an iterator over the migrations.
+    pub fn migrations_iter(&self) -> impl Iterator<Item = crate::MigrationTableRow> + '_ {
+        self.migrations.iter()
+    }
+
+    #[cfg(feature = "provenance")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
+    /// Return an iterator over provenances
+    pub fn provenances_iter(
+        &self,
+    ) -> impl Iterator<Item = crate::provenance::ProvenanceTableRow> + '_ {
+        self.provenances.iter()
+    }
+
+    /// Obtain a vector containing the indexes ("ids")
+    /// of all nodes for which [`crate::NodeFlags::is_sample`]
+    /// is `true`.
+    ///
+    /// The provided implementation dispatches to
+    /// [`crate::NodeTable::samples_as_vector`].
+    pub fn samples_as_vector(&self) -> Vec<crate::NodeId> {
+        self.nodes().samples_as_vector()
+    }
+
+    /// Obtain a vector containing the indexes ("ids") of all nodes
+    /// satisfying a certain criterion.
+    ///
+    /// The provided implementation dispatches to
+    /// [`crate::NodeTable::create_node_id_vector`].
+    ///
+    /// # Parameters
+    ///
+    /// * `f`: a function.  The function is passed the current table
+    ///    collection and each [`crate::node_table::NodeTableRow`].
+    ///    If `f` returns `true`, the index of that row is included
+    ///    in the return value.
+    ///
+    /// # Examples
+    ///
+    /// Get all nodes with time > 0.0:
+    ///
+    /// ```
+    /// let mut tables = tskit::TableCollection::new(100.).unwrap();
+    /// tables
+    ///     .add_node(tskit::NodeFlags::new_sample(), 0.0, tskit::PopulationId::NULL,
+    ///     tskit::IndividualId::NULL)
+    ///     .unwrap();
+    /// tables
+    ///     .add_node(tskit::NodeFlags::new_sample(), 1.0, tskit::PopulationId::NULL,
+    ///     tskit::IndividualId::NULL)
+    ///     .unwrap();
+    /// let samples = tables.create_node_id_vector(
+    ///     |row: &tskit::NodeTableRow| row.time > 0.,
+    /// );
+    /// assert_eq!(samples[0], 1);
+    /// ```
+    pub fn create_node_id_vector(
+        &self,
+        f: impl FnMut(&crate::NodeTableRow) -> bool,
+    ) -> Vec<crate::NodeId> {
+        self.nodes().create_node_id_vector(f)
+    }
 
     /// Pointer to the low-level C type.
     pub fn as_ptr(&self) -> *const ll_bindings::tsk_table_collection_t {