edge properties storage refactor

SpectraL519 · SpectraL519 · commit fd89aa445fd2 · 2026-04-19T21:29:52.000+02:00
diff --git a/include/gl/graph.hpp b/include/gl/graph.hpp
@@ -93,7 +93,7 @@ class graph final {
     using edge_properties_map_type = std::conditional_t<
         traits::c_empty_properties<edge_properties_type>,
         empty_properties_map,
-        std::vector<std::unique_ptr<edge_properties_type>>>;
+        std::vector<edge_properties_type>>;
 
     graph& operator=(const graph&) = delete;
 
@@ -355,18 +355,16 @@ class graph final {
         const auto new_edge_id = static_cast<id_type>(this->_n_edges++);
         this->_impl.add_edge(new_edge_id, source_id, target_id);
 
-        if constexpr (traits::c_non_empty_properties<edge_properties_type>) {
-            const auto& p =
-                this->_edge_properties.emplace_back(std::make_unique<edge_properties_type>());
-            return edge_type{new_edge_id, source_id, target_id, *p};
-        }
-        else {
+        if constexpr (traits::c_non_empty_properties<edge_properties_type>)
+            return edge_type{
+                new_edge_id, source_id, target_id, this->_edge_properties.emplace_back()
+            };
+        else
             return edge_type{new_edge_id, source_id, target_id};
-        }
     }
 
     edge_type add_edge_with(
-        const id_type source_id, const id_type target_id, const edge_properties_type& properties
+        const id_type source_id, const id_type target_id, edge_properties_type properties
     )
     requires(traits::c_non_empty_properties<edge_properties_type>)
     {
@@ -376,9 +374,12 @@ class graph final {
         const auto new_edge_id = static_cast<id_type>(this->_n_edges++);
         this->_impl.add_edge(new_edge_id, source_id, target_id);
 
-        auto& p =
-            this->_edge_properties.emplace_back(std::make_unique<edge_properties_type>(properties));
-        return edge_type{new_edge_id, source_id, target_id, *p};
+        return edge_type{
+            new_edge_id,
+            source_id,
+            target_id,
+            this->_edge_properties.emplace_back(std::move(properties))
+        };
     }
 
     // clang-format off
@@ -402,12 +403,8 @@ class graph final {
         const id_type source_id, const traits::c_sized_range_of<id_type> auto& target_id_rng
     ) {
         this->_verify_vertex_id(source_id);
-
-        for (auto target_id : target_id_rng) {
+        for (auto target_id : target_id_rng)
             this->_verify_vertex_id(target_id);
-            if constexpr (traits::c_non_empty_properties<edge_properties_type>)
-                this->_edge_properties.emplace_back(std::make_unique<edge_properties_type>());
-        }
 
         const auto prev_n_edges = this->_n_edges;
         this->_n_edges += std::ranges::size(target_id_rng);
@@ -416,18 +413,17 @@ class graph final {
             source_id,
             target_id_rng
         );
+
+        if constexpr (traits::c_non_empty_properties<edge_properties_type>)
+            this->_edge_properties.resize(this->_n_edges);
     }
 
     void add_edges_from(
         vertex_type source, const traits::c_sized_range_of<vertex_type> auto& target_rng
     ) {
         this->_verify_vertex_id(source.id());
-
-        for (auto target : target_rng) {
+        for (auto target : target_rng)
             this->_verify_vertex_id(target.id());
-            if constexpr (traits::c_non_empty_properties<edge_properties_type>)
-                this->_edge_properties.emplace_back(std::make_unique<edge_properties_type>());
-        }
 
         const auto prev_n_edges = this->_n_edges;
         this->_n_edges += std::ranges::size(target_rng);
@@ -436,6 +432,10 @@ class graph final {
             source.id(),
             target_rng | std::views::transform(&vertex_type::id)
         );
+
+
+        if constexpr (traits::c_non_empty_properties<edge_properties_type>)
+            this->_edge_properties.resize(this->_n_edges);
     }
 
     void remove_edge(const edge_type& edge) {
@@ -554,13 +554,13 @@ class graph final {
         if (id >= this->_n_edges)
             throw std::out_of_range(std::format("Got invalid edge id [{}]", id));
 
-        return *this->_edge_properties[id];
+        return this->_edge_properties[id];
     }
 
     [[nodiscard]] gl_attr_force_inline auto edge_properties_map() const noexcept
     requires(traits::c_non_empty_properties<edge_properties_type>)
     {
-        return util::deref_view(this->_edge_properties);
+        return std::views::all(this->_edge_properties);
     }
 
     // --- adjacency and incidence methods ---
@@ -602,10 +602,6 @@ class graph final {
     // --- comparison ---
 
     [[nodiscard]] friend bool operator==(const graph& lhs, const graph& rhs) noexcept {
-        constexpr auto val_eq = [](const auto& ptr_a, const auto& ptr_b) {
-            return *ptr_a == *ptr_b;
-        };
-
         if (lhs._n_vertices != rhs._n_vertices or lhs._n_edges != rhs._n_edges)
             return false;
 
@@ -614,7 +610,7 @@ class graph final {
                 return false;
 
         if constexpr (traits::c_non_empty_properties<edge_properties_type>)
-            if (not std::ranges::equal(lhs._edge_properties, rhs._edge_properties, val_eq))
+            if (lhs._edge_properties != rhs._edge_properties)
                 return false;
 
         return lhs._impl == rhs._impl;
@@ -656,14 +652,8 @@ class graph final {
     : _n_vertices{other._n_vertices},
       _n_edges{other._n_edges},
       _impl{other._impl},
-      _vertex_properties{other._vertex_properties} {
-        // Deep copy edge properties
-        if constexpr (traits::c_non_empty_properties<edge_properties_type>) {
-            this->_edge_properties.reserve(other._edge_properties.size());
-            for (const auto& property : other._edge_properties)
-                this->_edge_properties.push_back(std::make_unique<edge_properties_type>(*property));
-        }
-    }
+      _vertex_properties{other._vertex_properties},
+      _edge_properties{other._edge_properties} {}
 
     // --- element validation ---
 
@@ -892,7 +882,9 @@ class graph final {
 
     /// @todo Replace mutability with proper const-correct getter overloads to ensure thread safety guarantees associated with the const qualifier
     [[no_unique_address]] mutable vertex_properties_map_type _vertex_properties{};
-    [[no_unique_address]] edge_properties_map_type _edge_properties{};
+
+    /// @todo Replace mutability with proper const-correct getter overloads to ensure thread safety guarantees associated with the const qualifier
+    [[no_unique_address]] mutable edge_properties_map_type _edge_properties{};
 };
 
 // --- general graph utility ---
diff --git a/include/gl/impl/adjacency_list.hpp b/include/gl/impl/adjacency_list.hpp
@@ -163,7 +163,7 @@ class adjacency_list final {
     }
 
     [[nodiscard]] std::optional<edge_type> edge(
-        id_type source_id, id_type target_id, const auto& edge_properties_map
+        id_type source_id, id_type target_id, auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
@@ -173,7 +173,7 @@ class adjacency_list final {
         if (item_it == out_edges.cend())
             return std::nullopt;
         return std::make_optional<edge_type>(
-            item_it->edge_id, source_id, target_id, *edge_properties_map[to_idx(item_it->edge_id)]
+            item_it->edge_id, source_id, target_id, edge_properties_map[to_idx(item_it->edge_id)]
         );
     }
 
@@ -189,15 +189,15 @@ class adjacency_list final {
     }
 
     [[nodiscard]] std::vector<edge_type> edges(
-        id_type source_id, id_type target_id, const auto& edge_properties_map
+        id_type source_id, id_type target_id, auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
         return this->_list[source_id]
              | std::views::filter([&target_id](auto item) { return item.vertex_id == target_id; })
              | std::views::transform([source_id, &edge_properties_map](auto item) {
                    return edge_type{
-                       item.edge_id, source_id, item.vertex_id, *edge_properties_map[item.edge_id]
+                       item.edge_id, source_id, item.vertex_id, edge_properties_map[item.edge_id]
                    };
                })
              | std::ranges::to<std::vector>();
@@ -210,7 +210,7 @@ class adjacency_list final {
     }
 
     [[nodiscard]] gl_attr_force_inline auto incident_edges(
-        id_type vertex_id, const auto& edge_properties_map
+        id_type vertex_id, auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
@@ -226,9 +226,8 @@ class adjacency_list final {
                });
     }
 
-    [[nodiscard]] gl_attr_force_inline auto in_edges(
-        id_type vertex_id, const auto& edge_properties_map
-    ) const
+    [[nodiscard]] gl_attr_force_inline auto in_edges(id_type vertex_id, auto& edge_properties_map)
+        const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
         return specialized_impl::in_edges(*this, vertex_id)
@@ -237,7 +236,7 @@ class adjacency_list final {
                        item.edge_id,
                        item.vertex_id,
                        vertex_id,
-                       *edge_properties_map[to_idx(item.edge_id)]
+                       edge_properties_map[to_idx(item.edge_id)]
                    };
                });
     }
@@ -250,9 +249,8 @@ class adjacency_list final {
                });
     }
 
-    [[nodiscard]] gl_attr_force_inline auto out_edges(
-        id_type vertex_id, const auto& edge_properties_map
-    ) const
+    [[nodiscard]] gl_attr_force_inline auto out_edges(id_type vertex_id, auto& edge_properties_map)
+        const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
         return this->_list[to_idx(vertex_id)]
@@ -261,7 +259,7 @@ class adjacency_list final {
                        item.edge_id,
                        vertex_id,
                        item.vertex_id,
-                       *edge_properties_map[to_idx(item.edge_id)]
+                       edge_properties_map[to_idx(item.edge_id)]
                    };
                });
     }
diff --git a/include/gl/impl/adjacency_matrix.hpp b/include/gl/impl/adjacency_matrix.hpp
@@ -161,15 +161,15 @@ class adjacency_matrix final {
     }
 
     [[nodiscard]] std::optional<edge_type> edge(
-        id_type source_id, id_type target_id, const auto& edge_properties_map
+        id_type source_id, id_type target_id, auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
         const auto edge_id = specialized_impl::get_entry(*this, source_id, target_id);
         if (edge_id == invalid_id)
             return std::nullopt;
         return std::make_optional<edge_type>(
-            edge_id, source_id, target_id, *edge_properties_map[to_idx(edge_id)]
+            edge_id, source_id, target_id, edge_properties_map[to_idx(edge_id)]
         );
     }
 
@@ -185,15 +185,15 @@ class adjacency_matrix final {
     }
 
     [[nodiscard]] std::vector<edge_type> edges(
-        id_type source_id, id_type target_id, const auto& edge_properties_map
+        id_type source_id, id_type target_id, auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
         const auto edge_id = specialized_impl::get_entry(*this, source_id, target_id);
         if (edge_id == invalid_id)
             return std::vector<edge_type>();
         return std::vector<edge_type>{
-            edge_type{edge_id, source_id, target_id, *edge_properties_map[to_idx(edge_id)]}
+            edge_type{edge_id, source_id, target_id, edge_properties_map[to_idx(edge_id)]}
         };
     }
 
@@ -204,7 +204,7 @@ class adjacency_matrix final {
     }
 
     [[nodiscard]] gl_attr_force_inline auto incident_edges(
-        id_type vertex_id, const auto& edge_properties_map
+        id_type vertex_id, auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
@@ -227,9 +227,8 @@ class adjacency_matrix final {
                });
     }
 
-    [[nodiscard]] gl_attr_force_inline auto in_edges(
-        id_type vertex_id, const auto& edge_properties_map
-    ) const
+    [[nodiscard]] gl_attr_force_inline auto in_edges(id_type vertex_id, auto& edge_properties_map)
+        const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
         return std::views::iota(initial_id_v<id_type>, this->_matrix.size())
@@ -239,7 +238,7 @@ class adjacency_matrix final {
              | std::views::transform([this, vertex_id, &edge_properties_map](auto source_id) {
                    const auto edge_id = specialized_impl::get_entry(*this, source_id, vertex_id);
                    return edge_type{
-                       edge_id, source_id, vertex_id, *edge_properties_map[to_idx(edge_id)]
+                       edge_id, source_id, vertex_id, edge_properties_map[to_idx(edge_id)]
                    };
                });
     }
@@ -258,9 +257,8 @@ class adjacency_matrix final {
                });
     }
 
-    [[nodiscard]] gl_attr_force_inline auto out_edges(
-        id_type vertex_id, const auto& edge_properties_map
-    ) const
+    [[nodiscard]] gl_attr_force_inline auto out_edges(id_type vertex_id, auto& edge_properties_map)
+        const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
         return this->_matrix[to_idx(vertex_id)] | std::views::enumerate
@@ -274,7 +272,7 @@ class adjacency_matrix final {
                        edge_id,
                        vertex_id,
                        static_cast<id_type>(target_id),
-                       *edge_properties_map[to_idx(edge_id)]
+                       edge_properties_map[to_idx(edge_id)]
                    };
                });
     }
diff --git a/include/gl/impl/specialized/adjacency_list.hpp b/include/gl/impl/specialized/adjacency_list.hpp
@@ -198,7 +198,7 @@ struct directed_adjacency_list {
     }
 
     [[nodiscard]] gl_attr_force_inline static auto incident_edges(
-        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+        const impl_type& self, id_type vertex_id, auto& edge_properties_map
     ) {
         return util::concat(
             self.in_edges(vertex_id, edge_properties_map),
@@ -358,7 +358,7 @@ struct undirected_adjacency_list {
     }
 
     [[nodiscard]] gl_attr_force_inline static auto incident_edges(
-        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+        const impl_type& self, id_type vertex_id, auto& edge_properties_map
     ) {
         return self.out_edges(vertex_id, edge_properties_map);
     }
diff --git a/include/gl/impl/specialized/adjacency_matrix.hpp b/include/gl/impl/specialized/adjacency_matrix.hpp
@@ -240,7 +240,7 @@ struct directed_adjacency_matrix {
     }
 
     [[nodiscard]] gl_attr_force_inline static auto incident_edges(
-        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+        const impl_type& self, id_type vertex_id, auto& edge_properties_map
     ) {
         return util::concat(
             self.in_edges(vertex_id, edge_properties_map),
@@ -434,7 +434,7 @@ struct undirected_adjacency_matrix {
     }
 
     [[nodiscard]] gl_attr_force_inline static auto incident_edges(
-        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+        const impl_type& self, id_type vertex_id, auto& edge_properties_map
     ) {
         return self.out_edges(vertex_id, edge_properties_map);
     }
diff --git a/include/gl/impl/specialized/flat_adjacency_list.hpp b/include/gl/impl/specialized/flat_adjacency_list.hpp
@@ -162,7 +162,7 @@ struct directed_flat_adjacency_list {
     }
 
     [[nodiscard]] gl_attr_force_inline static auto incident_edges(
-        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+        const impl_type& self, id_type vertex_id, auto& edge_properties_map
     ) {
         return util::concat(
             self.in_edges(vertex_id, edge_properties_map),
@@ -338,7 +338,7 @@ struct undirected_flat_adjacency_list {
     }
 
     [[nodiscard]] gl_attr_force_inline static auto incident_edges(
-        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+        const impl_type& self, id_type vertex_id, auto& edge_properties_map
     ) {
         return self.out_edges(vertex_id, edge_properties_map);
     }
diff --git a/include/gl/impl/specialized/flat_adjacency_matrix.hpp b/include/gl/impl/specialized/flat_adjacency_matrix.hpp

Original file line number	Diff line number	Diff line change
`@@ -161,15 +161,15 @@ class adjacency_matrix final {`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`[[nodiscard]] std::optional<edge_type> edge(`
`164`		`- id_type source_id, id_type target_id, const auto& edge_properties_map`
	`164`	`+ id_type source_id, id_type target_id, auto& edge_properties_map`
`165`	`165`	`) const`
`166`	`166`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`167`	`167`	`{`
`168`	`168`	`const auto edge_id = specialized_impl::get_entry(*this, source_id, target_id);`
`169`	`169`	`if (edge_id == invalid_id)`
`170`	`170`	`return std::nullopt;`
`171`	`171`	`return std::make_optional<edge_type>(`
`172`		`- edge_id, source_id, target_id, *edge_properties_map[to_idx(edge_id)]`
	`172`	`+ edge_id, source_id, target_id, edge_properties_map[to_idx(edge_id)]`
`173`	`173`	`);`
`174`	`174`	`}`
`175`	`175`
`@@ -185,15 +185,15 @@ class adjacency_matrix final {`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`[[nodiscard]] std::vector<edge_type> edges(`
`188`		`- id_type source_id, id_type target_id, const auto& edge_properties_map`
	`188`	`+ id_type source_id, id_type target_id, auto& edge_properties_map`
`189`	`189`	`) const`
`190`	`190`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`191`	`191`	`{`
`192`	`192`	`const auto edge_id = specialized_impl::get_entry(*this, source_id, target_id);`
`193`	`193`	`if (edge_id == invalid_id)`
`194`	`194`	`return std::vector<edge_type>();`
`195`	`195`	`return std::vector<edge_type>{`
`196`		`- edge_type{edge_id, source_id, target_id, *edge_properties_map[to_idx(edge_id)]}`
	`196`	`+ edge_type{edge_id, source_id, target_id, edge_properties_map[to_idx(edge_id)]}`
`197`	`197`	`};`
`198`	`198`	`}`
`199`	`199`
`@@ -204,7 +204,7 @@ class adjacency_matrix final {`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`[[nodiscard]] gl_attr_force_inline auto incident_edges(`
`207`		`- id_type vertex_id, const auto& edge_properties_map`
	`207`	`+ id_type vertex_id, auto& edge_properties_map`
`208`	`208`	`) const`
`209`	`209`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`210`	`210`	`{`
`@@ -227,9 +227,8 @@ class adjacency_matrix final {`
`227`	`227`	`});`
`228`	`228`	`}`
`229`	`229`
`230`		`- [[nodiscard]] gl_attr_force_inline auto in_edges(`
`231`		`- id_type vertex_id, const auto& edge_properties_map`
`232`		`- ) const`
	`230`	`+ [[nodiscard]] gl_attr_force_inline auto in_edges(id_type vertex_id, auto& edge_properties_map)`
	`231`	`+ const`
`233`	`232`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`234`	`233`	`{`
`235`	`234`	`return std::views::iota(initial_id_v<id_type>, this->_matrix.size())`
`@@ -239,7 +238,7 @@ class adjacency_matrix final {`
`239`	`238`	`\| std::views::transform([this, vertex_id, &edge_properties_map](auto source_id) {`
`240`	`239`	`const auto edge_id = specialized_impl::get_entry(*this, source_id, vertex_id);`
`241`	`240`	`return edge_type{`
`242`		`- edge_id, source_id, vertex_id, *edge_properties_map[to_idx(edge_id)]`
	`241`	`+ edge_id, source_id, vertex_id, edge_properties_map[to_idx(edge_id)]`
`243`	`242`	`};`
`244`	`243`	`});`
`245`	`244`	`}`
`@@ -258,9 +257,8 @@ class adjacency_matrix final {`
`258`	`257`	`});`
`259`	`258`	`}`
`260`	`259`
`261`		`- [[nodiscard]] gl_attr_force_inline auto out_edges(`
`262`		`- id_type vertex_id, const auto& edge_properties_map`
`263`		`- ) const`
	`260`	`+ [[nodiscard]] gl_attr_force_inline auto out_edges(id_type vertex_id, auto& edge_properties_map)`
	`261`	`+ const`
`264`	`262`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`265`	`263`	`{`
`266`	`264`	`return this->_matrix[to_idx(vertex_id)] \| std::views::enumerate`
`@@ -274,7 +272,7 @@ class adjacency_matrix final {`
`274`	`272`	`edge_id,`
`275`	`273`	`vertex_id,`
`276`	`274`	`static_cast<id_type>(target_id),`
`277`		`- *edge_properties_map[to_idx(edge_id)]`
	`275`	`+ edge_properties_map[to_idx(edge_id)]`
`278`	`276`	`};`
`279`	`277`	`});`
`280`	`278`	`}`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ struct directed_adjacency_list {`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`[[nodiscard]] gl_attr_force_inline static auto incident_edges(`
`201`		`- const impl_type& self, id_type vertex_id, const auto& edge_properties_map`
	`201`	`+ const impl_type& self, id_type vertex_id, auto& edge_properties_map`
`202`	`202`	`) {`
`203`	`203`	`return util::concat(`
`204`	`204`	`self.in_edges(vertex_id, edge_properties_map),`
`@@ -358,7 +358,7 @@ struct undirected_adjacency_list {`
`358`	`358`	`}`
`359`	`359`
`360`	`360`	`[[nodiscard]] gl_attr_force_inline static auto incident_edges(`
`361`		`- const impl_type& self, id_type vertex_id, const auto& edge_properties_map`
	`361`	`+ const impl_type& self, id_type vertex_id, auto& edge_properties_map`
`362`	`362`	`) {`
`363`	`363`	`return self.out_edges(vertex_id, edge_properties_map);`
`364`	`364`	`}`
Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ struct directed_adjacency_matrix {`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`[[nodiscard]] gl_attr_force_inline static auto incident_edges(`
`243`		`- const impl_type& self, id_type vertex_id, const auto& edge_properties_map`
	`243`	`+ const impl_type& self, id_type vertex_id, auto& edge_properties_map`
`244`	`244`	`) {`
`245`	`245`	`return util::concat(`
`246`	`246`	`self.in_edges(vertex_id, edge_properties_map),`
`@@ -434,7 +434,7 @@ struct undirected_adjacency_matrix {`
`434`	`434`	`}`
`435`	`435`
`436`	`436`	`[[nodiscard]] gl_attr_force_inline static auto incident_edges(`
`437`		`- const impl_type& self, id_type vertex_id, const auto& edge_properties_map`
	`437`	`+ const impl_type& self, id_type vertex_id, auto& edge_properties_map`
`438`	`438`	`) {`
`439`	`439`	`return self.out_edges(vertex_id, edge_properties_map);`
`440`	`440`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,7 @@ struct directed_flat_adjacency_list {`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`[[nodiscard]] gl_attr_force_inline static auto incident_edges(`
`165`		`- const impl_type& self, id_type vertex_id, const auto& edge_properties_map`
	`165`	`+ const impl_type& self, id_type vertex_id, auto& edge_properties_map`
`166`	`166`	`) {`
`167`	`167`	`return util::concat(`
`168`	`168`	`self.in_edges(vertex_id, edge_properties_map),`
`@@ -338,7 +338,7 @@ struct undirected_flat_adjacency_list {`
`338`	`338`	`}`
`339`	`339`
`340`	`340`	`[[nodiscard]] gl_attr_force_inline static auto incident_edges(`
`341`		`- const impl_type& self, id_type vertex_id, const auto& edge_properties_map`
	`341`	`+ const impl_type& self, id_type vertex_id, auto& edge_properties_map`
`342`	`342`	`) {`
`343`	`343`	`return self.out_edges(vertex_id, edge_properties_map);`
`344`	`344`	`}`