Add viaroute suport for new API

include/engine/plugins/plugin_base.hpp

@@ -1,11 +1,14 @@
 #ifndef BASE_PLUGIN_HPP
 #define BASE_PLUGIN_HPP
 
+#include "engine/datafacade/datafacade_base.hpp"
+#include "engine/api/base_parameters.hpp"
 #include "engine/phantom_node.hpp"
+#include "engine/status.hpp"
 
-#include "osrm/coordinate.hpp"
-#include "osrm/json_container.hpp"
-#include "osrm/route_parameters.hpp"
+#include "util/coordinate.hpp"
+#include "util/json_container.hpp"
+#include "util/integer_range.hpp"
 
 #include <algorithm>
 #include <string>
@@ -20,38 +23,32 @@ namespace plugins
 
 class BasePlugin
 {
-  public:
-    enum class Status : int
-    {
-        Ok = 200,
-        EmptyResult = 207,
-        NoSegment = 208,
-        Error = 400
-    };
+  protected:
+    datafacade::BaseDataFacade &facade;
+    BasePlugin(datafacade::BaseDataFacade &facade_) : facade(facade_) {}
 
-    BasePlugin() {}
-    // Maybe someone can explain the pure virtual destructor thing to me (dennis)
-    virtual ~BasePlugin() {}
-    virtual const std::string GetDescriptor() const = 0;
-    virtual Status HandleRequest(const RouteParameters &, util::json::Object &) = 0;
-    virtual bool check_all_coordinates(const std::vector<util::FixedPointCoordinate> &coordinates,
-                                       const unsigned min = 2) const final
+    bool CheckAllCoordinates(const std::vector<util::FixedPointCoordinate> &coordinates)
     {
-        if (min > coordinates.size() || std::any_of(std::begin(coordinates), std::end(coordinates),
-                                                    [](const util::FixedPointCoordinate coordinate)
-                                                    {
-                                                        return !coordinate.IsValid();
-                                                    }))
-        {
-            return false;
-        }
-        return true;
+        return !std::any_of(std::begin(coordinates), std::end(coordinates),
+                           [](const util::FixedPointCoordinate &coordinate)
+                           {
+                               return !coordinate.IsValid();
+                           });
+    }
+
+    Status Error(const std::string &code,
+                 const std::string &message,
+                 util::json::Object &json_result) const
+    {
+        json_result.values["code"] = code;
+        json_result.values["message"] = message;
+        return Status::Error;
     }
 
     // Decides whether to use the phantom node from a big or small component if both are found.
     // Returns true if all phantom nodes are in the same component after snapping.
-    std::vector<PhantomNode> snapPhantomNodes(
-        const std::vector<std::pair<PhantomNode, PhantomNode>> &phantom_node_pair_list) const
+    std::vector<PhantomNode>
+    SnapPhantomNodes(const std::vector<PhantomNodePair> &phantom_node_pair_list) const
     {
         const auto check_component_id_is_tiny =
             [](const std::pair<PhantomNode, PhantomNode> &phantom_pair)
@@ -111,6 +108,69 @@ class BasePlugin
 
         return snapped_phantoms;
     }
+
+    std::vector<PhantomNodePair> GetPhantomNodes(const api::BaseParameters &parameters)
+    {
+        std::vector<PhantomNodePair> phantom_node_pairs(parameters.coordinates.size());
+
+        const bool use_hints = !parameters.hints.empty();
+        const bool use_bearings = !parameters.bearings.empty();
+        const bool use_radiuses = !parameters.radiuses.empty();
+
+        BOOST_ASSERT(parameters.IsValid());
+        for (const auto i : util::irange<std::size_t>(0, parameters.coordinates.size()))
+        {
+            if (use_hints && parameters.hints[i] &&
+                parameters.hints[i]->IsValid(parameters.coordinates[i], facade))
+            {
+                phantom_node_pairs[i].first = parameters.hints[i]->phantom;
+                // we don't set the second one - it will be marked as invalid
+                continue;
+            }
+
+            if (use_bearings && parameters.bearings[i])
+            {
+                if (use_radiuses && parameters.radiuses[i])
+                {
+                    phantom_node_pairs[i] =
+                        facade.NearestPhantomNodeWithAlternativeFromBigComponent(
+                            parameters.coordinates[i], *parameters.radiuses[i],
+                            parameters.bearings[i]->bearing, parameters.bearings[i]->range);
+                }
+                else
+                    phantom_node_pairs[i] =
+                        facade.NearestPhantomNodeWithAlternativeFromBigComponent(
+                            parameters.coordinates[i], parameters.bearings[i]->bearing,
+                            parameters.bearings[i]->range);
+                {
+                }
+            }
+            else
+            {
+                if (use_radiuses && parameters.radiuses[i])
+                {
+                    phantom_node_pairs[i] =
+                        facade.NearestPhantomNodeWithAlternativeFromBigComponent(
+                            parameters.coordinates[i], *parameters.radiuses[i]);
+                }
+                else
+                    phantom_node_pairs[i] =
+                        facade.NearestPhantomNodeWithAlternativeFromBigComponent(
+                            parameters.coordinates[i]);
+                {
+                }
+            }
+
+            // we didn't found a fitting node, return error
+            if (!phantom_node_pairs[i].first.IsValid(facade.GetNumberOfNodes()))
+            {
+                break;
+            }
+            BOOST_ASSERT(phantom_node_pairs[i].first.IsValid(facade.GetNumberOfNodes()));
+            BOOST_ASSERT(phantom_node_pairs[i].second.IsValid(facade.GetNumberOfNodes()));
+        }
+        return phantom_node_pairs;
+    }
 };
 }
 }

include/engine/plugins/viaroute.hpp

@@ -1,17 +1,16 @@
 #ifndef VIA_ROUTE_HPP
 #define VIA_ROUTE_HPP
 
+#include "engine/datafacade/datafacade_base.hpp"
 #include "engine/plugins/plugin_base.hpp"
+#include "engine/api/route_api.hpp"
 
-#include "engine/api_response_generator.hpp"
 #include "engine/object_encoder.hpp"
-#include "engine/search_engine.hpp"
-#include "util/for_each_pair.hpp"
-#include "util/integer_range.hpp"
-#include "util/make_unique.hpp"
-#include "util/simple_logger.hpp"
-#include "util/timing_util.hpp"
-#include "osrm/json_container.hpp"
+#include "engine/search_engine_data.hpp"
+#include "engine/routing_algorithms/shortest_path.hpp"
+#include "engine/routing_algorithms/alternative_path.hpp"
+#include "engine/routing_algorithms/direct_shortest_path.hpp"
+#include "util/json_container.hpp"
 
 #include <cstdlib>
 
@@ -27,146 +26,20 @@ namespace engine
 namespace plugins
 {
 
-template <class DataFacadeT> class ViaRoutePlugin final : public BasePlugin
+class ViaRoutePlugin final : public BasePlugin
 {
   private:
-    std::string descriptor_string;
-    std::unique_ptr<SearchEngine<DataFacadeT>> search_engine_ptr;
-    DataFacadeT *facade;
+    SearchEngineData heaps;
+    routing_algorithms::ShortestPathRouting<datafacade::BaseDataFacade> shortest_path;
+    routing_algorithms::AlternativeRouting<datafacade::BaseDataFacade> alternative_path;
+    routing_algorithms::DirectShortestPathRouting<datafacade::BaseDataFacade> direct_shortest_path;
     int max_locations_viaroute;
 
   public:
-    explicit ViaRoutePlugin(DataFacadeT *facade, int max_locations_viaroute)
-        : descriptor_string("viaroute"), facade(facade),
-          max_locations_viaroute(max_locations_viaroute)
-    {
-        search_engine_ptr = util::make_unique<SearchEngine<DataFacadeT>>(facade);
-    }
+    explicit ViaRoutePlugin(datafacade::BaseDataFacade &facade, int max_locations_viaroute);
 
-    virtual ~ViaRoutePlugin() {}
-
-    const std::string GetDescriptor() const override final { return descriptor_string; }
-
-    Status HandleRequest(const RouteParameters &route_parameters,
-                         util::json::Object &json_result) override final
-    {
-        if (max_locations_viaroute > 0 &&
-            (static_cast<int>(route_parameters.coordinates.size()) > max_locations_viaroute))
-        {
-            json_result.values["status_message"] =
-                "Number of entries " + std::to_string(route_parameters.coordinates.size()) +
-                " is higher than current maximum (" + std::to_string(max_locations_viaroute) + ")";
-            return Status::Error;
-        }
-
-        if (!check_all_coordinates(route_parameters.coordinates))
-        {
-            json_result.values["status_message"] = "Invalid coordinates";
-            return Status::Error;
-        }
-
-        const auto &input_bearings = route_parameters.bearings;
-        if (input_bearings.size() > 0 &&
-            route_parameters.coordinates.size() != input_bearings.size())
-        {
-            json_result.values["status_message"] =
-                "Number of bearings does not match number of coordinate";
-            return Status::Error;
-        }
-
-        std::vector<PhantomNodePair> phantom_node_pair_list(route_parameters.coordinates.size());
-        const bool checksum_OK = (route_parameters.check_sum == facade->GetCheckSum());
-
-        for (const auto i : util::irange<std::size_t>(0, route_parameters.coordinates.size()))
-        {
-            if (checksum_OK && i < route_parameters.hints.size() &&
-                !route_parameters.hints[i].empty())
-            {
-                phantom_node_pair_list[i].first =
-                    decodeBase64<PhantomNode>(route_parameters.hints[i]);
-                if (phantom_node_pair_list[i].first.IsValid(facade->GetNumberOfNodes()))
-                {
-                    continue;
-                }
-            }
-            const int bearing = input_bearings.size() > 0 ? input_bearings[i].first : 0;
-            const int range = input_bearings.size() > 0
-                                  ? (input_bearings[i].second ? *input_bearings[i].second : 10)
-                                  : 180;
-            phantom_node_pair_list[i] = facade->NearestPhantomNodeWithAlternativeFromBigComponent(
-                route_parameters.coordinates[i], bearing, range);
-            // we didn't found a fitting node, return error
-            if (!phantom_node_pair_list[i].first.IsValid(facade->GetNumberOfNodes()))
-            {
-                json_result.values["status_message"] =
-                    std::string("Could not find a matching segment for coordinate ") +
-                    std::to_string(i);
-                return Status::NoSegment;
-            }
-            BOOST_ASSERT(phantom_node_pair_list[i].first.IsValid(facade->GetNumberOfNodes()));
-            BOOST_ASSERT(phantom_node_pair_list[i].second.IsValid(facade->GetNumberOfNodes()));
-        }
-
-        auto snapped_phantoms = snapPhantomNodes(phantom_node_pair_list);
-
-        InternalRouteResult raw_route;
-        auto build_phantom_pairs =
-            [&raw_route](const PhantomNode &first_node, const PhantomNode &second_node)
-        {
-            raw_route.segment_end_coordinates.push_back(PhantomNodes{first_node, second_node});
-        };
-        util::for_each_pair(snapped_phantoms, build_phantom_pairs);
-
-        if (1 == raw_route.segment_end_coordinates.size())
-        {
-            if (route_parameters.alternate_route && facade->GetCoreSize() == 0)
-            {
-                search_engine_ptr->alternative_path(raw_route.segment_end_coordinates.front(),
-                                                    raw_route);
-            }
-            else
-            {
-                search_engine_ptr->direct_shortest_path(raw_route.segment_end_coordinates,
-                                                        route_parameters.uturns, raw_route);
-            }
-        }
-        else
-        {
-            search_engine_ptr->shortest_path(raw_route.segment_end_coordinates,
-                                             route_parameters.uturns, raw_route);
-        }
-
-        // we can only know this after the fact, different SCC ids still
-        // allow for connection in one direction.
-        if (raw_route.is_valid())
-        {
-            auto generator = MakeApiResponseGenerator(facade);
-            generator.DescribeRoute(route_parameters, raw_route, json_result);
-            json_result.values["status_message"] = "Found route between points";
-        }
-        else
-        {
-            auto first_component_id = snapped_phantoms.front().component.id;
-            auto not_in_same_component =
-                std::any_of(snapped_phantoms.begin(), snapped_phantoms.end(),
-                            [first_component_id](const PhantomNode &node)
-                            {
-                                return node.component.id != first_component_id;
-                            });
-
-            if (not_in_same_component)
-            {
-                json_result.values["status_message"] = "Impossible route between points";
-                return Status::EmptyResult;
-            }
-            else
-            {
-                json_result.values["status_message"] = "No route found between points";
-                return Status::Error;
-            }
-        }
-        return Status::Ok;
-    }
+    Status HandleRequest(const api::RouteParameters &route_parameters,
+                         util::json::Object &json_result);
 };
 }
 }