Fix

Author: Grufoony

benchmark/Bench_Network.cpp

@@ -63,8 +63,8 @@ static void BM_RoadNetwork_AllPathsTo(benchmark::State& state) {
   network.importNodeProperties((DATA_FOLDER / "forlì_nodes.csv").string());
   auto itNode = network.nodes().cbegin();
   for (auto _ : state) {
-    auto paths = network.allPathsTo(itNode->first,
-                                    [](auto const& pEdge) { return pEdge->length(); });
+    auto paths =
+        network.allPathsTo(itNode->first, [](auto const& edge) { return edge.length(); });
     ++itNode;
   }
 }
@@ -75,9 +75,8 @@ static void BM_RoadNetwork_ShortestPath(benchmark::State& state) {
   auto itSource = network.nodes().cbegin();
   auto itTarget = std::next(network.nodes().cbegin(), network.nodes().size() / 2);
   for (auto _ : state) {
-    auto path = network.shortestPath(itSource->first,
-                                     itTarget->first,
-                                     [](auto const& pEdge) { return pEdge->length(); });
+    auto path = network.shortestPath(
+        itSource->first, itTarget->first, [](auto const& edge) { return edge.length(); });
     benchmark::DoNotOptimize(path);
     ++itSource;
     ++itTarget;

examples/stalingrado.cpp

@@ -101,8 +101,8 @@ int main() {
         ++it;
       }
       if (progress % 300 == 0) {
-        ofs << progress << ';' << coil->counts() << std::endl;
-        coil->resetCounter();
+        ofs << progress << ';' << coil.counts() << std::endl;
+        coil.resetCounter();
       }
       dynamics.addAgents(*it, pItinerary, 0);
     }

profiling/parse_massif.cpp

@@ -16,19 +16,17 @@ std::vector<long> parse_massif(const std::string& file_path) {
 
   const char equal{'='};
   std::string buffer;
-  while (getline(file, buffer)) {
+  while (std::getline(file, buffer)) {
     if (buffer.find("mem_heap_B") != std::string::npos) {
       std::stringstream buffer_stream(buffer);
       std::string value;
-      getline(buffer_stream, value, equal);
+      std::getline(buffer_stream, value, equal);
       if (value == "mem_heap_B") {
-        getline(buffer_stream, value);
+        std::getline(buffer_stream, value);
         mem_values.push_back(std::stol(value));
       }
     }
   }
-
-  file.close();
   return mem_values;
 };
 
@@ -39,7 +37,12 @@ int main(int argc, char* argv[]) {
   }
 
   auto mem_values{parse_massif(argv[1])};
-  long long int integral{std::accumulate(mem_values.begin(), mem_values.end(), 0)};
+  if (mem_values.empty()) {
+    std::cerr << "No mem_heap_B values found in file: " << argv[1] << '\n';
+    return 1;
+  }
+
+  long long integral{std::accumulate(mem_values.begin(), mem_values.end(), 0LL)};
   long max_mem{*std::max_element(mem_values.begin(), mem_values.end())};
 
   std::cout << "integral: " << integral << " B\n";

src/dsf/base/Dynamics.hpp

@@ -119,6 +119,9 @@ namespace dsf {
     /// @brief Get the graph
     /// @return const network_t&, The graph
     inline auto const& graph() const { return m_graph; };
+    /// @brief Get the graph (mutable)
+    /// @return network_t&, The graph
+    inline auto& graph() { return m_graph; };
     /// @brief Get the id of the simulation
     /// @return const Id&, The id of the simulation
     inline auto const& id() const { return m_id; };

src/dsf/base/Network.hpp

@@ -65,20 +65,20 @@ namespace dsf {
 
     /// @brief Get a node by id
     /// @param nodeId The node's id
-    /// @return node_t& A reference to the node
-    inline node_t& node(Id nodeId) const { return *m_nodes.at(nodeId); };
+    /// @return const node_t& A reference to the node
+    inline const auto& node(Id nodeId) const { return *m_nodes.at(nodeId); };
     /// @brief Get a node by id
     /// @param nodeId The node's id
     /// @return node_t& A reference to the node
-    inline node_t& node(Id nodeId) { return *m_nodes.at(nodeId); };
+    inline auto& node(Id nodeId) { return *m_nodes.at(nodeId); };
     /// @brief Get an edge by id
     /// @param edgeId The edge's id
-    /// @return edge_t& A reference to the edge
-    inline edge_t& edge(Id edgeId) const { return *m_edges.at(edgeId); };
+    /// @return const edge_t& A reference to the edge
+    inline const auto& edge(Id edgeId) const { return *m_edges.at(edgeId); };
     /// @brief Get an edge by id
     /// @param edgeId The edge's id
     /// @return edge_t& A reference to the edge
-    inline edge_t& edge(Id edgeId) { return *m_edges.at(edgeId); }
+    inline auto& edge(Id edgeId) { return *m_edges.at(edgeId); }
 
     edge_t& edge(Id source, Id target) const;
     /// @brief Get a node by id

src/dsf/bindings.cpp

@@ -468,10 +468,9 @@ PYBIND11_MODULE(dsf_cpp, m) {
                     reinterpret_cast<double (*)(double, double)>(arg.cast<uintptr_t>());
                 self.setSpeedFunction(
                     dsf::SpeedFunction::CUSTOM,
-                    [func_ptr](
-                        std::unique_ptr<dsf::mobility::Street> const& pStreet) -> double {
+                    [func_ptr](dsf::mobility::Street const& street) -> double {
                       // No GIL needed — this is pure C
-                      return func_ptr(pStreet->maxSpeed(), pStreet->density(true));
+                      return func_ptr(street.maxSpeed(), street.density(true));
                     });
                 break;
               }
@@ -655,7 +654,9 @@ PYBIND11_MODULE(dsf_cpp, m) {
           dsf::g_docstrings.at("dsf::mobility::FirstOrderDynamics::optimizeTrafficLights")
               .c_str())
       .def("graph",
-           &dsf::mobility::FirstOrderDynamics::graph,
+           static_cast<const dsf::mobility::RoadNetwork& (
+               dsf::mobility::FirstOrderDynamics::*)() const>(
+               &dsf::mobility::FirstOrderDynamics::graph),
            pybind11::return_value_policy::reference_internal,
            dsf::g_docstrings.at("dsf::Dynamics::graph").c_str())
       .def("nAgents",

src/dsf/mobility/Street.hpp

@@ -165,6 +165,7 @@ namespace dsf::mobility {
     movingAgents() {
       return m_movingAgents;
     }
+    inline const auto& movingAgents() const { return m_movingAgents; }
     static inline auto agentData() {
       if (!m_agentData.has_value()) {
         throw std::runtime_error(