Read postgresql data on C++

.github/workflows/check-files.yml

@@ -67,7 +67,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: 'cpplint/cpplint'
-          ref: "develop"
+          ref: "1.6.1"
           path: "code_linter/cpplint"
       - name: Run linter
         run: |

NEWS.md

@@ -34,6 +34,8 @@ milestone for 3.7.0
 
 * [#2599](https://github.com/pgRouting/pgrouting/pull/2599)  Driving distance
   cleanup
+* [#2607](https://github.com/pgRouting/pgrouting/pull/2607)  Read postgresql
+  data on C++
 
 **Others**
 

doc/src/release_notes.rst

@@ -60,6 +60,8 @@ milestone for 3.7.0
 
 * `#2599 <https://github.com/pgRouting/pgrouting/pull/2599>`__  Driving distance
   cleanup
+* `#2607 <https://github.com/pgRouting/pgrouting/pull/2607>`__  Read postgresql
+  data on C++
 
 .. rubric:: Others
 

docqueries/bdAstar/doc-pgr_bdAstar.result

@@ -71,8 +71,8 @@ SELECT * FROM pgr_bdAstar(
    5 |        5 |         6 |      10 |   15 |    3 |    1 |        4
    6 |        6 |         6 |      10 |   10 |   -1 |    0 |        5
    7 |        1 |         6 |      12 |    6 |    4 |    1 |        0
-   8 |        2 |         6 |      12 |    7 |   10 |    1 |        1
-   9 |        3 |         6 |      12 |    8 |   12 |    1 |        2
+   8 |        2 |         6 |      12 |    7 |    8 |    1 |        1
+   9 |        3 |         6 |      12 |   11 |   11 |    1 |        2
   10 |        4 |         6 |      12 |   12 |   -1 |    0 |        3
   11 |        1 |         8 |      10 |    8 |   10 |    1 |        0
   12 |        2 |         8 |      10 |    7 |    8 |    1 |        1

docqueries/lineGraph/pgtap_design_lineGraphFull.result

@@ -54,6 +54,8 @@ SELECT id FROM vertices;
 SELECT  *  FROM pgr_lineGraphFull(
     $$SELECT id, source, target, cost FROM edges WHERE id = 1$$
 );
+NOTICE:  No edges found
+HINT:  SELECT id, source, target, cost FROM edges WHERE id = 1
  seq | source | target | cost | edge
 -----+--------+--------+------+------
 (0 rows)

docqueries/topologicalSort/doc-topologicalSort.result

@@ -62,6 +62,7 @@ SELECT * FROM pgr_topologicalsort(
 SELECT * FROM pgr_topologicalsort(
   $$SELECT id, source, target, cost, reverse_cost FROM edges$$);
 ERROR:  Graph is not DAG
+HINT:
 CONTEXT:  SQL function "pgr_topologicalsort" statement 1
 /* -- q4 */
 ROLLBACK;

include/allpairs/pgr_allpairs.hpp

@@ -45,7 +45,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #include "c_types/iid_t_rt.h"
 #include "cpp_common/basePath_SSEC.hpp"
 #include "cpp_common/pgr_base_graph.hpp"
-#include "cpp_common/interruption.h"
+#include "cpp_common/interruption.hpp"
 
 // TODO(vicky) don't keep it here
 #include "cpp_common/pgr_alloc.hpp"

include/astar/astar.hpp

@@ -42,7 +42,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #include "visitors/astar_visitors.hpp"
 #include "cpp_common/basePath_SSEC.hpp"
 #include "cpp_common/pgr_base_graph.hpp"
-#include "cpp_common/interruption.h"
+#include "cpp_common/interruption.hpp"
 #include "c_types/ii_t_rt.h"
 
 namespace detail {

include/bellman_ford/pgr_bellman_ford.hpp

@@ -1,4 +1,5 @@
 /*PGR-GNU*****************************************************************
+File: pgr_bellman_ford.hpp
 
 Copyright (c) 2015 pgRouting developers
 Mail: [email protected]
@@ -43,22 +44,19 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #include "cpp_common/pgr_messages.h"
 #include "cpp_common/basePath_SSEC.hpp"
 #include "cpp_common/pgr_base_graph.hpp"
-#include "cpp_common/interruption.h"
+#include "cpp_common/interruption.hpp"
 #include "c_types/ii_t_rt.h"
 
-
-
-
-//******************************************
 namespace pgrouting {
 
 template < class G >
 class Pgr_bellman_ford : public pgrouting::Pgr_messages {
  public:
      typedef typename G::V V;
      typedef typename G::E E;
-     //@}
+     //@{
 
+#if 0
      //! @name BellmanFord
      //@{
      //! BellmanFord 1 to 1
@@ -94,39 +92,40 @@ class Pgr_bellman_ford : public pgrouting::Pgr_messages {
                  predecessors, distances,
                  only_cost, true);
      }
+#endif
+
 
+     /** @brief bellman_ford one to a set of many
+      * @todo document this function
+      */
 
-     //! BellmanFord 1 to many
      std::deque<Path> bellman_ford(
              G &graph,
              int64_t start_vertex,
-             const std::vector< int64_t > &end_vertex,
+             const std::set<int64_t> &end_vertex,
              bool only_cost = false) {
          // adjust predecessors and distances vectors
          clear();
-         log << std::string(__FUNCTION__) << "\n";
          predecessors.resize(graph.num_vertices());
          distances.resize(graph.num_vertices());
 
-         // get the graphs source and target
-         if (!graph.has_vertex(start_vertex))
-             return std::deque<Path>();
+         // get the graphs source and targets
+         if (!graph.has_vertex(start_vertex)) return std::deque<Path>();
          auto v_source(graph.get_V(start_vertex));
 
-         std::set< V > s_v_targets;
+         std::set<V> s_v_targets;
          for (const auto &vertex : end_vertex) {
              if (graph.has_vertex(vertex)) {
                  s_v_targets.insert(graph.get_V(vertex));
              }
          }
 
-         std::vector< V > v_targets(s_v_targets.begin(), s_v_targets.end());
+         std::vector<V> v_targets(s_v_targets.begin(), s_v_targets.end());
          // perform the algorithm
          bellman_ford_1_to_many(graph, v_source);
 
-         std::deque< Path > paths;
          // get the results // route id are the targets
-         paths = get_paths(graph, v_source, v_targets, only_cost);
+         auto paths = get_paths(graph, v_source, v_targets, only_cost);
 
          std::stable_sort(paths.begin(), paths.end(),
                  [](const Path &e1, const Path &e2)->bool {
@@ -136,6 +135,7 @@ class Pgr_bellman_ford : public pgrouting::Pgr_messages {
          return paths;
      }
 
+#if 0
      // BellmanFord many to 1
      std::deque<Path> bellman_ford(
              G &graph,
@@ -219,10 +219,28 @@ class Pgr_bellman_ford : public pgrouting::Pgr_messages {
 
          return paths;
      }
+#endif
+
+     /** @brief BellmanFord combinations **/
+     std::deque<Path> bellman_ford(
+             G &graph,
+             const std::map<int64_t, std::set<int64_t>> &combinations,
+             bool only_cost = false) {
+         std::deque<Path> paths;
+
+         for (const auto &comb : combinations) {
+             if (!graph.has_vertex(comb.first)) continue;
+             auto tmp_paths = bellman_ford(graph, comb.first, comb.second, only_cost);
+             paths.insert(paths.end(), tmp_paths.begin(), tmp_paths.end());
+         }
+
+         return paths;
+     }
 
      //@}
 
  private:
+#if 0
      //! Call to BellmanFord  1 source to 1 target
      bool bellman_ford_1_to_1(
                  G &graph,
@@ -250,6 +268,8 @@ class Pgr_bellman_ford : public pgrouting::Pgr_messages {
          }
          return true;
      }
+#endif
+
      //! Call to BellmanFord  1 source to many targets
      bool bellman_ford_1_to_many(
              G &graph,
@@ -291,7 +311,6 @@ class Pgr_bellman_ford : public pgrouting::Pgr_messages {
              V source,
              std::vector< V > &targets,
              bool only_cost) const {
-        log << std::string(__FUNCTION__) << "\n";
          std::deque<Path> paths;
          for (const auto target : targets) {
              paths.push_back(Path(
@@ -307,8 +326,8 @@ class Pgr_bellman_ford : public pgrouting::Pgr_messages {
 
      //! @name members
      //@{
-     std::vector< V > predecessors;
-     std::vector< double > distances;
+     std::vector<V> predecessors;
+     std::vector<double> distances;
 
      //@}
 };

include/bellman_ford/pgr_edwardMoore.hpp

@@ -1,7 +1,9 @@
 /*PGR-GNU*****************************************************************
 File: pgr_edwardMoore.hpp
+
 Copyright (c) 2019 pgRouting developers
 Mail: [email protected]
+
 Copyright (c) 2019 Gudesa Venkata Sai AKhil
 Mail: [email protected]
 ------
@@ -26,11 +28,12 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #include <algorithm>
 #include <vector>
 #include <deque>
+#include <set>
 #include <map>
 
 #include "cpp_common/basePath_SSEC.hpp"
 #include "cpp_common/pgr_base_graph.hpp"
-#include "cpp_common/interruption.h"
+#include "cpp_common/interruption.hpp"
 
 #include "c_types/ii_t_rt.h"
 
@@ -42,10 +45,9 @@ class Pgr_edwardMoore {
  public:
     typedef typename G::V V;
     typedef typename G::E E;
-    typedef typename G::B_G B_G;
     typedef typename G::EO_i EO_i;
-    typedef typename G::E_i E_i;
 
+#if 0
     std::deque<Path> edwardMoore(
         G &graph,
         const std::vector<int64_t> &start_vertex,
@@ -117,14 +119,37 @@ class Pgr_edwardMoore {
 
         return paths;
     }
+#endif
+
+    /** @brief edwardMoore for combinations */
+    std::deque<Path> edwardMoore(
+        G &graph,
+        const std::map<int64_t, std::set<int64_t>> &combinations) {
+        std::deque<Path> paths;
+
+         for (const auto &comb : combinations) {
+             if (!graph.has_vertex(comb.first)) continue;
+             auto tmp_paths = one_to_many_edwardMoore(graph, comb.first, comb.second);
+             paths.insert(paths.end(), tmp_paths.begin(), tmp_paths.end());
+         }
+         std::sort(paths.begin(), paths.end(),
+                 [](const Path &e1, const Path &e2) -> bool {
+                 return e1.end_id() < e2.end_id();
+                 });
+         std::stable_sort(paths.begin(), paths.end(),
+                 [](const Path &e1, const Path &e2) -> bool {
+                 return e1.start_id() < e2.start_id();
+                 });
+         return paths;
+    }
 
  private:
-    E DEFAULT_EDGE;
+    E default_edge;
 
     std::deque<Path> one_to_many_edwardMoore(
         G &graph,
         int64_t start_vertex,
-        std::vector<int64_t> end_vertex) {
+        const std::set<int64_t> &end_vertex) {
         std::deque<Path> paths;
 
         if (graph.has_vertex(start_vertex) == false) {
@@ -135,7 +160,7 @@ class Pgr_edwardMoore {
         std::vector<bool> isInQ(graph.num_vertices(), false);
         std::vector<E> from_edge(graph.num_vertices());
         std::deque<V> dq;
-        DEFAULT_EDGE = from_edge[0];
+        default_edge = from_edge[0];
 
         auto bgl_start_vertex = graph.get_V(start_vertex);
 
@@ -159,7 +184,7 @@ class Pgr_edwardMoore {
 
             auto bgl_target_vertex = graph.get_V(target_vertex);
 
-            if (from_edge[bgl_target_vertex] == DEFAULT_EDGE) {
+            if (from_edge[bgl_target_vertex] == default_edge) {
                 continue;
             }
 
@@ -192,7 +217,7 @@ class Pgr_edwardMoore {
             path.push_back({graph[from].id, graph[e].id, graph[e].cost, current_cost[from], 0});
 
             current_node = from;
-        } while (from_edge[current_node] != DEFAULT_EDGE);
+        } while (from_edge[current_node] != default_edge);
 
         std::reverse(path.begin(), path.end());
         return path;