Path::collapse_paths get_tuples in to_postgres namespace

Author: cvvergara

include/cpp_common/path.hpp

@@ -143,17 +143,6 @@ class Path {
             Path_rt **ret_path,
             size_t &sequence, int routeId) const;
 
-    void generate_postgres_data(
-            Path_rt **postgres_data,
-            size_t &sequence) const;
-
-    void generate_tuples(MST_rt**, size_t&) const;
-    friend size_t collapse_paths(MST_rt**, const std::deque<Path>&);
-
-    friend size_t collapse_paths(
-            Path_rt **ret_path,
-            const std::deque< Path > &paths);
-
 
     /** @brief discards common vertices with greater agg_cost */
     friend void equi_cost(std::deque< Path > &paths);

include/cpp_common/to_postgres.hpp

@@ -27,11 +27,14 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #pragma once
 
 #include <vector>
+#include <deque>
 #include <cstddef>
 
 #include "c_types/contractionHierarchies_rt.h"
 #include "c_types/iid_t_rt.h"
 #include "c_types/routes_t.h"
+#include "c_types/path_rt.h"
+#include "c_types/mst_rt.h"
 
 #include "cpp_common/path.hpp"
 #include "cpp_common/base_graph.hpp"
@@ -48,6 +51,21 @@ size_t count_rows(const std::vector<std::vector<double>>&);
 
 }  // namespace detail
 
+/*
+ * @brief Via Routes save on a C array
+ */
+size_t get_viaRoute(std::deque<pgrouting::Path>&, Routes_t**);
+
+/*
+ * @brief get tuples from a Path to a Path_rt
+ */
+size_t get_tuples(const std::deque<pgrouting::Path>&, Path_rt*&);
+
+/*
+ * @brief get tuples from a Path to a MST_rt
+ */
+size_t get_tuples(const std::deque<pgrouting::Path>&, MST_rt*&);
+
 /** @brief Vector of vertices id are saved on a C array
  *
  * @param[in] graph Created graph with the base Graph
@@ -206,11 +224,6 @@ void graph_to_tuple(
     }
 }
 
-/*
- * @brief Via Routes save on a C array
- */
-size_t get_viaRoute(std::deque<pgrouting::Path>&, Routes_t**);
-
 }  // namespace to_postgres
 }  // namespace pgrouting
 

src/common/path.cpp

@@ -228,36 +228,6 @@ void Path::append(const Path &other) {
 }
 
 
-void Path::generate_postgres_data(
-        Path_rt **postgres_data,
-        size_t &sequence) const {
-    for (const auto e : path) {
-        auto agg_cost = std::fabs(
-                e.agg_cost - (std::numeric_limits<double>::max)()) < 1?
-            std::numeric_limits<double>::infinity() : e.agg_cost;
-        auto cost = std::fabs(e.cost - (std::numeric_limits<double>::max)()) < 1?
-            std::numeric_limits<double>::infinity() : e.cost;
-
-        (*postgres_data)[sequence] = {start_id(), end_id(), e.node, e.edge, cost, agg_cost};
-        ++sequence;
-    }
-}
-
-void Path::generate_tuples(
-        MST_rt **tuples,
-        size_t &sequence) const {
-    for (const auto e : path) {
-        auto agg_cost = std::fabs(
-                e.agg_cost - (std::numeric_limits<double>::max)()) < 1?
-            std::numeric_limits<double>::infinity() : e.agg_cost;
-        auto cost = std::fabs(e.cost - (std::numeric_limits<double>::max)()) < 1?
-            std::numeric_limits<double>::infinity() : e.cost;
-
-        (*tuples)[sequence] = {start_id(), 0, e.pred, e.node, e.edge, cost, agg_cost};
-        ++sequence;
-    }
-}
-
 
 /* used by ksp */
 void Path::get_pg_nksp_path(
@@ -325,17 +295,6 @@ collapse_paths(
     return sequence;
 }
 
-size_t
-collapse_paths(
-        MST_rt **tuples,
-        const std::deque<Path> &paths) {
-    size_t sequence = 0;
-    for (const Path &path : paths) {
-        if (path.path.size() > 0) path.generate_tuples(tuples, sequence);
-    }
-    return sequence;
-}
-
 /*
  * sort the paths by size from greater to smaller
  *        and sort each path by node

src/cpp_common/to_postgres.cpp

@@ -27,26 +27,35 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #include <cstddef>
 #include <deque>
 #include <vector>
+#include <limits>
 
 #include "c_types/routes_t.h"
+#include "c_types/path_rt.h"
+#include "c_types/mst_rt.h"
 
 #include "cpp_common/path.hpp"
 #include "cpp_common/alloc.hpp"
 #include "cpp_common/assert.hpp"
 
 namespace {
 
+double
+to_inf(double value) {
+    return std::fabs(value - (std::numeric_limits<double>::max)()) < 1?
+        std::numeric_limits<double>::infinity() : value;
+}
+
 void
 get_path(
         int route_id,
         int path_id,
         const pgrouting::Path &path,
-        Routes_t **postgres_data,
+        Routes_t **tuples,
         double &route_agg_cost,
         size_t &sequence) {
     int path_seq = 0;
     for (const auto e : path) {
-        (*postgres_data)[sequence] = {
+        (*tuples)[sequence] = {
             route_id,
             path_id,
             path_seq,
@@ -63,6 +72,45 @@ get_path(
     }
 }
 
+void get_path(
+        const pgrouting::Path &path,
+        Path_rt* &tuples,
+        size_t &sequence) {
+    double prev_cost = 0;
+    double aggcost = path.size() == 1? path[0].agg_cost : 0;
+    for (const auto e : path) {
+        aggcost += prev_cost;
+        tuples[sequence] = {
+            path.start_id(),
+            path.end_id(),
+            e.node,
+            e.edge,
+            to_inf(e.cost),
+            to_inf(aggcost)
+        };
+        prev_cost = e.cost;
+        sequence++;
+    }
+}
+
+void get_path(
+        const pgrouting::Path &path,
+        MST_rt* &tuples,
+        size_t &sequence) {
+    for (const auto e : path) {
+        tuples[sequence] = {
+            path.start_id(),
+            0,
+            e.pred,
+            e.node,
+            e.edge,
+            to_inf(e.cost),
+            to_inf(e.agg_cost)};
+        ++sequence;
+    }
+}
+
+
 }  // namespace
 
 namespace pgrouting {
@@ -134,5 +182,46 @@ get_viaRoute(
     return sequence;
 }
 
+size_t
+get_tuples(
+        const std::deque<pgrouting::Path> &paths,
+        Path_rt* &tuples) {
+    pgassert(!tuples);
+
+    auto count = count_tuples(paths);
+    if (count == 0) return 0;
+
+    tuples = pgr_alloc(count, tuples);
+
+    size_t sequence = 0;
+    for (const auto &path : paths) {
+        if (path.size() > 0) {
+            ::get_path(path, tuples, sequence);
+        }
+    }
+    return sequence;
+}
+
+
+size_t
+get_tuples(
+        const std::deque<pgrouting::Path> &paths,
+        MST_rt* &tuples) {
+    pgassert(!tuples);
+
+    auto count = count_tuples(paths);
+    if (count == 0) return 0;
+
+    tuples = pgr_alloc(count, tuples);
+
+    size_t sequence = 0;
+    for (const Path &path : paths) {
+        if (path.size() > 0) {
+            ::get_path(path, tuples, sequence);
+        }
+    }
+    return sequence;
+}
+
 }  // namespace to_postgres
 }  // namespace pgrouting