Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

First take at distance table API re-write

Browse Source
This commit is contained in:
Daniel J. Hofmann 2016-02-12 14:49:28 -08:00 committed by Patrick Niklaus
parent 9194ab590c
commit d73600387b
7 changed files with 164 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/engine/api/table_parameters.hpp
View File

@ -36,7 +36,7 @@ struct TableParameters : public BaseParameters
return false; return false;
// 3/ 0 <= index < len(locations) // 3/ 0 <= index < len(locations)
const auto is_not_in_range = [](const std::size_t x) const auto not_in_range = [this](const std::size_t x)
{ {
return x >= coordinates.size(); return x >= coordinates.size();
}; };

22
include/engine/engine.hpp
View File

@ -26,10 +26,12 @@ struct EngineConfig;
namespace api namespace api
{ {
struct RouteParameters; struct RouteParameters;
struct TableParameters;
} }
namespace plugins namespace plugins
{ {
class ViaRoutePlugin; class ViaRoutePlugin;
class DistanceTablePlugin;
} }
namespace datafacade namespace datafacade
{ {
@ -39,26 +41,20 @@ class BaseDataFacade;
class Engine final class Engine final
{ {
public: public:
struct EngineLock Engine(EngineConfig &config);
{
// will only be initialized if shared memory is used
storage::SharedBarriers barrier;
// decrease number of concurrent queries
void DecreaseQueryCount();
// increase number of concurrent queries
void IncreaseQueryCount();
};
Engine(EngineConfig &config_);
Engine(const Engine &) = delete; Engine(const Engine &) = delete;
Engine &operator=(const Engine &) = delete; Engine &operator=(const Engine &) = delete;
Status Route(const api::RouteParameters &route_parameters, util::json::Object &json_result); Status Route(const api::RouteParameters &parameters, util::json::Object &result);
Status Table(const api::TableParameters &parameters, util::json::Object &result);
private: private:
struct EngineLock;
std::unique_ptr<EngineLock> lock; std::unique_ptr<EngineLock> lock;
std::unique_ptr<plugins::ViaRoutePlugin> route_plugin; std::unique_ptr<plugins::ViaRoutePlugin> route_plugin;
std::unique_ptr<plugins::DistanceTablePlugin> table_plugin;
std::unique_ptr<datafacade::BaseDataFacade> query_data_facade; std::unique_ptr<datafacade::BaseDataFacade> query_data_facade;
}; };
} }

168
include/engine/plugins/distance_table.hpp
View File

@ -3,8 +3,10 @@
#include "engine/plugins/plugin_base.hpp" #include "engine/plugins/plugin_base.hpp"
#include "engine/api/table_parameters.hpp"
#include "engine/object_encoder.hpp" #include "engine/object_encoder.hpp"
#include "engine/search_engine.hpp" #include "engine/routing_algorithms/many_to_many.hpp"
#include "engine/search_engine_data.hpp"
#include "util/make_unique.hpp" #include "util/make_unique.hpp"
#include "util/string_util.hpp" #include "util/string_util.hpp"
#include "osrm/json_container.hpp" #include "osrm/json_container.hpp"
@ -23,109 +25,57 @@ namespace engine
namespace plugins namespace plugins
{ {
template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin class DistanceTablePlugin final : public BasePlugin
{ {
private: private:
std::unique_ptr<SearchEngine<DataFacadeT>> search_engine_ptr; SearchEngineData heaps;
routing_algorithms::ManyToManyRouting<datafacade::BaseDataFacade> distance_table;
int max_locations_distance_table; int max_locations_distance_table;
public: public:
explicit DistanceTablePlugin(DataFacadeT *facade, const int max_locations_distance_table) explicit DistanceTablePlugin(datafacade::BaseDataFacade *facade,
: max_locations_distance_table(max_locations_distance_table), descriptor_string("table"), const int max_locations_distance_table)
facade(facade) : BasePlugin{*facade}, distance_table(facade, heaps),
max_locations_distance_table(max_locations_distance_table)
{ {
search_engine_ptr = util::make_unique<SearchEngine<DataFacadeT>>(facade);
} }
virtual ~DistanceTablePlugin() {} Status HandleRequest(const api::TableParameters &params, util::json::Object &result)
const std::string GetDescriptor() const override final { return descriptor_string; }
Status HandleRequest(const RouteParameters &route_parameters,
util::json::Object &json_result) override final
{ {
return NonConstHandleRequest(route_parameters, json_result); BOOST_ASSERT(params.IsValid());
}
// XXX: should be const-ref, but we need to artificially source, destination values if (!CheckAllCoordinates(params.coordinates))
// so consider this a hack for 4.9, in 5.0 we refactored and handle it beautifully! return Error("invalid-options", "Coordinates are invalid", result);
Status NonConstHandleRequest(RouteParameters route_parameters, util::json::Object &json_result)
{
if (!check_all_coordinates(route_parameters.coordinates))
{
json_result.values["status_message"] = "Coordinates are invalid";
return Status::Error;
}
const auto &input_bearings = route_parameters.bearings; if (params.bearings.size() > 0 && params.coordinates.size() != params.bearings.size())
if (input_bearings.size() > 0 && return Error("invalid-options", "Number of bearings does not match number of coordinates", result);
route_parameters.coordinates.size() != input_bearings.size())
{
json_result.values["status_message"] =
"Number of bearings does not match number of coordinates";
return Status::Error;
}
const auto number_of_coordinates = route_parameters.coordinates.size();
BOOST_ASSERT(route_parameters.is_source.size() <= number_of_coordinates);
BOOST_ASSERT(route_parameters.is_destination.size() <= number_of_coordinates);
// The check_all_coordinates guard above makes sure we have at least 2 coordinates.
// This establishes the parallel array invariant for is_source, is_destination, coordinates
if (route_parameters.is_source.size() == 0)
{
const auto where = route_parameters.is_source.end();
const auto n = number_of_coordinates - route_parameters.is_source.size();
route_parameters.is_source.insert(where, n, true);
}
if (route_parameters.is_destination.size() == 0)
{
const auto where = route_parameters.is_destination.end();
const auto n = number_of_coordinates - route_parameters.is_destination.size();
route_parameters.is_destination.insert(where, n, true);
}
// parallel array invariant
BOOST_ASSERT(route_parameters.coordinates.size() == route_parameters.is_source.size());
BOOST_ASSERT(route_parameters.coordinates.size() == route_parameters.is_destination.size());
const auto number_of_sources = std::count(route_parameters.is_source.begin(), //
route_parameters.is_source.end(), true);
const auto number_of_destination = std::count(route_parameters.is_destination.begin(), //
route_parameters.is_destination.end(), true);
if (max_locations_distance_table > 0 && if (max_locations_distance_table > 0 &&
(number_of_sources * number_of_destination > (params.sources.size() * params.destinations.size() >
max_locations_distance_table * max_locations_distance_table)) max_locations_distance_table * max_locations_distance_table))
{ return Error("invalid-options", "Number of entries " + std::to_string(params.sources.size() * params.destinations.size()) +
json_result.values["status_message"] =
"Number of entries " + std::to_string(number_of_sources * number_of_destination) +
" is higher than current maximum (" + " is higher than current maximum (" +
std::to_string(max_locations_distance_table * max_locations_distance_table) + ")"; std::to_string(max_locations_distance_table * max_locations_distance_table) + ")", result);
return Status::Error;
}
const bool checksum_OK = (route_parameters.check_sum == facade->GetCheckSum()); const bool checksum_OK = (params.check_sum == BasePlugin::facade.GetCheckSum());
std::vector<PhantomNodePair> phantom_node_source_vector(number_of_sources); std::vector<PhantomNodePair> phantom_node_source_vector(params.sources.size());
std::vector<PhantomNodePair> phantom_node_target_vector(number_of_destination); std::vector<PhantomNodePair> phantom_node_target_vector(params.destinations.size());
auto phantom_node_source_out_iter = phantom_node_source_vector.begin(); auto phantom_node_source_out_iter = phantom_node_source_vector.begin();
auto phantom_node_target_out_iter = phantom_node_target_vector.begin(); auto phantom_node_target_out_iter = phantom_node_target_vector.begin();
for (const auto i : util::irange<std::size_t>(0u, route_parameters.coordinates.size())) for (const auto i : util::irange<std::size_t>(0u, params.coordinates.size()))
{ {
if (checksum_OK && i < route_parameters.hints.size() && if (checksum_OK && i < params.hints.size() && !params.hints[i].empty())
!route_parameters.hints[i].empty())
{ {
auto current_phantom_node = decodeBase64<PhantomNode>(route_parameters.hints[i]); PhantomNode current_phantom_node;
if (current_phantom_node.IsValid(facade->GetNumberOfNodes())) ObjectEncoder::DecodeFromBase64(params.hints[i], current_phantom_node);
if (current_phantom_node.IsValid(BasePlugin::facade.GetNumberOfNodes()))
{ {
if (route_parameters.is_source[i]) if (params.is_source[i])
{ {
*phantom_node_source_out_iter = *phantom_node_source_out_iter =
std::make_pair(current_phantom_node, current_phantom_node); std::make_pair(current_phantom_node, current_phantom_node);
if (route_parameters.is_destination[i]) if (params.is_destination[i])
{ {
*phantom_node_target_out_iter = *phantom_node_source_out_iter; *phantom_node_target_out_iter = *phantom_node_source_out_iter;
phantom_node_target_out_iter++; phantom_node_target_out_iter++;
@ -134,8 +84,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
} }
else else
{ {
BOOST_ASSERT(route_parameters.is_destination[i] && BOOST_ASSERT(params.is_destination[i] && !params.is_source[i]);
!route_parameters.is_source[i]);
*phantom_node_target_out_iter = *phantom_node_target_out_iter =
std::make_pair(current_phantom_node, current_phantom_node); std::make_pair(current_phantom_node, current_phantom_node);
phantom_node_target_out_iter++; phantom_node_target_out_iter++;
@ -143,26 +92,26 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
continue; continue;
} }
} }
const int bearing = input_bearings.size() > 0 ? input_bearings[i].first : 0; const int bearing = params.bearings.size() > 0 ? params.bearings[i].first : 0;
const int range = input_bearings.size() > 0 const int range = params.bearings.size() > 0
? (input_bearings[i].second ? *input_bearings[i].second : 10) ? (params.bearings[i].second ? *param_bearings[i].second : 10)
: 180; : 180;
if (params.is_source[i])
if (route_parameters.is_source[i])
{ {
*phantom_node_source_out_iter = *phantom_node_source_out_iter =
facade->NearestPhantomNodeWithAlternativeFromBigComponent( BasePlugin::facade.NearestPhantomNodeWithAlternativeFromBigComponent(
route_parameters.coordinates[i], bearing, range); params.coordinates[i], bearing, range);
// we didn't found a fitting node, return error // we didn't found a fitting node, return error
if (!phantom_node_source_out_iter->first.IsValid(facade->GetNumberOfNodes())) if (!phantom_node_source_out_iter->first.IsValid(
BasePlugin::facade.GetNumberOfNodes()))
{ {
json_result.values["status_message"] = result.values["status_message"] =
std::string("Could not find a matching segment for coordinate ") + std::string("Could not find a matching segment for coordinate ") +
std::to_string(i); std::to_string(i);
return Status::NoSegment; return Status::NoSegment;
} }
if (route_parameters.is_destination[i]) if (params.is_destination[i])
{ {
*phantom_node_target_out_iter = *phantom_node_source_out_iter; *phantom_node_target_out_iter = *phantom_node_source_out_iter;
phantom_node_target_out_iter++; phantom_node_target_out_iter++;
@ -171,15 +120,16 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
} }
else else
{ {
BOOST_ASSERT(route_parameters.is_destination[i] && !route_parameters.is_source[i]); BOOST_ASSERT(params.is_destination[i] && !params.is_source[i]);
*phantom_node_target_out_iter = *phantom_node_target_out_iter =
facade->NearestPhantomNodeWithAlternativeFromBigComponent( BasePlugin::facade.NearestPhantomNodeWithAlternativeFromBigComponent(
route_parameters.coordinates[i], bearing, range); params.coordinates[i], bearing, range);
// we didn't found a fitting node, return error // we didn't found a fitting node, return error
if (!phantom_node_target_out_iter->first.IsValid(facade->GetNumberOfNodes())) if (!phantom_node_target_out_iter->first.IsValid(
BasePlugin::facade.GetNumberOfNodes()))
{ {
json_result.values["status_message"] = result.values["status_message"] =
std::string("Could not find a matching segment for coordinate ") + std::string("Could not find a matching segment for coordinate ") +
std::to_string(i); std::to_string(i);
return Status::NoSegment; return Status::NoSegment;
@ -189,34 +139,34 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
} }
BOOST_ASSERT((phantom_node_source_out_iter - phantom_node_source_vector.begin()) == BOOST_ASSERT((phantom_node_source_out_iter - phantom_node_source_vector.begin()) ==
number_of_sources); params.sources.size());
BOOST_ASSERT((phantom_node_target_out_iter - phantom_node_target_vector.begin()) == BOOST_ASSERT((phantom_node_target_out_iter - phantom_node_target_vector.begin()) ==
number_of_destination); params.destinations.size());
// FIXME we should clear phantom_node_source_vector and phantom_node_target_vector after // FIXME we should clear phantom_node_source_vector and phantom_node_target_vector after
// this // this
auto snapped_source_phantoms = snapPhantomNodes(phantom_node_source_vector); auto snapped_source_phantoms = snapPhantomNodes(phantom_node_source_vector);
auto snapped_target_phantoms = snapPhantomNodes(phantom_node_target_vector); auto snapped_target_phantoms = snapPhantomNodes(phantom_node_target_vector);
auto result_table = auto result_table = distance_table(snapped_source_phantoms, snapped_target_phantoms);
search_engine_ptr->distance_table(snapped_source_phantoms, snapped_target_phantoms);
if (!result_table) if (!result_table)
{ {
json_result.values["status_message"] = "No distance table found"; result.values["status_message"] = "No distance table found";
return Status::EmptyResult; return Status::EmptyResult;
} }
util::json::Array matrix_json_array; util::json::Array matrix_json_array;
for (const auto row : util::irange<std::size_t>(0, number_of_sources)) for (const auto row : util::irange<std::size_t>(0, params.sources.size()))
{ {
util::json::Array json_row; util::json::Array json_row;
auto row_begin_iterator = result_table->begin() + (row * number_of_destination); auto row_begin_iterator = result_table->begin() + (row * params.destinations.size());
auto row_end_iterator = result_table->begin() + ((row + 1) * number_of_destination); auto row_end_iterator =
result_table->begin() + ((row + 1) * params.destinations.size());
json_row.values.insert(json_row.values.end(), row_begin_iterator, row_end_iterator); json_row.values.insert(json_row.values.end(), row_begin_iterator, row_end_iterator);
matrix_json_array.values.push_back(json_row); matrix_json_array.values.push_back(json_row);
} }
json_result.values["distance_table"] = std::move(matrix_json_array); result.values["distance_table"] = matrix_json_array;
util::json::Array target_coord_json_array; util::json::Array target_coord_json_array;
for (const auto &phantom : snapped_target_phantoms) for (const auto &phantom : snapped_target_phantoms)
@ -226,7 +176,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
json_coord.values.push_back(phantom.location.lon / COORDINATE_PRECISION); json_coord.values.push_back(phantom.location.lon / COORDINATE_PRECISION);
target_coord_json_array.values.push_back(json_coord); target_coord_json_array.values.push_back(json_coord);
} }
json_result.values["destination_coordinates"] = std::move(target_coord_json_array); result.values["destination_coordinates"] = target_coord_json_array;
util::json::Array source_coord_json_array; util::json::Array source_coord_json_array;
for (const auto &phantom : snapped_source_phantoms) for (const auto &phantom : snapped_source_phantoms)
{ {
@ -235,13 +185,9 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
json_coord.values.push_back(phantom.location.lon / COORDINATE_PRECISION); json_coord.values.push_back(phantom.location.lon / COORDINATE_PRECISION);
source_coord_json_array.values.push_back(json_coord); source_coord_json_array.values.push_back(json_coord);
} }
json_result.values["source_coordinates"] = std::move(source_coord_json_array); result.values["source_coordinates"] = source_coord_json_array;
return Status::Ok; return Status::Ok;
} }
private:
std::string descriptor_string;
DataFacadeT *facade;
}; };
} }
} }

2
include/engine/routing_algorithms/many_to_many.hpp
View File

@ -44,8 +44,6 @@ class ManyToManyRouting final
{ {
} }
~ManyToManyRouting() {}
std::shared_ptr<std::vector<EdgeWeight>> std::shared_ptr<std::vector<EdgeWeight>>
operator()(const std::vector<PhantomNode> &phantom_sources_array, operator()(const std::vector<PhantomNode> &phantom_sources_array,
const std::vector<PhantomNode> &phantom_targets_array) const const std::vector<PhantomNode> &phantom_targets_array) const

18
include/osrm/osrm.hpp
View File

@ -49,24 +49,30 @@ struct EngineConfig;
namespace api namespace api
{ {
struct RouteParameters; struct RouteParameters;
struct TableParameters;
} }
} }
using engine::EngineConfig; using engine::EngineConfig;
using engine::api::RouteParameters; using engine::api::RouteParameters;
using engine::api::TableParameters;
namespace json = util::json; namespace json = util::json;
class OSRM class OSRM
{ {
public:
explicit OSRM(EngineConfig &config);
~OSRM();
OSRM(OSRM &&) noexcept;
OSRM &operator=(OSRM &&) noexcept;
Status Route(const RouteParameters &parameters, json::Object &result);
Status Table(const TableParameters &parameters, json::Object &result);
private: private:
std::unique_ptr<engine::Engine> engine_; std::unique_ptr<engine::Engine> engine_;
public:
OSRM(EngineConfig &lib_config);
~OSRM(); // needed for unique_ptr + impl abstraction
Status Route(const RouteParameters &route_parameters, json::Object &json_result);
}; };
} }
#endif // OSRM_HPP #endif // OSRM_HPP

122
src/engine/engine.cpp
View File

@ -3,7 +3,7 @@
#include "engine/api/route_parameters.hpp" #include "engine/api/route_parameters.hpp"
#include "engine/status.hpp" #include "engine/status.hpp"
//#include "engine/plugins/distance_table.hpp" #include "engine/plugins/distance_table.hpp"
//#include "engine/plugins/hello_world.hpp" //#include "engine/plugins/hello_world.hpp"
//#include "engine/plugins/nearest.hpp" //#include "engine/plugins/nearest.hpp"
//#include "engine/plugins/timestamp.hpp" //#include "engine/plugins/timestamp.hpp"
@ -35,59 +35,15 @@ namespace osrm
{ {
namespace engine namespace engine
{ {
struct Engine::EngineLock
// Abstracted away the query locking into a template function
// Works the same for every plugin.
template<typename ParameterT, typename PluginT>
Status RunQuery(const std::unique_ptr<Engine::EngineLock> &lock,
datafacade::BaseDataFacade &facade,
const ParameterT &parameters,
PluginT &plugin,
util::json::Object &json_result)
{ {
if (!lock) // will only be initialized if shared memory is used
{ storage::SharedBarriers barrier;
return plugin.HandleRequest(parameters, json_result); // decrease number of concurrent queries
} void DecreaseQueryCount();
// increase number of concurrent queries
BOOST_ASSERT(lock); void IncreaseQueryCount();
lock->IncreaseQueryCount(); };
auto& shared_facade = static_cast<datafacade::SharedDataFacade &>(facade);
shared_facade.CheckAndReloadFacade();
// Get a shared data lock so that other threads won't update
// things while the query is running
boost::shared_lock<boost::shared_mutex> data_lock{shared_facade.data_mutex};
Status status = plugin.HandleRequest(parameters, json_result);
lock->DecreaseQueryCount();
return status;
}
Engine::Engine(EngineConfig &config)
{
if (config.use_shared_memory)
{
lock = util::make_unique<EngineLock>();
query_data_facade = util::make_unique<datafacade::SharedDataFacade>();
}
else
{
// populate base path
util::populate_base_path(config.server_paths);
query_data_facade = util::make_unique<datafacade::InternalDataFacade>(config.server_paths);
}
route_plugin = util::make_unique<plugins::ViaRoutePlugin>(*query_data_facade, config.max_locations_viaroute);
}
Status Engine::Route(const api::RouteParameters &route_parameters,
util::json::Object &result)
{
return RunQuery(lock, *query_data_facade, route_parameters, *route_plugin, result);
}
// decrease number of concurrent queries // decrease number of concurrent queries
void Engine::EngineLock::DecreaseQueryCount() void Engine::EngineLock::DecreaseQueryCount()
@ -124,5 +80,65 @@ void Engine::EngineLock::IncreaseQueryCount()
// increment query count // increment query count
++(barrier.number_of_queries); ++(barrier.number_of_queries);
} }
} // ns engine
} // ns osrm
namespace
{
// Abstracted away the query locking into a template function
// Works the same for every plugin.
template <typename ParameterT, typename PluginT>
osrm::engine::Status RunQuery(const std::unique_ptr<osrm::engine::Engine::EngineLock> &lock,
osrm::engine::datafacade::BaseDataFacade &facade,
const ParameterT &parameters,
PluginT &plugin,
osrm::util::json::Object &json_result)
{
if (!lock)
{
return plugin.HandleRequest(parameters, json_result);
} }
BOOST_ASSERT(lock);
lock->IncreaseQueryCount();
auto &shared_facade = static_cast<osrm::engine::datafacade::SharedDataFacade &>(facade);
shared_facade.CheckAndReloadFacade();
// Get a shared data lock so that other threads won't update
// things while the query is running
boost::shared_lock<boost::shared_mutex> data_lock{shared_facade.data_mutex};
osrm::engine::Status status = plugin.HandleRequest(parameters, json_result);
lock->DecreaseQueryCount();
return status;
} }
} // anon. ns
namespace osrm
{
namespace engine
{
Engine::Engine(EngineConfig &config)
{
if (config.use_shared_memory)
{
lock = util::make_unique<EngineLock>();
query_data_facade = util::make_unique<datafacade::SharedDataFacade>();
}
else
{
util::populate_base_path(config.server_paths);
query_data_facade = util::make_unique<datafacade::InternalDataFacade>(config.server_paths);
}
route_plugin = util::make_unique<plugins::ViaRoutePlugin>(*query_data_facade,
config.max_locations_viaroute);
}
Status Engine::Route(const api::RouteParameters &route_parameters, util::json::Object &result)
{
return RunQuery(lock, *query_data_facade, route_parameters, *route_plugin, result);
}
} // engine ns
} // osrm ns

24
src/osrm/osrm.cpp
View File

@ -1,23 +1,31 @@
#include "osrm/osrm.hpp" #include "osrm/osrm.hpp"
#include "engine/api/route_parameters.hpp"
#include "engine/api/table_parameters.hpp"
#include "engine/engine.hpp" #include "engine/engine.hpp"
#include "engine/status.hpp" #include "engine/status.hpp"
#include "engine/engine_config.hpp" #include "engine/engine_config.hpp"
#include "engine/plugins/viaroute.hpp"
#include "storage/shared_barriers.hpp"
#include "util/make_unique.hpp" #include "util/make_unique.hpp"
namespace osrm namespace osrm
{ {
// proxy code for compilation firewall // Pimpl idiom
OSRM::OSRM(engine::EngineConfig &config_) : engine_(util::make_unique<engine::Engine>(config_)) {}
// needed because unique_ptr needs the size of OSRM_impl for delete OSRM::OSRM(engine::EngineConfig &config) : engine_(util::make_unique<engine::Engine>(config)) {}
OSRM::~OSRM() {} OSRM::~OSRM() = default;
OSRM::OSRM(OSRM &&) noexcept = default;
OSRM &OSRM::operator=(OSRM &&) noexcept = default;
engine::Status OSRM::Route(const RouteParameters &route_parameters, util::json::Object &json_result) // Forward to implementation
engine::Status OSRM::Route(const engine::api::RouteParameters &params, util::json::Object &result)
{ {
return engine_->Route(route_parameters, json_result); return engine_->Route(params, result);
} }
engine::Status OSRM::Table(const engine::api::TableParameters &params, json::Object &result)
{
return engine_->Table(params, result);
} }
} // ns osrm