code cleanup

Author: SpectraL519

README.md

@@ -128,7 +128,6 @@ The instructions and requirements of working on the `CPP-GL` project can be foun
 
 ## Compiler support
 
-<!--TODO: verify whether the min compiler version is correct for C++23-->
 | Compiler | Min version |
 | :-: | :-: |
 | GNU G++ | 14 |

docs/graph.md

@@ -344,6 +344,7 @@ Based on the specified traits, the `graph` class defines the following types:
     - `source_id: types::id_type` – the ID of the source vertex.
     - `target_id_range: const IdRange&` – a range of target vertex IDs to connect to the source vertex.
   - *Return type*: `void`
+  - *NOTE:* For an adjacency matrix representation passing a range with duplicate IDs will result in an error.
 
 - **`graph.add_edges_from(source, target_range)`**:
   - *Description*: Adds multiple edges from a specified source vertex to a range of target vertices (specified by references).
@@ -353,6 +354,7 @@ Based on the specified traits, the `graph` class defines the following types:
     - `source: const vertex_type&` – the source vertex.
     - `target_range: const VertexRefRange&` – a range of target vertex references to connect to the source vertex.
   - *Return type*: `void`
+  - *NOTE:* For an adjacency matrix representation passing a range with duplicate vertices will result in an error.
 
 > [!IMPORTANT]
 > Behaviour of adding an edge between `first` and `second`:

include/gl/algorithm/dijkstra.hpp

@@ -118,8 +118,8 @@ template <
         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(),
-            edge.second(),
+            edge.source(),
+            edge.target(),
             get_weight<GraphType>(edge)
         ));
     }

include/gl/edge_descriptor.hpp

@@ -30,19 +30,19 @@ class edge_descriptor final {
     }
 
     explicit edge_descriptor(
-        const types::id_type id, const types::id_type first, const types::id_type second
+        const types::id_type id, const types::id_type source, const types::id_type target
     )
     requires(type_traits::c_empty_properties<properties_type>)
-    : _id(id), _vertices(first, second) {}
+    : _id(id), _vertices(source, target) {}
 
     explicit edge_descriptor(
         const types::id_type id,
-        const types::id_type first,
-        const types::id_type second,
+        const types::id_type source,
+        const types::id_type target,
         properties_type& properties
     )
     requires(type_traits::c_non_empty_properties<properties_type>)
-    : _id(id), _vertices(first, second), _properties(properties) {}
+    : _id(id), _vertices(source, target), _properties(properties) {}
 
     [[nodiscard]] gl_attr_force_inline static edge_descriptor invalid() noexcept
     requires(type_traits::c_empty_properties<properties_type>)
@@ -114,12 +114,12 @@ class edge_descriptor final {
     }
 
     // TODO: rename to source
-    [[nodiscard]] gl_attr_force_inline const types::id_type first() const noexcept {
+    [[nodiscard]] gl_attr_force_inline const types::id_type source() const noexcept {
         return this->_vertices.first;
     }
 
     // TODO: rename to target
-    [[nodiscard]] gl_attr_force_inline const types::id_type second() const noexcept {
+    [[nodiscard]] gl_attr_force_inline const types::id_type target() const noexcept {
         return this->_vertices.second;
     }
 
@@ -158,7 +158,9 @@ class edge_descriptor final {
     }
 
     [[nodiscard]] gl_attr_force_inline properties_ref_type properties() const {
-        // TODO: throw if edge is invalid
+        if (not this->is_valid())
+            throw std::logic_error("Cannot access properties of an invalid edge");
+
         return this->_properties.get();
     }
 
@@ -180,7 +182,7 @@ class edge_descriptor final {
             }
 
             if (io::is_option_set(os, io::graph_option::verbose)) {
-                os << "[first: " << this->_vertices.first << ", second: " << this->_vertices.second
+                os << "[source: " << this->_vertices.first << ", target: " << this->_vertices.second
                    << " | properties: " << this->_properties.get() << "]";
             }
             else {
@@ -192,7 +194,7 @@ class edge_descriptor final {
 
     void _write_no_properties(std::ostream& os) const {
         if (io::is_option_set(os, io::graph_option::verbose))
-            os << "[first: " << this->_vertices.first << ", second: " << this->_vertices.first
+            os << "[source: " << this->_vertices.first << ", target: " << this->_vertices.first
                << "]";
         else
             os << "[" << this->_vertices.first << ", " << this->_vertices.second << "]";

include/gl/edge_tags.hpp

@@ -26,8 +26,6 @@ class edge_descriptor;
 
 namespace type_traits {
 
-// TODO: use concepts
-
 template <typename T>
 inline constexpr bool is_directed_v = false;
 

include/gl/graph.hpp

@@ -300,7 +300,6 @@ class graph final {
         const types::id_type source_id,
         const type_traits::c_sized_range_of<types::id_type> auto& target_id_range
     ) {
-        // TODO: validate no duplicate target ids
         this->_verify_vertex_id(source_id);
 
         for (const auto target_id : target_id_range) {
@@ -320,7 +319,6 @@ class graph final {
         const vertex_type& source,
         const type_traits::c_sized_range_of<vertex_type> auto& target_range
     ) {
-        // TODO: validate no duplicate targets
         this->_verify_vertex_id(source.id());
 
         for (const auto& target : target_range) {
@@ -472,7 +470,7 @@ class graph final {
     [[nodiscard]] bool are_incident(const edge_type& edge_1, const edge_type& edge_2) const {
         this->_verify_edge(edge_1);
         this->_verify_edge(edge_2);
-        return edge_1.is_incident_with(edge_2.first()) or edge_1.is_incident_with(edge_2.second());
+        return edge_1.is_incident_with(edge_2.source()) or edge_1.is_incident_with(edge_2.target());
     }
 
     // --- property methods ---
@@ -541,13 +539,13 @@ class graph final {
     }
 
     void _verify_edge(const edge_type& edge) const {
-        if (edge.id() >= this->_n_unique_edges or not this->has_vertex(edge.first())
-            or not this->has_vertex(edge.second()))
+        if (edge.id() >= this->_n_unique_edges or not this->has_vertex(edge.source())
+            or not this->has_vertex(edge.target()))
             throw std::invalid_argument(std::format(
                 "Got invalid edge [id = {}, vertices = ({}, {})]",
                 edge.id(),
-                edge.first(),
-                edge.second()
+                edge.source(),
+                edge.target()
             ));
     }
 
@@ -623,9 +621,9 @@ class graph final {
             if (with_edge_properties) {
                 const auto print_incident_edges = [this, &os](const types::id_type vertex_id) {
                     for (const auto& edge : this->adjacent_edges(vertex_id)) {
-                        if (edge.first() != vertex_id)
+                        if (edge.source() != vertex_id)
                             continue; // vertex is not the source
-                        os << edge.first() << ' ' << edge.second() << ' ' << edge.properties()
+                        os << edge.source() << ' ' << edge.target() << ' ' << edge.properties()
                            << '\n';
                     }
                 };
@@ -639,9 +637,9 @@ class graph final {
 
         const auto print_incident_edges = [this, &os](const types::id_type vertex_id) {
             for (const auto& edge : this->adjacent_edges(vertex_id)) {
-                if (edge.first() != vertex_id)
+                if (edge.source() != vertex_id)
                     continue; // vertex is not the source
-                os << edge.first() << ' ' << edge.second() << '\n';
+                os << edge.source() << ' ' << edge.target() << '\n';
             }
         };
 

include/gl/impl/adjacency_list.hpp

@@ -21,7 +21,7 @@ class adjacency_list final {
 public:
     using vertex_type = typename GraphTraits::vertex_type;
     using edge_type = typename GraphTraits::edge_type;
-    using edge_item_list_type = std::vector<specialized::edge_list_item>;
+    using edge_item_list_type = std::vector<specialized::adjacency_list_item>;
     using adjacency_list_type = std::vector<edge_item_list_type>;
 
     adjacency_list(const adjacency_list&) = delete;
@@ -105,7 +105,7 @@ class adjacency_list final {
 
     [[nodiscard]] gl_attr_force_inline bool has_edge(const edge_type& edge) const {
         return std::ranges::contains(
-            this->_list[edge.first()], specialized::edge_list_item{edge.id(), edge.second()}
+            this->_list[edge.source()], specialized::adjacency_list_item{edge.id(), edge.target()}
         );
     }
 

include/gl/impl/adjacency_matrix.hpp

@@ -115,7 +115,7 @@ class adjacency_matrix final {
     }
 
     [[nodiscard]] bool has_edge(const edge_type& edge) const {
-        return this->_matrix[edge.first()][edge.second()] == edge.id();
+        return this->_matrix[edge.source()][edge.target()] == edge.id();
     }
 
     [[nodiscard]] std::optional<edge_type> get_edge(

include/gl/impl/specialized/adjacency_list.hpp

@@ -19,27 +19,26 @@ class adjacency_list;
 
 namespace specialized {
 
-// adjacency list edge item
-struct edge_list_item { // TODO: rename to adjacency_list_item
+struct adjacency_list_item {
     types::id_type id;
     types::id_type target_id;
 
-    [[nodiscard]] bool operator==(const edge_list_item&) const = default;
+    [[nodiscard]] bool operator==(const adjacency_list_item&) const = default;
 };
 
 namespace detail {
 
 [[nodiscard]] auto strict_find(
-    type_traits::c_range_of<edge_list_item> auto& edge_list, const auto& edge
+    type_traits::c_range_of<adjacency_list_item> auto& edge_list, const auto& edge
 ) {
     // find the edge by address
-    const auto it = std::ranges::find(edge_list, edge.id(), &edge_list_item::id);
+    const auto it = std::ranges::find(edge_list, edge.id(), &adjacency_list_item::id);
     if (it == edge_list.end())
         throw std::invalid_argument(std::format(
             "Got invalid edge [id = {} | vertices = ({}, {})]",
             edge.id(),
-            edge.first(),
-            edge.second()
+            edge.source(),
+            edge.target()
         ));
 
     return it;
@@ -58,7 +57,8 @@ struct directed_adjacency_list {
     ) {
         types::size_type in_deg = constants::default_size;
         for (const auto& adjacent_edges : self._list)
-            in_deg += std::ranges::count(adjacent_edges, vertex_id, &edge_list_item::target_id);
+            in_deg +=
+                std::ranges::count(adjacent_edges, vertex_id, &adjacency_list_item::target_id);
 
         return in_deg;
     }
@@ -112,7 +112,7 @@ struct directed_adjacency_list {
         impl_type& self, const types::id_type vertex_id
     ) {
         auto removed_edges =
-            self._list[vertex_id] | std::views::transform(&edge_list_item::id)
+            self._list[vertex_id] | std::views::transform(&adjacency_list_item::id)
             | std::ranges::to<std::vector>();
 
         // remove all edges incident to the vertex
@@ -157,7 +157,7 @@ struct directed_adjacency_list {
     }
 
     gl_attr_force_inline static void remove_edge(impl_type& self, const edge_type& edge) {
-        auto& adj_edges = self._list[edge.first()];
+        auto& adj_edges = self._list[edge.source()];
         adj_edges.erase(detail::strict_find(adj_edges, edge));
     }
 };
@@ -226,7 +226,7 @@ struct undirected_adjacency_list {
 
         // remove the list of edges incident from the vertex entirely
         const auto removed_edges =
-            self._list[vertex_id] | std::views::transform(&edge_list_item::id)
+            self._list[vertex_id] | std::views::transform(&adjacency_list_item::id)
             | std::ranges::to<std::vector>();
         self._list.erase(std::next(std::begin(self._list), vertex_id));
         return removed_edges;
@@ -257,8 +257,8 @@ struct undirected_adjacency_list {
     }
 
     static void remove_edge(impl_type& self, const edge_type& edge) {
-        auto& adj_edges_first = self._list[edge.first()];
-        auto& adj_edges_second = self._list[edge.second()];
+        auto& adj_edges_first = self._list[edge.source()];
+        auto& adj_edges_second = self._list[edge.target()];
 
         if (edge.is_loop()) {
             adj_edges_first.erase(detail::strict_find(adj_edges_first, edge));

include/gl/impl/specialized/adjacency_matrix.hpp

@@ -275,7 +275,7 @@ struct undirected_adjacency_matrix {
             detail::strict_get(self._matrix, edge) = constants::invalid_id;
             // if the edge was found in the first matrix cell,
             // it will also be present in the second matrix cell
-            self._matrix[edge.second()][edge.first()] = constants::invalid_id;
+            self._matrix[edge.target()][edge.source()] = constants::invalid_id;
         }
     }
 };