graph file io aligned

Author: SpectraL519

include/gl/edge_descriptor.hpp

@@ -19,7 +19,7 @@ class edge_descriptor final {
     using directional_tag = DirectionalTag;
     using properties_type = Properties;
     using properties_ref_type = std::conditional_t<
-        type_traits::is_default_properties_type_v<properties_type>,
+        type_traits::c_empty_properties<properties_type>,
         types::empty_properties,
         properties_type&>;
 
@@ -32,7 +32,7 @@ class edge_descriptor final {
     explicit edge_descriptor(
         const types::id_type id, const types::id_type first, const types::id_type second
     )
-    requires(type_traits::is_default_properties_type_v<properties_type>)
+    requires(type_traits::c_empty_properties<properties_type>)
     : _id(id), _vertices(first, second) {}
 
     explicit edge_descriptor(
@@ -41,17 +41,17 @@ class edge_descriptor final {
         const types::id_type second,
         properties_type& properties
     )
-    requires(not type_traits::is_default_properties_type_v<properties_type>)
+    requires(type_traits::c_non_empty_properties<properties_type>)
     : _id(id), _vertices(first, second), _properties(properties) {}
 
     [[nodiscard]] static gl_attr_force_inline edge_descriptor invalid() noexcept
-    requires(type_traits::is_default_properties_type_v<properties_type>)
+    requires(type_traits::c_empty_properties<properties_type>)
     {
         return edge_descriptor(constants::invalid_id, constants::invalid_id, constants::invalid_id);
     }
 
     [[nodiscard]] static gl_attr_force_inline edge_descriptor invalid() noexcept
-    requires(not type_traits::is_default_properties_type_v<properties_type>)
+    requires(type_traits::c_non_empty_properties<properties_type>)
     {
         static properties_type invalid_properties{};
         return edge_descriptor(

include/gl/graph.hpp

@@ -35,7 +35,7 @@ class graph final {
     using vertex_type = typename traits_type::vertex_type;
     using vertex_properties_type = typename traits_type::vertex_properties_type;
     using vertex_properties_map_type = std::conditional_t<
-        type_traits::is_default_properties_type_v<vertex_properties_type>,
+        type_traits::c_empty_properties<vertex_properties_type>,
         types::empty_properties_map,
         std::vector<std::unique_ptr<vertex_properties_type>>>;
 
@@ -44,7 +44,7 @@ class graph final {
     using edge_properties_type = typename traits_type::edge_properties_type;
 
     using edge_properties_map_type = std::conditional_t<
-        type_traits::is_default_properties_type_v<edge_properties_type>,
+        type_traits::c_empty_properties<edge_properties_type>,
         types::empty_properties_map,
         std::vector<std::unique_ptr<edge_properties_type>>>;
 
@@ -54,7 +54,7 @@ class graph final {
     graph() = default;
 
     explicit graph(const types::size_type n_vertices) : _n_vertices(n_vertices), _impl(n_vertices) {
-        if constexpr (not type_traits::is_default_properties_type_v<vertex_properties_type>) {
+        if constexpr (type_traits::c_non_empty_properties<vertex_properties_type>) {
             this->_vertex_properties.reserve(n_vertices);
             for (const auto _ : this->vertex_ids())
                 this->_vertex_properties.push_back(std::make_unique<vertex_properties_type>());
@@ -79,14 +79,14 @@ class graph final {
     // --- vertex methods ---
 
     [[nodiscard]] gl_attr_force_inline auto vertices() const
-    requires(type_traits::is_default_properties_type_v<vertex_properties_type>)
+    requires(type_traits::c_empty_properties<vertex_properties_type>)
     {
         return this->vertex_ids()
              | std::views::transform([](const types::id_type id) { return vertex_descriptor{id}; });
     }
 
     [[nodiscard]] gl_attr_force_inline auto vertices() const
-    requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
+    requires(type_traits::c_non_empty_properties<vertex_properties_type>)
     {
         return this->_vertex_properties | std::views::enumerate
              | std::views::transform([](const auto& x) {
@@ -105,7 +105,7 @@ class graph final {
 
     [[nodiscard]] gl_attr_force_inline vertex_type get_vertex(const types::id_type vertex_id) const {
         this->_verify_vertex_id(vertex_id);
-        if constexpr (type_traits::is_default_properties_type_v<vertex_properties_type>)
+        if constexpr (type_traits::c_empty_properties<vertex_properties_type>)
             return vertex_descriptor{vertex_id};
         else
             return vertex_descriptor{vertex_id, *this->_vertex_properties[vertex_id]};
@@ -125,7 +125,7 @@ class graph final {
         this->_impl.add_vertex();
         const auto new_vertex_id = this->_n_vertices++;
 
-        if constexpr (type_traits::is_default_properties_type_v<vertex_properties_type>)
+        if constexpr (type_traits::c_empty_properties<vertex_properties_type>)
             return vertex_descriptor{new_vertex_id};
         else {
             this->_vertex_properties.push_back(std::make_unique<vertex_properties_type>());
@@ -134,7 +134,7 @@ class graph final {
     }
 
     vertex_type add_vertex(vertex_properties_type properties)
-    requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
+    requires(type_traits::c_non_empty_properties<vertex_properties_type>)
     {
         this->_impl.add_vertex();
         this->_vertex_properties.push_back(
@@ -147,7 +147,7 @@ class graph final {
         this->_impl.add_vertices(n);
         this->_n_vertices += n;
 
-        if constexpr (not type_traits::is_default_properties_type_v<vertex_properties_type>) {
+        if constexpr (type_traits::c_non_empty_properties<vertex_properties_type>) {
             const auto old_size = this->_vertex_properties.size();
             this->_vertex_properties.reserve(this->_n_vertices);
             for (types::size_type i = old_size; i < this->_n_vertices; ++i)
@@ -158,14 +158,14 @@ class graph final {
     void add_vertices_with(
         const type_traits::c_sized_range_of<vertex_properties_type> auto& properties_range
     )
-    requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
+    requires(type_traits::c_non_empty_properties<vertex_properties_type>)
     {
         const auto n = std::ranges::size(properties_range);
 
         this->_impl.add_vertices(n);
         this->_n_vertices += n;
 
-        if constexpr (not type_traits::is_default_properties_type_v<vertex_properties_type>) {
+        if constexpr (type_traits::c_non_empty_properties<vertex_properties_type>) {
             for (auto& properties : properties_range) {
                 this->_vertex_properties.emplace_back(
                     std::make_unique<vertex_properties_type>(properties)
@@ -250,7 +250,7 @@ class graph final {
     }
 
     [[nodiscard]] gl_attr_force_inline auto vertex_properties_map() const noexcept
-    requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
+    requires(type_traits::c_non_empty_properties<vertex_properties_type>)
     {
         return util::deref_view(this->_vertex_properties);
     }
@@ -269,7 +269,7 @@ class graph final {
         const auto new_edge_id = this->_n_unique_edges++;
         this->_impl.add_edge(new_edge_id, first_id, second_id);
 
-        if constexpr (type_traits::is_default_properties_type_v<edge_properties_type>) {
+        if constexpr (type_traits::c_empty_properties<edge_properties_type>) {
             return edge_type{new_edge_id, first_id, second_id};
         }
         else {
@@ -283,7 +283,7 @@ class graph final {
         const types::id_type second_id,
         const edge_properties_type& properties
     )
-    requires(not type_traits::is_default_properties_type_v<edge_properties_type>)
+    requires(type_traits::c_non_empty_properties<edge_properties_type>)
     {
         this->_verify_vertex_id(first_id);
         this->_verify_vertex_id(second_id);
@@ -305,7 +305,7 @@ class graph final {
     const gl_attr_force_inline edge_type add_edge(
         const vertex_type& first, const vertex_type& second, const edge_properties_type& properties
     )
-    requires(not type_traits::is_default_properties_type_v<edge_properties_type>)
+    requires(type_traits::c_non_empty_properties<edge_properties_type>)
     {
         return this->add_edge(first.id(), second.id(), properties);
     }
@@ -319,7 +319,7 @@ class graph final {
 
         for (const auto target_id : target_id_range) {
             this->_verify_vertex_id(target_id);
-            if constexpr (not type_traits::is_default_properties_type_v<edge_properties_type>)
+            if constexpr (type_traits::c_non_empty_properties<edge_properties_type>)
                 this->_edge_properties.emplace_back(std::make_unique<edge_properties_type>());
         }
 
@@ -339,7 +339,7 @@ class graph final {
 
         for (const auto& target : target_range) {
             this->_verify_vertex_id(target.id());
-            if constexpr (not type_traits::is_default_properties_type_v<edge_properties_type>)
+            if constexpr (type_traits::c_non_empty_properties<edge_properties_type>)
                 this->_edge_properties.emplace_back(std::make_unique<edge_properties_type>());
         }
 
@@ -376,7 +376,7 @@ class graph final {
         this->_verify_vertex_id(first_id);
         this->_verify_vertex_id(second_id);
 
-        if constexpr (type_traits::is_default_properties_type_v<edge_properties_type>)
+        if constexpr (type_traits::c_empty_properties<edge_properties_type>)
             return this->_impl.get_edge(first_id, second_id);
         else
             return this->_impl.get_edge(first_id, second_id, this->_edge_properties);
@@ -394,7 +394,7 @@ class graph final {
         this->_verify_vertex_id(first_id);
         this->_verify_vertex_id(second_id);
 
-        if constexpr (type_traits::is_default_properties_type_v<edge_properties_type>)
+        if constexpr (type_traits::c_empty_properties<edge_properties_type>)
             return this->_impl.get_edges(first_id, second_id);
         else
             return this->_impl.get_edges(first_id, second_id, this->_edge_properties);
@@ -408,7 +408,7 @@ class graph final {
 
     gl_attr_force_inline void remove_edge(const edge_type& edge) {
         this->_verify_edge(edge);
-        if constexpr (not type_traits::is_default_properties_type_v<edge_properties_type>)
+        if constexpr (type_traits::c_non_empty_properties<edge_properties_type>)
             this->_edge_properties.erase(this->_edge_properties.begin() + edge.id());
         this->_impl.remove_edge(edge);
         this->_n_unique_edges--;
@@ -418,7 +418,7 @@ class graph final {
         const auto removed_edge_ids = this->_impl.remove_edges(edges);
         this->_n_unique_edges -= removed_edge_ids.size();
 
-        if constexpr (not type_traits::is_default_properties_type_v<edge_properties_type>) {
+        if constexpr (type_traits::c_non_empty_properties<edge_properties_type>) {
             // IDs are sorted and do not contain duplicates
             for (const auto edge_id : std::views::reverse(removed_edge_ids))
                 this->_edge_properties.erase(this->_edge_properties.begin() + edge_id);
@@ -427,7 +427,7 @@ class graph final {
 
     [[nodiscard]] inline auto adjacent_edges(const types::id_type vertex_id) const {
         this->_verify_vertex_id(vertex_id);
-        if constexpr (type_traits::is_default_properties_type_v<edge_properties_type>)
+        if constexpr (type_traits::c_empty_properties<edge_properties_type>)
             return this->_impl.adjacent_edges(vertex_id);
         else
             return this->_impl.adjacent_edges(vertex_id, this->_edge_properties);
@@ -525,10 +525,10 @@ class graph final {
         this->_n_vertices--;
         this->_n_unique_edges -= removed_edge_ids.size();
 
-        if constexpr (not type_traits::is_default_properties_type_v<vertex_properties_type>)
+        if constexpr (type_traits::c_non_empty_properties<vertex_properties_type>)
             this->_vertex_properties.erase(this->_vertex_properties.begin() + vertex_id);
 
-        if constexpr (not type_traits::is_default_properties_type_v<edge_properties_type>) {
+        if constexpr (type_traits::c_non_empty_properties<edge_properties_type>) {
             // IDs are sorted and do not contain duplicates
             for (const auto& edge_id : std::views::reverse(removed_edge_ids))
                 this->_edge_properties.erase(this->_edge_properties.begin() + edge_id);
@@ -547,7 +547,7 @@ class graph final {
 
         for (const auto& vertex : this->vertices()) {
             os << "- " << vertex << "\n  adjacent edges:\n";
-            for (const auto& edge : this->_impl.adjacent_edges(vertex.id()))
+            for (const auto& edge : this->adjacent_edges(vertex.id()))
                 os << "\t- " << edge << '\n';
         }
     }
@@ -559,7 +559,7 @@ class graph final {
 
         for (const auto& vertex : this->vertices()) {
             os << "- " << vertex << " :";
-            for (const auto& edge : this->_impl.adjacent_edges(vertex.id()))
+            for (const auto& edge : this->adjacent_edges(vertex.id()))
                 os << ' ' << edge;
             os << '\n';
         }
@@ -584,15 +584,15 @@ class graph final {
         if constexpr (type_traits::c_writable<typename vertex_type::properties_type>)
             if (with_vertex_properties)
                 for (const auto& vertex : this->vertices())
-                    os << vertex._properties << '\n';
+                    os << vertex.properties() << '\n';
 
         if constexpr (type_traits::c_writable<typename edge_type::properties_type>) {
             if (with_edge_properties) {
                 const auto print_incident_edges = [this, &os](const types::id_type vertex_id) {
-                    for (const auto& edge : this->_impl.adjacent_edges(vertex_id)) {
+                    for (const auto& edge : this->adjacent_edges(vertex_id)) {
                         if (edge.first() != vertex_id)
                             continue; // vertex is not the source
-                        os << edge.first() << ' ' << edge.second() << ' ' << edge._properties
+                        os << edge.first() << ' ' << edge.second() << ' ' << edge.properties()
                            << '\n';
                     }
                 };
@@ -605,7 +605,7 @@ class graph final {
         }
 
         const auto print_incident_edges = [this, &os](const types::id_type vertex_id) {
-            for (const auto& edge : this->_impl.adjacent_edges(vertex_id)) {
+            for (const auto& edge : this->adjacent_edges(vertex_id)) {
                 if (edge.first() != vertex_id)
                     continue; // vertex is not the source
                 os << edge.first() << ' ' << edge.second() << '\n';

include/gl/impl/adjacency_list.hpp

@@ -113,7 +113,9 @@ class adjacency_list final {
 
     [[nodiscard]] std::optional<edge_type> get_edge(
         const types::id_type source_id, const types::id_type target_id
-    ) const {
+    ) const
+    requires(type_traits::c_has_empty_properties<edge_type>)
+    {
         const auto& adjacent_edges = this->_list[source_id];
         const auto item_it = std::ranges::find(adjacent_edges, target_id, [](const auto& item) {
             return item.target_id;
@@ -127,21 +129,25 @@ class adjacency_list final {
         const types::id_type source_id,
         const types::id_type target_id,
         const auto& edge_properties_map
-    ) const {
+    ) const
+    requires(type_traits::c_has_non_empty_properties<edge_type>)
+    {
         const auto& adjacent_edges = this->_list[source_id];
         const auto item_it = std::ranges::find(adjacent_edges, target_id, [](const auto& item) {
             return item.target_id;
         });
         if (item_it == adjacent_edges.cend())
             return std::nullopt;
         return std::make_optional<edge_type>(
-            item_it->id, source_id, target_id, edge_properties_map[item_it->id]
+            item_it->id, source_id, target_id, *edge_properties_map[item_it->id]
         );
     }
 
     [[nodiscard]] std::vector<edge_type> get_edges(
         const types::id_type source_id, const types::id_type target_id
-    ) const {
+    ) const
+    requires(type_traits::c_has_empty_properties<edge_type>)
+    {
         return this->_list[source_id] | std::views::filter([&target_id](const auto& item) {
                    return item.target_id == target_id;
                })
@@ -155,7 +161,9 @@ class adjacency_list final {
         const types::id_type source_id,
         const types::id_type target_id,
         const auto& edge_properties_map
-    ) const {
+    ) const
+    requires(type_traits::c_has_non_empty_properties<edge_type>)
+    {
         return this->_list[source_id] | std::views::filter([&target_id](const auto& item) {
                    return item.target_id == target_id;
                })
@@ -184,15 +192,19 @@ class adjacency_list final {
         return removed_edge_ids;
     }
 
-    [[nodiscard]] gl_attr_force_inline auto adjacent_edges(const types::id_type vertex_id) const {
+    [[nodiscard]] gl_attr_force_inline auto adjacent_edges(const types::id_type vertex_id) const
+    requires(type_traits::c_has_empty_properties<edge_type>)
+    {
         return this->_list[vertex_id] | std::views::transform([vertex_id](const auto& item) {
                    return edge_type{item.id, vertex_id, item.target_id};
                });
     }
 
     [[nodiscard]] gl_attr_force_inline auto adjacent_edges(
         const types::id_type vertex_id, const auto& edge_properties_map
-    ) const {
+    ) const
+    requires(type_traits::c_has_non_empty_properties<edge_type>)
+    {
         return this->_list[vertex_id]
              | std::views::transform([vertex_id, &edge_properties_map](const auto& item) {
                    return edge_type{
@@ -203,13 +215,17 @@ class adjacency_list final {
 
     // --- access operators ---
 
-    [[nodiscard]] gl_attr_force_inline auto at(const types::id_type vertex_id) const {
+    [[nodiscard]] gl_attr_force_inline auto at(const types::id_type vertex_id) const
+    requires(type_traits::c_has_empty_properties<edge_type>)
+    {
         return this->adjacent_edges(vertex_id);
     }
 
     [[nodiscard]] gl_attr_force_inline auto at(
         const types::id_type vertex_id, const auto& edge_properties_map
-    ) const {
+    ) const
+    requires(type_traits::c_has_non_empty_properties<edge_type>)
+    {
         return this->adjacent_edges(vertex_id, edge_properties_map);
     }