reverse confusion

Author: tonibohnlein

include/osp/dag_divider/isomorphism_divider/IsomorphicSubgraphScheduler.hpp

@@ -39,7 +39,7 @@ class IsomorphicSubgraphScheduler {
     private:
 
     static constexpr bool verbose = false;    
-    const HashComputer<std::size_t>* hash_computer_;
+    const HashComputer<vertex_idx_t<Graph_t>>* hash_computer_;
     size_t symmetry_ = 2;
     Scheduler<Constr_Graph_t> * bsp_scheduler_;
     bool use_max_group_size_ = false;
@@ -51,7 +51,7 @@ class IsomorphicSubgraphScheduler {
     explicit IsomorphicSubgraphScheduler(Scheduler<Constr_Graph_t> & bsp_scheduler) 
         : hash_computer_(nullptr), symmetry_(2), bsp_scheduler_(&bsp_scheduler), plot_dot_graphs_(false) {}
 
-    IsomorphicSubgraphScheduler(Scheduler<Constr_Graph_t> & bsp_scheduler, const HashComputer<std::size_t>& hash_computer) 
+    IsomorphicSubgraphScheduler(Scheduler<Constr_Graph_t> & bsp_scheduler, const HashComputer<vertex_idx_t<Graph_t>>& hash_computer) 
         : hash_computer_(&hash_computer), symmetry_(2), bsp_scheduler_(&bsp_scheduler), plot_dot_graphs_(false) {}
 
     virtual ~IsomorphicSubgraphScheduler() {}
@@ -68,7 +68,7 @@ class IsomorphicSubgraphScheduler {
     std::vector<vertex_idx_t<Graph_t>> compute_partition(const BspInstance<Graph_t>& instance) {
         OrbitGraphProcessor<Graph_t, Constr_Graph_t> orbit_processor(symmetry_);
 
-        std::unique_ptr<HashComputer<std::size_t>> local_hasher;      
+        std::unique_ptr<HashComputer<vertex_idx_t<Graph_t>>> local_hasher;      
         if (!hash_computer_) {
             local_hasher = std::make_unique<MerkleHashComputer<Graph_t, bwd_merkle_node_hash_func<Graph_t>, true>>(instance.getComputationalDag(), instance.getComputationalDag());
             hash_computer_ = local_hasher.get();

include/osp/dag_divider/isomorphism_divider/MerkleHashComputer.hpp

@@ -32,7 +32,7 @@ limitations under the License.
 namespace osp {
 
 template<typename Graph_t, typename node_hash_func_t = uniform_node_hash_func<vertex_idx_t<Graph_t>>, bool forward = true>
-class MerkleHashComputer : public HashComputer<std::size_t> {
+class MerkleHashComputer : public HashComputer<vertex_idx_t<Graph_t>> {
 
     static_assert(is_directed_graph_v<Graph_t>, "Graph_t must satisfy the directed_graph concept");
     static_assert(std::is_invocable_r<std::size_t, node_hash_func_t, vertex_idx_t<Graph_t>>::value, "node_hash_func_t must be invocable with one vertex_idx_t<Graph_t> argument and return std::size_t.");

include/osp/dag_divider/isomorphism_divider/OrbitGraphProcessor.hpp

@@ -387,7 +387,7 @@ class OrbitGraphProcessor {
      * @brief Discovers isomorphic groups (orbits) and constructs a coarse graph.
      * @param dag The input computational DAG.
      */
-    void discover_isomorphic_groups(const Graph_t &dag, const HashComputer<std::size_t> &hasher) {
+    void discover_isomorphic_groups(const Graph_t &dag, const HashComputer<VertexType> &hasher) {
         coarse_graph_ = Constr_Graph_t();
         contraction_map_.clear();
         final_coarse_graph_ = Constr_Graph_t();