Adapts Nearest plugin to new API

src/engine/engine.cpp

@@ -144,14 +144,30 @@ Engine::~Engine() = default;
 Engine::Engine(Engine &&) noexcept = default;
 Engine &Engine::operator=(Engine &&) noexcept = default;
 
-Status Engine::Route(const api::RouteParameters &route_parameters, util::json::Object &result)
+Status Engine::Route(const api::RouteParameters &params, util::json::Object &result)
 {
-    return RunQuery(lock, *query_data_facade, route_parameters, *route_plugin, result);
+    return RunQuery(lock, *query_data_facade, params, *route_plugin, result);
 }
 
-Status Engine::Table(const api::TableParameters &table_parameters, util::json::Object &result)
+Status Engine::Table(const api::TableParameters &params, util::json::Object &result)
 {
-    return RunQuery(lock, *query_data_facade, table_parameters, *table_plugin, result);
+    return RunQuery(lock, *query_data_facade, params, *table_plugin, result);
 }
+
+Status Engine::Nearest(const api::NearestParameters &params, util::json::Object &result)
+{
+    return RunQuery(lock, *query_data_facade, params, *nearest_plugin, result);
+}
+
+//Status Engine::Trip(const api::TripParameters &params, util::json::Object &result)
+//{
+//    return RunQuery(lock, *query_data_facade, params, *trip_plugin, result);
+//}
+//
+//Status Engine::Match(const api::MatchParameters &params, util::json::Object &result)
+//{
+//    return RunQuery(lock, *query_data_facade, params, *match_plugin, result);
+//}
+
 } // engine ns
 } // osrm ns

src/engine/plugins/nearest.cpp

@@ -0,0 +1,87 @@
+#include "engine/plugins/nearest.hpp"
+#include "engine/phantom_node.hpp"
+#include "util/integer_range.hpp"
+
+#include <cstddef>
+#include <string>
+
+#include <boost/assert.hpp>
+
+namespace osrm
+{
+namespace engine
+{
+namespace plugins
+{
+
+NearestPlugin::NearestPlugin(datafacade::BaseDataFacade &facade) : BasePlugin{facade} {}
+
+Status NearestPlugin::HandleRequest(const api::NearestParameters &params,
+                                    util::json::Object &result)
+{
+    BOOST_ASSERT(params.IsValid());
+
+    if (!CheckAllCoordinates(params.coordinates))
+        return Error("invalid-options", "Coordinates are invalid", result);
+
+    if (params.bearings.size() > 0 && params.coordinates.size() != params.bearings.size())
+        return Error("invalid-options", "Number of bearings does not match number of coordinates",
+                     result);
+
+    const auto &input_bearings = params.bearings;
+    auto number_of_results = static_cast<std::size_t>(params.number_of_results);
+
+    /* TODO(daniel-j-h): bearing range?
+    const int bearing = input_bearings.size() > 0 ? input_bearings.front().first : 0;
+    const int range = input_bearings.size() > 0
+                          ? (input_bearings.front().second ? *input_bearings.front().second : 10)
+                          : 180;
+    auto phantom_node_vector =
+        facade.NearestPhantomNodes(params.coordinates.front(), number_of_results, bearing, range);
+
+    if (phantom_node_vector.empty())
+    {
+        result.values["status_message"] =
+            std::string("Could not find a matching segments for coordinate");
+        return Status::NoSegment;
+    }
+    else
+    {
+        result.values["status_message"] = "Found nearest edge";
+        if (number_of_results > 1)
+        {
+            util::json::Array results;
+
+            auto vector_length = phantom_node_vector.size();
+            for (const auto i :
+                 util::irange<std::size_t>(0, std::min(number_of_results, vector_length)))
+            {
+                const auto &node = phantom_node_vector[i].phantom_node;
+                util::json::Array json_coordinate;
+                util::json::Object result;
+                json_coordinate.values.push_back(node.location.lat / COORDINATE_PRECISION);
+                json_coordinate.values.push_back(node.location.lon / COORDINATE_PRECISION);
+                result.values["mapped coordinate"] = json_coordinate;
+                result.values["name"] = facade.get_name_for_id(node.name_id);
+                results.values.push_back(result);
+            }
+            result.values["results"] = results;
+        }
+        else
+        {
+            util::json::Array json_coordinate;
+            json_coordinate.values.push_back(phantom_node_vector.front().phantom_node.location.lat /
+                                             COORDINATE_PRECISION);
+            json_coordinate.values.push_back(phantom_node_vector.front().phantom_node.location.lon /
+                                             COORDINATE_PRECISION);
+            result.values["mapped_coordinate"] = json_coordinate;
+            result.values["name"] =
+                facade.get_name_for_id(phantom_node_vector.front().phantom_node.name_id);
+        }
+    }
+    */
+    return Status::Ok;
+}
+}
+}
+}

src/engine/plugins/table.cpp

@@ -15,6 +15,8 @@
 #include <string>
 #include <vector>
 
+#include <boost/assert.hpp>
+
 namespace osrm
 {
 namespace engine
@@ -58,7 +60,7 @@ Status TablePlugin::HandleRequest(const api::TableParameters &params, util::json
 
     auto snapped_phantoms = SnapPhantomNodes(GetPhantomNodes(params));
 
-    const auto result_table = [&]()
+    const auto result_table = [&]
     {
         if (params.sources.empty())
         {
@@ -76,7 +78,7 @@ Status TablePlugin::HandleRequest(const api::TableParameters &params, util::json
         return Error("no-table", "No table found", result);
     }
 
-    api::TableAPI table_api {facade, params};
+    api::TableAPI table_api{facade, params};
     table_api.MakeResponse(result_table, snapped_phantoms, result);
 
     return Status::Ok;