algs aligned

Author: SpectraL519

include/gl/algorithm/dijkstra.hpp

@@ -82,7 +82,7 @@ template <
     paths.predecessors.at(source_id).emplace(source_id);
     paths.distances[source_id] = distance_type{};
 
-    std::optional<types::const_ref_wrap<edge_type>> negative_edge;
+    std::optional<edge_type> negative_edge;
 
     impl::pfs(
         graph,
@@ -98,7 +98,7 @@ template <
 
             const auto edge_weight = get_weight<GraphType>(in_edge);
             if (edge_weight < constants::zero) {
-                negative_edge = std::cref(in_edge);
+                negative_edge.emplace(in_edge);
                 return predicate_result::unknown;
             }
 
@@ -115,7 +115,7 @@ template <
     );
 
     if (negative_edge.has_value()) {
-        const auto& edge = negative_edge.value().get();
+        const auto& edge = negative_edge.value();
         throw std::invalid_argument(std::format(
             "[alg::dijkstra_shortest_paths] Found an edge with a negative weight: [{}, {} | w={}]",
             edge.first(),

include/gl/algorithm/mst.hpp

@@ -22,7 +22,7 @@ struct mst_descriptor {
         edges.reserve(n_vertices - constants::one);
     }
 
-    std::vector<types::const_ref_wrap<edge_type>> edges;
+    std::vector<edge_type> edges;
     weight_type weight = static_cast<weight_type>(constants::zero);
 };
 
@@ -41,7 +41,7 @@ template <type_traits::c_undirected_graph GraphType>
         [[nodiscard]] gl_attr_force_inline bool operator()(
             const edge_info_type& lhs, const edge_info_type& rhs
         ) const {
-            return get_weight<GraphType>(lhs.edge.get()) > get_weight<GraphType>(rhs.edge.get());
+            return get_weight<GraphType>(lhs.edge) > get_weight<GraphType>(rhs.edge);
         }
     };
 
@@ -69,7 +69,7 @@ template <type_traits::c_undirected_graph GraphType>
         const auto min_edge_info = edge_queue.top();
         edge_queue.pop();
 
-        const auto& min_edge = min_edge_info.edge.get();
+        const auto& min_edge = min_edge_info.edge;
         const auto min_weight = get_weight<GraphType>(min_edge);
 
         const auto& target_id = min_edge.incident_vertex(min_edge_info.source_id);
@@ -107,7 +107,7 @@ requires type_traits::c_has_numeric_limits_max<types::vertex_distance_type<Graph
 
     std::vector<bool> in_mst(n_vertices, false);
     std::vector<distance_type> min_cost(n_vertices, std::numeric_limits<distance_type>::max());
-    std::vector<const edge_type*> min_cost_edges(n_vertices, nullptr);
+    std::vector<std::optional<edge_type>> min_cost_edges(n_vertices, std::nullopt);
 
     // set the distance to the root vertex to 0
     min_cost.at(root_id_opt.value_or(constants::zero)) = constants::zero;
@@ -132,8 +132,8 @@ requires type_traits::c_has_numeric_limits_max<types::vertex_distance_type<Graph
 
         in_mst[vertex_id] = true;
 
-        const auto* min_cost_edge = min_cost_edges[vertex_id];
-        if (min_cost_edge != nullptr) { // Add the corresponding edge to MST
+        const auto min_cost_edge = min_cost_edges[vertex_id];
+        if (min_cost_edge.has_value()) { // Add the corresponding edge to MST
             mst.edges.emplace_back(*min_cost_edge);
             mst.weight += min_cost[vertex_id];
         }
@@ -145,7 +145,7 @@ requires type_traits::c_has_numeric_limits_max<types::vertex_distance_type<Graph
 
             if (not in_mst[incident_vertex_id] && edge_weight < min_cost[incident_vertex_id]) {
                 min_cost[incident_vertex_id] = edge_weight;
-                min_cost_edges[incident_vertex_id] = &edge;
+                min_cost_edges[incident_vertex_id].emplace(edge);
             }
         }
 

include/gl/algorithm/types.hpp

@@ -31,7 +31,7 @@ template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
 struct edge_info {
     using edge_type = EdgeType;
 
-    types::const_ref_wrap<edge_type> edge;
+    edge_type edge;
     types::id_type source_id;
 };
 

include/gl/edge_descriptor.hpp

@@ -159,7 +159,7 @@ class edge_descriptor final {
 
     [[nodiscard]] gl_attr_force_inline properties_ref_type properties() const {
         // TODO: throw if edge is invalid
-        return this->_properties;
+        return this->_properties.get();
     }
 
     friend inline std::ostream& operator<<(std::ostream& os, const edge_descriptor& edge) {
@@ -181,11 +181,11 @@ class edge_descriptor final {
 
             if (io::is_option_set(os, io::graph_option::verbose)) {
                 os << "[first: " << this->_vertices.first << ", second: " << this->_vertices.second
-                   << " | properties: " << this->_properties << "]";
+                   << " | properties: " << this->_properties.get() << "]";
             }
             else {
                 os << "[" << this->_vertices.first << ", " << this->_vertices.second << " | "
-                   << this->_properties << "]";
+                   << this->_properties.get() << "]";
             }
         }
     }
@@ -200,7 +200,10 @@ class edge_descriptor final {
 
     types::id_type _id;
     types::homogeneous_pair<types::id_type> _vertices;
-    [[no_unique_address]] properties_ref_type _properties;
+    [[no_unique_address]] std::conditional_t<
+        type_traits::c_empty_properties<properties_type>,
+        types::empty_properties,
+        std::reference_wrapper<properties_type>> _properties;
 };
 
 template <

include/gl/vertex_descriptor.hpp

@@ -56,7 +56,7 @@ class vertex_descriptor final {
     }
 
     [[nodiscard]] gl_attr_force_inline properties_ref_type properties() const {
-        return this->_properties;
+        return this->_properties.get();
     }
 
     friend inline std::ostream& operator<<(std::ostream& os, const vertex_descriptor& vertex) {
@@ -77,10 +77,10 @@ class vertex_descriptor final {
             }
 
             if (io::is_option_set(os, io::graph_option::verbose)) {
-                os << "[id: " << this->_id << " | properties: " << this->_properties << "]";
+                os << "[id: " << this->_id << " | properties: " << this->_properties.get() << "]";
             }
             else {
-                os << "[" << this->_id << " | " << this->_properties << "]";
+                os << "[" << this->_id << " | " << this->_properties.get() << "]";
             }
         }
     }
@@ -95,7 +95,10 @@ class vertex_descriptor final {
     }
 
     types::id_type _id;
-    [[no_unique_address]] properties_ref_type _properties;
+    [[no_unique_address]] std::conditional_t<
+        type_traits::c_empty_properties<properties_type>,
+        types::empty_properties,
+        std::reference_wrapper<properties_type>> _properties;
 };
 
 template <type_traits::c_properties Properties = types::empty_properties>