aligned cpp-gl to c++23

Author: SpectraL519

include/gl/algorithm/impl/bfs.hpp

@@ -39,7 +39,6 @@ bool bfs(
     using vertex_queue_type = std::queue<algorithm::vertex_info>;
     vertex_queue_type vertex_queue;
 
-    // TODO [C++23]: replace with push_range
     for (const auto& vinfo : initial_queue_content)
         vertex_queue.push(vinfo);
 

include/gl/algorithm/impl/pfs.hpp

@@ -42,7 +42,6 @@ bool pfs(
         std::priority_queue<algorithm::vertex_info, std::vector<algorithm::vertex_info>, PQCompare>;
     vertex_queue_type vertex_queue(pq_compare);
 
-    // TODO [C++23]: replace with push_range
     for (const auto& vinfo : initial_queue_content)
         vertex_queue.push(vinfo);
 

include/gl/impl/adjacency_list.hpp

@@ -54,13 +54,13 @@ class adjacency_list final {
     // --- vertex methods ---
 
     gl_attr_force_inline void add_vertex() {
-        this->_list.push_back(edge_list_type{});
+        this->_list.emplace_back(edge_list_type{});
     }
 
     inline void add_vertices(const types::size_type n) {
         this->_list.reserve(this->n_vertices() + n);
         for (types::size_type _ = constants::begin_idx; _ < n; ++_)
-            this->_list.push_back(edge_list_type{});
+            this->_list.emplace_back(edge_list_type{});
     }
 
     [[nodiscard]] gl_attr_force_inline types::size_type in_degree(const types::id_type vertex_id
@@ -172,7 +172,7 @@ class adjacency_list final {
 
         for (const auto& edge : adjacent_edges)
             if (specialized_impl::is_edge_incident_to(edge, second_id, first_id))
-                matching_edges.push_back(std::cref(*edge));
+                matching_edges.emplace_back(*edge);
 
         matching_edges.shrink_to_fit();
         return matching_edges;

include/gl/impl/adjacency_matrix.hpp

@@ -62,7 +62,7 @@ class adjacency_matrix final {
 
     void add_vertex() {
         for (auto& row : this->_matrix)
-            row.push_back(_make_null_edge());
+            row.emplace_back(_make_null_edge());
         auto& new_row = this->_matrix.emplace_back();
         new_row.reserve(this->n_vertices());
         std::generate_n(std::back_inserter(new_row), this->n_vertices(), _make_null_edge);

include/gl/impl/specialized/adjacency_list.hpp

@@ -67,15 +67,10 @@ struct directed_adjacency_list {
         const impl_type& self, const types::id_type vertex_id
     ) {
         types::size_type in_deg = constants::default_size;
-        for (types::id_type id = constants::initial_id; id < self._list.size(); ++id) {
-            const auto& adj_edges = self._list[id];
-            if (adj_edges.empty())
-                continue;
-
-            in_deg += std::ranges::count(adj_edges, vertex_id, [](const auto& edge) {
+        for (const auto& adjacent_edges : self._list)
+            in_deg += std::ranges::count(adjacent_edges, vertex_id, [](const auto& edge) {
                 return edge->second_id();
             });
-        }
 
         return in_deg;
     }
@@ -107,10 +102,9 @@ struct directed_adjacency_list {
     [[nodiscard]] gl_attr_force_inline static std::vector<types::size_type> out_degree_map(
         const impl_type& self
     ) {
-        const auto out_degree_view =
-            self._list
-            | std::views::transform([](const auto& adj_edges) { return adj_edges.size(); });
-        return std::vector<types::size_type>(out_degree_view.begin(), out_degree_view.end());
+        return self._list
+             | std::views::transform([](const auto& adj_edges) { return adj_edges.size(); })
+             | std::ranges::to<std::vector<types::size_type>>();
     }
 
     [[nodiscard]] static std::vector<types::size_type> degree_map(const impl_type& self) {
@@ -151,9 +145,9 @@ struct directed_adjacency_list {
 
     static const edge_type& add_edge(impl_type& self, edge_ptr_type edge) {
         auto& adjacent_edges_first = self._list[edge->first_id()];
-        adjacent_edges_first.push_back(std::move(edge));
+        auto& new_edge = adjacent_edges_first.emplace_back(std::move(edge));
         ++self._n_unique_edges;
-        return *adjacent_edges_first.back();
+        return *new_edge;
     }
 
     static void add_edges_from(
@@ -163,7 +157,7 @@ struct directed_adjacency_list {
         adjacent_edges_source.reserve(adjacent_edges_source.size() + new_edges.size());
 
         for (auto& edge : new_edges)
-            adjacent_edges_source.push_back(std::move(edge));
+            adjacent_edges_source.emplace_back(std::move(edge));
 
         self._n_unique_edges += new_edges.size();
     }
@@ -282,7 +276,7 @@ struct undirected_adjacency_list {
 
         if (not edge->is_loop())
             self._list[edge->second_id()].push_back(edge);
-        adjacent_edges_first.push_back(std::move(edge));
+        adjacent_edges_first.emplace_back(std::move(edge));
 
         ++self._n_unique_edges;
         return *adjacent_edges_first.back();
@@ -297,7 +291,7 @@ struct undirected_adjacency_list {
         for (auto& edge : new_edges) {
             if (not edge->is_loop())
                 self._list[edge->second_id()].push_back(edge);
-            adjacent_edges_source.push_back(std::move(edge));
+            adjacent_edges_source.emplace_back(std::move(edge));
         }
 
         self._n_unique_edges += new_edges.size();

include/gl/impl/specialized/adjacency_matrix.hpp

@@ -90,9 +90,8 @@ struct directed_adjacency_matrix {
         std::vector<types::id_type> in_degree_map(self._matrix.size(), constants::zero);
 
         for (const auto& row : self._matrix)
-            for (types::id_type id = constants::initial_id; id < self._matrix.size(); ++id)
-                if (row[id] != nullptr)
-                    ++in_degree_map[id];
+            for (auto [id, edge_ptr] : std::views::enumerate(row))
+                in_degree_map[id] += static_cast<types::size_type>(edge_ptr != nullptr);
 
         return in_degree_map;
     }
@@ -187,11 +186,10 @@ struct undirected_adjacency_matrix {
     [[nodiscard]] gl_attr_force_inline static types::size_type degree(
         const impl_type& self, const types::id_type vertex_id
     ) {
-        const auto& loop = self._matrix[vertex_id][vertex_id];
         return std::ranges::count_if(
                    self._matrix[vertex_id], [](const auto& edge) { return edge != nullptr; }
                )
-             + static_cast<types::size_type>(loop and loop->is_loop());
+             + static_cast<types::size_type>(self._matrix[vertex_id][vertex_id] != nullptr);
     }
 
     [[nodiscard]] gl_attr_force_inline static std::vector<types::size_type> in_degree_map(

include/gl/io/stream_options_manipulator.hpp

@@ -5,7 +5,6 @@
 #pragma once
 
 #include "gl/attributes/force_inline.hpp"
-#include "gl/util/enum.hpp"
 
 #include <iostream>
 
@@ -102,7 +101,7 @@ template <detail::c_bit_position_enum BitPosition>
     iword_type options_bitmask = 0ul;
     for (const auto bit_position : bit_positions)
         options_bitmask |=
-            iword_bit << static_cast<bit_position_type>(util::to_underlying(bit_position));
+            iword_bit << static_cast<bit_position_type>(std::to_underlying(bit_position));
     return options_bitmask;
 }
 
@@ -137,7 +136,7 @@ set_option(bit_position_type bit_position) {
 template <detail::c_bit_position_enum BitPosition>
 [[nodiscard]] gl_attr_force_inline stream_options_manipulator set_option(BitPosition bit_position) {
     return stream_options_manipulator::from_bit_position(
-        static_cast<bit_position_type>(util::to_underlying(bit_position)),
+        static_cast<bit_position_type>(std::to_underlying(bit_position)),
         stream_options_manipulator::set
     );
 }
@@ -172,7 +171,7 @@ template <detail::c_bit_position_enum BitPosition>
 [[nodiscard]] gl_attr_force_inline stream_options_manipulator unset_option(BitPosition bit_position
 ) {
     return stream_options_manipulator::from_bit_position(
-        static_cast<bit_position_type>(util::to_underlying(bit_position)),
+        static_cast<bit_position_type>(std::to_underlying(bit_position)),
         stream_options_manipulator::unset
     );
 }
@@ -209,7 +208,7 @@ template <detail::c_bit_position_enum BitPosition>
     std::ios_base& stream, BitPosition bit_position
 ) {
     return stream_options_manipulator::is_option_set(
-        stream, static_cast<bit_position_type>(util::to_underlying(bit_position))
+        stream, static_cast<bit_position_type>(std::to_underlying(bit_position))
     );
 }
 

include/gl/types/iterator_range.hpp

@@ -98,15 +98,13 @@ class iterator_range
         return this->_range.second;
     }
 
-#if __cplusplus >= 202302L
     [[nodiscard]] gl_attr_force_inline auto cbegin() const {
         return std::make_const_iterator(this->_range.first);
     }
 
     [[nodiscard]] gl_attr_force_inline auto cend() const {
         return std::make_const_iterator(this->_range.second);
     }
-#endif
 
     [[nodiscard]] gl_attr_force_inline distance_type distance() const
     requires(cache_mode::value == type_traits::cache_mode_value::eager)

include/gl/types/properties.hpp

@@ -5,7 +5,6 @@
 #pragma once
 
 #include "gl/attributes/force_inline.hpp"
-#include "gl/util/enum.hpp"
 #include "traits/concepts.hpp"
 
 #include <any>
@@ -186,7 +185,7 @@ class binary_color
     }
 
     [[nodiscard]] gl_attr_force_inline std::underlying_type_t<value> to_underlying() const {
-        return util::to_underlying(this->_value);
+        return std::to_underlying(this->_value);
     }
 
     [[nodiscard]] gl_attr_force_inline binary_color next() const {