edges store only vertex ids

Author: SpectraL519

include/gl/algorithm/coloring.hpp

@@ -26,8 +26,7 @@ template <
     coloring_opt.emplace(graph.n_vertices(), bin_color_value::unset);
     auto& coloring = coloring_opt.value();
 
-    for (const auto root_vertex : graph.vertices()) {
-        const auto root_id = root_vertex.id();
+    for (const auto root_id : graph.vertex_ids()) {
         if (coloring[root_id].is_set())
             continue;
 
@@ -44,7 +43,7 @@ template <
                 if (in_edge.is_loop())
                     return false;
 
-                const auto pred_id = in_edge.incident_vertex(vertex_id).id();
+                const auto pred_id = in_edge.incident_vertex(vertex_id);
 
                 if (coloring[vertex_id] == coloring[pred_id])
                     return predicate_result::unknown; // graph is not bipartite

include/gl/algorithm/dijkstra.hpp

@@ -94,7 +94,7 @@ template <
         algorithm::empty_callback{}, // visit callback
         [&paths, &negative_edge](const types::id_type vertex_id, const edge_type& in_edge)
             -> predicate_result { // enqueue predicate
-            const auto pred_id = in_edge.incident_vertex(vertex_id).id();
+            const auto pred_id = in_edge.incident_vertex(vertex_id);
 
             const auto edge_weight = get_weight<GraphType>(in_edge);
             if (edge_weight < constants::zero) {
@@ -118,8 +118,8 @@ template <
         const auto& edge = negative_edge.value().get();
         throw std::invalid_argument(std::format(
             "[alg::dijkstra_shortest_paths] Found an edge with a negative weight: [{}, {} | w={}]",
-            edge.first().id(),
-            edge.second().id(),
+            edge.first(),
+            edge.second(),
             get_weight<GraphType>(edge)
         ));
     }

include/gl/algorithm/impl/bfs.hpp

@@ -56,7 +56,7 @@ bool bfs(
                 return false;
 
         for (const auto& edge : graph.adjacent_edges(vinfo.id)) {
-            const auto incident_vertex_id = edge.incident_vertex(vinfo.id).id();
+            const auto incident_vertex_id = edge.incident_vertex(vinfo.id);
 
             const auto enqueue = enqueue_vertex_pred(incident_vertex_id, edge);
             if (enqueue == predicate_result::unknown)

include/gl/algorithm/impl/dfs.hpp

@@ -52,7 +52,7 @@ void dfs(
         visit(vinfo.id, vinfo.pred_id);
 
         for (const auto& edge : graph.adjacent_edges(vinfo.id)) {
-            const auto incident_vertex_id = edge.incident_vertex(vinfo.id).id();
+            const auto incident_vertex_id = edge.incident_vertex(vinfo.id);
             if (enqueue_vertex_pred(incident_vertex_id, edge))
                 vertex_stack.emplace(incident_vertex_id, vinfo.id);
         }
@@ -91,7 +91,7 @@ void r_dfs(
 
     // recursively search vertices adjacent to the current vertex
     for (const auto& edge : graph.adjacent_edges(vertex_id)) {
-        const auto& incident_vertex_id = edge.incident_vertex(vertex_id).id();
+        const auto& incident_vertex_id = edge.incident_vertex(vertex_id);
         if (enqueue_vertex_pred(incident_vertex_id, edge))
             r_dfs(
                 graph,

include/gl/algorithm/impl/pfs.hpp

@@ -59,7 +59,7 @@ bool pfs(
                 return false;
 
         for (const auto& edge : graph.adjacent_edges(vinfo.id)) {
-            const auto incident_vertex_id = edge.incident_vertex(vinfo.id).id();
+            const auto incident_vertex_id = edge.incident_vertex(vinfo.id);
 
             const auto enqueue = enqueue_vertex_pred(incident_vertex_id, edge);
             if (enqueue == predicate_result::unknown)

include/gl/algorithm/mst.hpp

@@ -72,7 +72,7 @@ template <type_traits::c_undirected_graph GraphType>
         const auto& min_edge = min_edge_info.edge.get();
         const auto min_weight = get_weight<GraphType>(min_edge);
 
-        const auto& target_id = min_edge.incident_vertex(min_edge_info.source_id).id();
+        const auto& target_id = min_edge.incident_vertex(min_edge_info.source_id);
         if (visited[target_id])
             continue;
 
@@ -85,7 +85,7 @@ template <type_traits::c_undirected_graph GraphType>
 
         // enqueue all edges adjacent to the `target` vertex if they lead to unvisited verties
         for (const auto& edge : graph.adjacent_edges(target_id))
-            if (not visited[edge.incident_vertex(target_id).id()])
+            if (not visited[edge.incident_vertex(target_id)])
                 edge_queue.emplace(edge, target_id);
     }
 
@@ -141,7 +141,7 @@ requires type_traits::c_has_numeric_limits_max<types::vertex_distance_type<Graph
         // Update adjacent vertices
         for (const auto& edge : graph.adjacent_edges(vertex_id)) {
             const auto edge_weight = get_weight<GraphType>(edge);
-            const auto incident_vertex_id = edge.incident_vertex(vertex_id).id();
+            const auto incident_vertex_id = edge.incident_vertex(vertex_id);
 
             if (not in_mst[incident_vertex_id] && edge_weight < min_cost[incident_vertex_id]) {
                 min_cost[incident_vertex_id] = edge_weight;

include/gl/edge_descriptor.hpp

@@ -11,13 +11,11 @@
 namespace gl {
 
 template <
-    type_traits::c_instantiation_of<vertex_descriptor> VertexType,
     type_traits::c_edge_directional_tag DirectionalTag = directed_t,
     type_traits::c_properties Properties = types::empty_properties>
 class edge_descriptor final {
 public:
-    using type = edge_descriptor<VertexType, DirectionalTag, Properties>;
-    using vertex_type = VertexType;
+    using type = edge_descriptor<DirectionalTag, Properties>;
     using directional_tag = DirectionalTag;
     using properties_type = Properties;
     using properties_ref_type = std::conditional_t<
@@ -34,14 +32,14 @@ class edge_descriptor final {
     edge_descriptor(const edge_descriptor&) = delete;
     edge_descriptor& operator=(const edge_descriptor&) = delete;
 
-    explicit edge_descriptor(const vertex_type first, const vertex_type& second)
-    : _vertices(std::move(first), std::move(second)) {}
+    explicit edge_descriptor(const types::id_type first, const types::id_type second)
+    : _vertices(first, second) {}
 
     explicit edge_descriptor(
-        const vertex_type first, const vertex_type second, properties_type properties
+        const types::id_type first, const types::id_type second, properties_type properties
     )
     requires(not type_traits::is_default_properties_type_v<properties_type>)
-    : _vertices(std::move(first), std::move(second)), _properties(properties) {}
+    : _vertices(first, second), _properties(properties) {}
 
     edge_descriptor(edge_descriptor&&) = default;
     edge_descriptor& operator=(edge_descriptor&&) = default;
@@ -59,68 +57,45 @@ class edge_descriptor final {
     // clang-format off
     // gl_attr_force_inline misplacement
 
-    [[nodiscard]] gl_attr_force_inline
-    const types::homogeneous_pair<const vertex_type>& incident_vertices() const {
+    [[nodiscard]] gl_attr_force_inline types::homogeneous_pair<const types::id_type> incident_vertices() const {
         return this->_vertices;
     }
 
-    [[nodiscard]] gl_attr_force_inline const types::homogeneous_pair<types::id_type> incident_vertex_ids() const {
-        return std::make_pair(this->_vertices.first.id(), this->_vertices.second.id());
-    }
-
-    [[nodiscard]] gl_attr_force_inline const vertex_type& first() const {
+    [[nodiscard]] gl_attr_force_inline const types::id_type first() const {
         return this->_vertices.first;
     }
 
-    [[nodiscard]] gl_attr_force_inline const vertex_type& second() const {
+    [[nodiscard]] gl_attr_force_inline const types::id_type second() const {
         return this->_vertices.second;
     }
 
     // clang-format on
 
     // returns the `other` vertex or throws error if the given vertex is not incident with the edge
-    [[nodiscard]] const vertex_type incident_vertex(const types::id_type vertex_id) const {
-        if (vertex_id == this->_vertices.first.id())
+    [[nodiscard]] const types::id_type incident_vertex(const types::id_type vertex_id) const {
+        if (vertex_id == this->_vertices.first)
             return this->_vertices.second;
 
-        if (vertex_id == this->_vertices.second.id())
+        if (vertex_id == this->_vertices.second)
             return this->_vertices.first;
 
         throw std::invalid_argument(std::format("Got invalid vertex id: {}", vertex_id));
     }
 
-    [[nodiscard]] const vertex_type incident_vertex(const vertex_type& vertex) const {
-        return this->incident_vertex(vertex.id());
-    }
-
     [[nodiscard]] gl_attr_force_inline bool is_incident_with(const types::id_type vertex_id) const {
-        return vertex_id == this->_vertices.first.id() or vertex_id == this->_vertices.second.id();
-    }
-
-    [[nodiscard]] gl_attr_force_inline bool is_incident_with(const vertex_type& vertex) const {
-        return this->is_incident_with(vertex.id());
+        return vertex_id == this->_vertices.first or vertex_id == this->_vertices.second;
     }
 
     // true if the given vertex is the `source` of the edge
     [[nodiscard]] gl_attr_force_inline bool is_incident_from(const types::id_type vertex_id) const {
         return directional_tag::is_incident_from(*this, vertex_id);
     }
 
-    // true if the given vertex is the `source` of the edge
-    [[nodiscard]] gl_attr_force_inline bool is_incident_from(const vertex_type& vertex) const {
-        return this->is_incident_from(vertex.id());
-    }
-
     // true if the given vertex is the `target` vertex of the edge
     [[nodiscard]] gl_attr_force_inline bool is_incident_to(const types::id_type vertex_id) const {
         return directional_tag::is_incident_to(*this, vertex_id);
     }
 
-    // true if the given vertex is the `target` vertex of the edge
-    [[nodiscard]] gl_attr_force_inline bool is_incident_to(const vertex_type& vertex) const {
-        return this->is_incident_to(vertex.id());
-    }
-
     [[nodiscard]] gl_attr_force_inline bool is_loop() const {
         return this->_vertices.first == this->_vertices.second;
     }
@@ -135,75 +110,49 @@ class edge_descriptor final {
     }
 
 private:
-    class vertex_writer {
-    public:
-        vertex_writer(const vertex_type& vertex, bool within_context)
-        : _vertex_ref(vertex), _within_context(within_context) {}
-
-        friend std::ostream& operator<<(std::ostream& os, const vertex_writer& vw) {
-            if (vw._within_context)
-                os << vw._vertex_ref.id();
-            else
-                os << vw._vertex_ref;
-            return os;
-        }
-
-    private:
-        const vertex_type& _vertex_ref;
-        bool _within_context;
-    };
-
-    void _write(std::ostream& os, bool within_context = false) const {
+    void _write(std::ostream& os) const {
         if constexpr (not type_traits::c_writable<properties_type>) {
-            this->_write_no_properties(os, within_context);
+            this->_write_no_properties(os);
             return;
         }
         else {
             if (not io::is_option_set(os, io::graph_option::with_edge_properties)) {
-                this->_write_no_properties(os, within_context);
+                this->_write_no_properties(os);
                 return;
             }
 
             if (io::is_option_set(os, io::graph_option::verbose)) {
-                os << "[first: " << vertex_writer(this->first(), within_context)
-                   << ", second: " << vertex_writer(this->second(), within_context)
+                os << "[first: " << this->_vertices.first << ", second: " << this->_vertices.second
                    << " | properties: " << this->_properties << "]";
             }
             else {
-                os << "[" << vertex_writer(this->first(), within_context) << ", "
-                   << vertex_writer(this->second(), within_context) << " | " << this->_properties
-                   << "]";
+                os << "[" << this->_vertices.first << ", " << this->_vertices.second << " | "
+                   << this->_properties << "]";
             }
         }
     }
 
-    void _write_no_properties(std::ostream& os, bool within_context = false) const {
+    void _write_no_properties(std::ostream& os) const {
         if (io::is_option_set(os, io::graph_option::verbose))
-            os << "[first: " << vertex_writer(this->first(), within_context)
-               << ", second: " << vertex_writer(this->second(), within_context) << "]";
+            os << "[first: " << this->_vertices.first << ", second: " << this->_vertices.first
+               << "]";
         else
-            os << "[" << vertex_writer(this->first(), within_context) << ", "
-               << vertex_writer(this->second(), within_context) << "]";
+            os << "[" << this->_vertices.first << ", " << this->_vertices.second << "]";
     }
 
-    types::homogeneous_pair<const vertex_type> _vertices;
+    types::homogeneous_pair<types::id_type> _vertices;
     [[no_unique_address]] mutable properties_type _properties{};
 };
 
 template <
-    type_traits::c_instantiation_of<vertex_descriptor> VertexType,
     type_traits::c_edge_directional_tag DirectionalTag = directed_t,
     type_traits::c_properties Properties = types::empty_properties>
-using edge = edge_descriptor<VertexType, DirectionalTag, Properties>;
+using edge = edge_descriptor<DirectionalTag, Properties>;
 
-template <
-    type_traits::c_instantiation_of<vertex_descriptor> VertexType,
-    type_traits::c_properties Properties = types::empty_properties>
-using directed_edge = edge_descriptor<VertexType, directed_t, Properties>;
+template <type_traits::c_properties Properties = types::empty_properties>
+using directed_edge = edge_descriptor<directed_t, Properties>;
 
-template <
-    type_traits::c_instantiation_of<vertex_descriptor> VertexType,
-    type_traits::c_properties Properties = types::empty_properties>
-using undirected_edge = edge_descriptor<VertexType, undirected_t, Properties>;
+template <type_traits::c_properties Properties = types::empty_properties>
+using undirected_edge = edge_descriptor<undirected_t, Properties>;
 
 } // namespace gl

include/gl/edge_tags.hpp

@@ -21,13 +21,7 @@ concept c_edge_directional_tag = c_one_of<T, directed_t, undirected_t>;
 
 } // namespace type_traits
 
-template <type_traits::c_properties Properties>
-class vertex_descriptor;
-
-template <
-    type_traits::c_instantiation_of<vertex_descriptor> VertexType,
-    type_traits::c_edge_directional_tag EdgeTag,
-    type_traits::c_properties Properties>
+template <type_traits::c_edge_directional_tag EdgeTag, type_traits::c_properties Properties>
 class edge_descriptor;
 
 namespace type_traits {
@@ -58,16 +52,16 @@ struct directed_t {
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
     requires(type_traits::is_directed_v<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static edge_ptr_type<EdgeType> make(
-        const typename EdgeType::vertex_type& first, const typename EdgeType::vertex_type& second
+        const types::id_type first, const types::id_type second
     ) {
         return std::make_unique<EdgeType>(first, second);
     }
 
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
     requires(type_traits::is_directed_v<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static edge_ptr_type<EdgeType> make(
-        const typename EdgeType::vertex_type& first,
-        const typename EdgeType::vertex_type& second,
+        const types::id_type first,
+        const types::id_type second,
         const typename EdgeType::properties_type& properties
     ) {
         return std::make_unique<EdgeType>(first, second, properties);
@@ -78,15 +72,15 @@ struct directed_t {
     [[nodiscard]] gl_attr_force_inline static bool is_incident_from(
         const EdgeType& edge, const types::id_type vertex_id
     ) {
-        return vertex_id == edge._vertices.first.id();
+        return vertex_id == edge._vertices.first;
     }
 
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
     requires(type_traits::is_directed_v<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static bool is_incident_to(
         const EdgeType& edge, const types::id_type vertex_id
     ) {
-        return vertex_id == edge._vertices.second.id();
+        return vertex_id == edge._vertices.second;
     }
 };
 
@@ -100,16 +94,16 @@ struct undirected_t {
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
     requires(type_traits::is_undirected_v<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static edge_ptr_type<EdgeType> make(
-        const typename EdgeType::vertex_type& first, const typename EdgeType::vertex_type& second
+        const types::id_type first, const types::id_type second
     ) {
         return std::make_shared<EdgeType>(first, second);
     }
 
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
     requires(type_traits::is_undirected_v<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static edge_ptr_type<EdgeType> make(
-        const typename EdgeType::vertex_type& first,
-        const typename EdgeType::vertex_type& second,
+        const types::id_type first,
+        const types::id_type second,
         const typename EdgeType::properties_type& properties
     ) {
         return std::make_shared<EdgeType>(first, second, properties);
@@ -143,15 +137,15 @@ namespace detail {
 
 template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
 [[nodiscard]] gl_attr_force_inline types::edge_ptr_type<EdgeType> make_edge(
-    const typename EdgeType::vertex_type& first, const typename EdgeType::vertex_type& second
+    const types::id_type first, const types::id_type second
 ) {
     return EdgeType::directional_tag::template make<EdgeType>(first, second);
 }
 
 template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
 [[nodiscard]] gl_attr_force_inline types::edge_ptr_type<EdgeType> make_edge(
-    const typename EdgeType::vertex_type& first,
-    const typename EdgeType::vertex_type& second,
+    const types::id_type first,
+    const types::id_type second,
     const typename EdgeType::properties_type& properties
 ) {
     return EdgeType::directional_tag::template make<EdgeType>(first, second, properties);