wip: lightweight vertex descriptor

Author: SpectraL519

include/gl/graph.hpp

@@ -23,12 +23,15 @@ class graph final {
     using implementation_type = typename implementation_tag::template type<traits_type>;
 
     using vertex_type = typename traits_type::vertex_type;
-    using vertex_ptr_type = typename traits_type::vertex_ptr_type;
-    using vertex_properties_type = typename traits_type::vertex_properties_type;
+    // using vetex_list_type = std::vector<vertex_type>;
+    // using vertex_iterator_type =
+    //     types::dereferencing_iterator<typename vetex_list_type::const_iterator>;
 
-    using vetex_list_type = std::vector<vertex_ptr_type>;
-    using vertex_iterator_type =
-        types::dereferencing_iterator<typename vetex_list_type::const_iterator>;
+    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>,
+        types::empty_properties_map,
+        std::vector<std::unique_ptr<vertex_properties_type>>>;
 
     // TODO: reverese iterators should be available for bidirectional ranges
 
@@ -45,10 +48,24 @@ class graph final {
 
     graph() = default;
 
-    graph(const types::size_type n_vertices) : _impl(n_vertices) {
+    graph(const types::size_type n_vertices)
+    requires(type_traits::is_default_properties_type_v<vertex_properties_type>)
+    : _vertex_properties(), _impl(n_vertices) {
         this->_vertices.reserve(n_vertices);
-        for (auto vertex_id = constants::initial_id; vertex_id < n_vertices; ++vertex_id)
-            this->_vertices.push_back(detail::make_vertex<vertex_type>(vertex_id));
+        for (auto id : std::views::iota(constants::initial_id, n_vertices))
+            this->_vertices.emplace_back(vertex_id, this->_vertex_properties);
+    }
+
+    graph(const types::size_type n_vertices)
+    requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
+    : _impl(n_vertices) {
+        this->_vertices.reserve(n_vertices);
+        this->_vertex_properties.reserve(n_vertices);
+        for (auto [id, properties] : std::views::enumerate(this->_vertex_properties))
+            this->_vertices.emplace_back(
+                vertex_id,
+                *this->_vertex_properties.emplace_back(std::make_unique<vertex_properties_type>())
+            );
     }
 
     graph(graph&&) = default;
@@ -59,7 +76,7 @@ class graph final {
     // --- general methods ---
 
     [[nodiscard]] gl_attr_force_inline types::size_type n_vertices() const {
-        return this->_vertices.size();
+        return this->_n_vertices;
     }
 
     [[nodiscard]] gl_attr_force_inline types::size_type n_unique_edges() const {
@@ -68,14 +85,29 @@ class graph final {
 
     // --- vertex methods ---
 
-    [[nodiscard]] gl_attr_force_inline types::iterator_range<vertex_iterator_type> vertices(
-    ) const {
-        return make_iterator_range(deref_cbegin(this->_vertices), deref_cend(this->_vertices));
+    // TODO: return a view
+    // [[nodiscard]] gl_attr_force_inline types::iterator_range<vertex_iterator_type> vertices(
+    // ) const {
+    //     return make_iterator_range(deref_cbegin(this->_vertices), deref_cend(this->_vertices));
+    // }
+
+    [[nodiscard]] gl_attr_force_inline auto vertices() const
+    requires(type_traits::is_default_properties_type_v<vertex_properties_type>)
+    {
+        return std::views::enumerate(this->_vertex_properties) | std::views::transform([](auto [id, properties]) {
+            return vertex_descriptor{id, *properties}; }));
+    }
+
+    [[nodiscard]] gl_attr_force_inline auto vertices() const
+    requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
+    {
+        return this->vertex_ids()
+             | std::views::transform([](const types::id_type id) { return vertex_descriptor{id}; });
     }
 
     [[nodiscard]] gl_attr_force_inline std::ranges::iota_view<types::id_type, types::id_type>
     vertex_ids() const {
-        return std::views::iota(constants::initial_id, this->n_vertices());
+        return std::views::iota(constants::initial_id, this->_n_vertices);
     }
 
     // clang-format off
@@ -85,36 +117,40 @@ class graph final {
         const types::id_type vertex_id
     ) const {
         this->_verify_vertex_id(vertex_id);
-        return *this->_vertices[vertex_id];
+        if constexpr (type_traits::is_default_properties_type_v<vertex_properties_type>)
+            return vertex_descriptor{vertex_id};
+        else
+            return vertex_descriptor{vertex_id, *this->_vertex_properties[vertex_id]};
     }
 
     // clang-format on
 
     [[nodiscard]] gl_attr_force_inline bool has_vertex(const types::id_type vertex_id) const {
-        return vertex_id < this->n_vertices();
+        return vertex_id < this->_n_vertices;
     }
 
-    [[nodiscard]] gl_attr_force_inline bool has_vertex(const vertex_type& vertex) const {
-        return this->has_vertex(vertex.id()) and &vertex == this->_vertices[vertex.id()].get();
-    }
-
-    const vertex_type& add_vertex() {
+    vertex_type add_vertex() {
         this->_impl.add_vertex();
-        this->_vertices.push_back(detail::make_vertex<vertex_type>(this->n_vertices()));
-        return *this->_vertices.back();
+        return this->_vertices.emplace_back(
+            this->n_vertices(), this->_vertex_properties.emplace_back()
+        );
     }
 
     const vertex_type& add_vertex(const vertex_properties_type& properties)
     requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
     {
         this->_impl.add_vertex();
-        this->_vertices.push_back(detail::make_vertex<vertex_type>(this->n_vertices(), properties));
-        return *this->_vertices.back();
+        return vertex_descriptor{
+            this->_n_vertices++,
+            *this->_vertex_properties.emplace_back(
+                std::make_unique<vertex_properties_type>(properties)
+            )
+        };
     }
 
     void add_vertices(const types::size_type n) {
         this->_impl.add_vertices(n);
-        this->_vertices.reserve(this->n_vertices() + n);
+        this->_vertices.reserve(this->_n_vertices + n);
 
         for (types::size_type _ = constants::begin_idx; _ < n; ++_)
             this->_vertices.push_back(detail::make_vertex<vertex_type>(this->n_vertices()));
@@ -644,7 +680,10 @@ class graph final {
         }
     }
 
-    vetex_list_type _vertices{};
+    types::size_type _n_vertices = 0uz;
+    [[no_unique_address]] vertex_properties_map_type _vertex_properties;
+    // TODO: edge properties map
+
     implementation_type _impl{};
 };
 

include/gl/types/iterator_range.hpp

@@ -46,9 +46,7 @@ class iterator_range
 {
 public:
     using iterator = Iterator;
-#if __cplusplus >= 202302L
     using const_iterator = std::const_iterator<Iterator>;
-#endif
     using distance_type = std::ptrdiff_t;
     using value_type = std::remove_reference_t<typename iterator::value_type>;
 

include/gl/types/properties.hpp

@@ -25,6 +25,7 @@ namespace types {
 // --- common properties ---
 
 using empty_properties = std::monostate;
+using empty_properties_map = std::monostate;
 
 class name_property
 #ifndef _GL_PROPERTY_TYPES_NOT_FINAL

include/gl/vertex_descriptor.hpp

@@ -20,6 +20,10 @@ class vertex_descriptor final {
 public:
     using type = std::type_identity_t<vertex_descriptor<Properties>>;
     using properties_type = Properties;
+    using properties_ref_type = std::conditional_t<
+        type_traits::is_default_properties_type_v<properties_type>,
+        types::empty_properties,
+        properties_type&>;
 
     template <type_traits::c_instantiation_of<graph_traits> GraphTraits>
     friend class graph;
@@ -28,11 +32,15 @@ class vertex_descriptor final {
     vertex_descriptor(const vertex_descriptor&) = delete;
     vertex_descriptor& operator=(const vertex_descriptor&) = delete;
 
-    explicit vertex_descriptor(const types::id_type id) : _id(id) {}
+    // TODO: private
+    explicit vertex_descriptor(const types::id_type id)
+    requires(type_traits::is_default_properties_type_v<properties_type>)
+    : _id(id), _properties() {}
 
-    explicit vertex_descriptor(const types::id_type id, const properties_type& properties)
+    // TODO: private
+    explicit vertex_descriptor(const types::id_type id, properties_type& properties)
     requires(not type_traits::is_default_properties_type_v<properties_type>)
-    : _id(id), properties(properties) {}
+    : _id(id), _properties(properties) {}
 
     vertex_descriptor(vertex_descriptor&&) = default;
     vertex_descriptor& operator=(vertex_descriptor&&) = default;
@@ -51,7 +59,9 @@ class vertex_descriptor final {
         return this->_id;
     }
 
-    [[no_unique_address]] mutable properties_type properties{};
+    [[no_unique_address]] gl_attr_force_inline properties_ref_type properties() mutable {
+        return this->_properties;
+    }
 
     friend inline std::ostream& operator<<(std::ostream& os, const vertex_descriptor& vertex) {
         vertex._write(os);
@@ -89,6 +99,7 @@ class vertex_descriptor final {
     }
 
     types::id_type _id;
+    [[no_unique_address]] properties_ref_type _properties;
 };
 
 template <type_traits::c_properties Properties = types::empty_properties>

task.md

@@ -0,0 +1,22 @@
+# CPP-GL Graph Element Representation and Storage Refactor
+
+## Task
+
+- [YouTrack Task](https://spectral519.youtrack.cloud/issue/CPPGL-56/Replace-the-usage-of-pointers-for-vertex-and-edge-storage-to-simple-composite-types)
+- Description:
+  ```
+  - The `graph` class should conditionally contain vertex and edge property maps. Each entry in these maps should be bound to the element with the given id.
+  - The `vertex_descriptor` and `edge_descriptor` classes should contain a reference to the proper property map entry instead of containing the properties directly and define a mutable `properties()` getter method
+  - The `graph` class should initialize new vertex/edge elements without the use of pointers and delegate the proper element handling/conversion to the implementation types
+  - The vertex/edge getter methods of the `graph` class should return the elements by value
+  - The `adjacency_list` model should store the edges without the use of pointers
+  - Align the algorithms to match the new structure of the graph elements and their storage
+  ```
+
+## Ideas
+
+1. Lightweight descriptor object
+- Instead of storing the vertex set, store only the number of vertices and a properties map
+- Create the descriptor object only when necessary
+- After removing a vertex align the ids of descriptors stored by graph edges:
+  - Requires a warning/caution doc stating that removing a vertex invalidates the ids of returned descriptors