diff --git a/CHANGELOG.md b/CHANGELOG.md index baee7fcf5..f524becbf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ - ADDED: data timestamp information in the response (saved in new file `.osrm.timestamp`). [#5115](https://github.com/Project-OSRM/osrm-backend/issues/5115) - ADDED: new API parameter - `snapping=any|default` to allow snapping to previously unsnappable edges [#5361](https://github.com/Project-OSRM/osrm-backend/pull/5361) - ADDED: keepalive support to the osrm-routed HTTP server [#5518](https://github.com/Project-OSRM/osrm-backend/pull/5518) + - ADDED: flatbuffers output format support [#5513](https://github.com/Project-OSRM/osrm-backend/pull/5513) - Routing: - CHANGED: allow routing past `barrier=arch` [#5352](https://github.com/Project-OSRM/osrm-backend/pull/5352) - CHANGED: default car weight was reduced to 2000 kg. [#5371](https://github.com/Project-OSRM/osrm-backend/pull/5371) diff --git a/example/example.cpp b/example/example.cpp index 162e629e3..108fc622e 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -57,7 +57,7 @@ int main(int argc, const char *argv[]) // Execute routing request, this does the heavy lifting const auto status = osrm.Route(params, result); - auto& json_result=result.get(); + auto &json_result = result.get(); if (status == Status::Ok) { auto &routes = json_result.values["routes"].get(); diff --git a/include/engine/api/base_api.hpp b/include/engine/api/base_api.hpp index b5ad0e121..b57477daf 100644 --- a/include/engine/api/base_api.hpp +++ b/include/engine/api/base_api.hpp @@ -72,32 +72,42 @@ class BaseAPI } } - flatbuffers::Offset>> MakeWaypoints(flatbuffers::FlatBufferBuilder& builder, const std::vector &segment_end_coordinates) const + flatbuffers::Offset>> + MakeWaypoints(flatbuffers::FlatBufferBuilder &builder, + const std::vector &segment_end_coordinates) const { BOOST_ASSERT(parameters.coordinates.size() > 0); BOOST_ASSERT(parameters.coordinates.size() == segment_end_coordinates.size() + 1); std::vector> waypoints; waypoints.resize(parameters.coordinates.size()); - waypoints[0] = MakeWaypoint(builder, segment_end_coordinates.front().source_phantom).Finish(); + waypoints[0] = + MakeWaypoint(builder, segment_end_coordinates.front().source_phantom).Finish(); - std::transform(segment_end_coordinates.begin(), segment_end_coordinates.end(), std::next(waypoints.begin()), [this, &builder](const PhantomNodes &phantom_pair) { - return MakeWaypoint(builder, phantom_pair.target_phantom).Finish(); - }); + std::transform(segment_end_coordinates.begin(), + segment_end_coordinates.end(), + std::next(waypoints.begin()), + [this, &builder](const PhantomNodes &phantom_pair) { + return MakeWaypoint(builder, phantom_pair.target_phantom).Finish(); + }); return builder.CreateVector(waypoints); } // FIXME: gcc 4.9 does not like MakeWaypoints to be protected // protected: - fbresult::WaypointBuilder MakeWaypoint(flatbuffers::FlatBufferBuilder& builder, const PhantomNode &phantom) const + fbresult::WaypointBuilder MakeWaypoint(flatbuffers::FlatBufferBuilder &builder, + const PhantomNode &phantom) const { - auto location = fbresult::Position(static_cast(util::toFloating(phantom.location.lon)), static_cast(util::toFloating(phantom.location.lat))); + auto location = + fbresult::Position(static_cast(util::toFloating(phantom.location.lon)), + static_cast(util::toFloating(phantom.location.lat))); fbresult::WaypointBuilder waypoint(builder); waypoint.add_location(&location); - waypoint.add_distance(util::coordinate_calculation::fccApproximateDistance(phantom.location, - phantom.input_location)); - auto name_string = builder.CreateString(facade.GetNameForID(facade.GetNameIndex(phantom.forward_segment_id.id)).to_string()); + waypoint.add_distance(util::coordinate_calculation::fccApproximateDistance( + phantom.location, phantom.input_location)); + auto name_string = builder.CreateString( + facade.GetNameForID(facade.GetNameIndex(phantom.forward_segment_id.id)).to_string()); waypoint.add_name(name_string); if (parameters.generate_hints) { diff --git a/include/engine/api/base_result.hpp b/include/engine/api/base_result.hpp index 8ca858526..65dd6aeeb 100644 --- a/include/engine/api/base_result.hpp +++ b/include/engine/api/base_result.hpp @@ -14,7 +14,8 @@ namespace engine { namespace api { - using ResultT = mapbox::util::variant; +using ResultT = + mapbox::util::variant; } // ns api } // ns engine } // ns osrm diff --git a/include/engine/api/match_api.hpp b/include/engine/api/match_api.hpp index 8f1328239..f2110ada1 100644 --- a/include/engine/api/match_api.hpp +++ b/include/engine/api/match_api.hpp @@ -34,10 +34,13 @@ class MatchAPI final : public RouteAPI osrm::engine::api::ResultT &response) const { BOOST_ASSERT(sub_matchings.size() == sub_routes.size()); - if (response.is()) { + if (response.is()) + { auto &fb_result = response.get(); MakeResponse(sub_matchings, sub_routes, fb_result); - } else { + } + else + { auto &json_result = response.get(); MakeResponse(sub_matchings, sub_routes, json_result); } @@ -46,7 +49,9 @@ class MatchAPI final : public RouteAPI const std::vector &sub_routes, flatbuffers::FlatBufferBuilder &fb_result) const { - auto response = MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_matchings]() { return MakeTracepoints(fb_result, sub_matchings); }); + auto response = MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_matchings]() { + return MakeTracepoints(fb_result, sub_matchings); + }); fb_result.Finish(response.Finish()); } @@ -79,7 +84,7 @@ class MatchAPI final : public RouteAPI { MatchingIndex() = default; MatchingIndex(unsigned sub_matching_index_, unsigned point_index_) - : sub_matching_index(sub_matching_index_), point_index(point_index_) + : sub_matching_index(sub_matching_index_), point_index(point_index_) { } @@ -94,7 +99,8 @@ class MatchAPI final : public RouteAPI }; flatbuffers::Offset>> - MakeTracepoints(flatbuffers::FlatBufferBuilder &fb_result, const std::vector &sub_matchings) const + MakeTracepoints(flatbuffers::FlatBufferBuilder &fb_result, + const std::vector &sub_matchings) const { std::vector> waypoints; waypoints.reserve(parameters.coordinates.size()); @@ -119,11 +125,11 @@ class MatchAPI final : public RouteAPI continue; } const auto &phantom = - sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index]; + sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index]; auto waypoint = BaseAPI::MakeWaypoint(fb_result, phantom); waypoint.add_matchings_index(matching_index.sub_matching_index); waypoint.add_alternatives_count(sub_matchings[matching_index.sub_matching_index] - .alternatives_count[matching_index.point_index]); + .alternatives_count[matching_index.point_index]); // waypoint indices need to be adjusted if route legs were collapsed // waypoint parameter assumes there is only one match object if (!parameters.waypoints.empty()) @@ -137,7 +143,9 @@ class MatchAPI final : public RouteAPI { waypoint.add_waypoint_index(0); } - } else { + } + else + { waypoint.add_waypoint_index(matching_index.point_index); } waypoints.push_back(waypoint.Finish()); @@ -198,20 +206,24 @@ class MatchAPI final : public RouteAPI return waypoints; } - std::vector MakeMatchingIndices(const std::vector &sub_matchings) const { + std::vector + MakeMatchingIndices(const std::vector &sub_matchings) const + { std::vector trace_idx_to_matching_idx(parameters.coordinates.size()); for (auto sub_matching_index : - util::irange(0u, static_cast(sub_matchings.size()))) { + util::irange(0u, static_cast(sub_matchings.size()))) + { for (auto point_index : util::irange( - 0u, static_cast(sub_matchings[sub_matching_index].indices.size()))) { + 0u, static_cast(sub_matchings[sub_matching_index].indices.size()))) + { // tidied_to_original: index of the input coordinate that a tidied coordinate // corresponds to. // sub_matching indices: index of the coordinate passed to map matching plugin that // a matched node corresponds to. trace_idx_to_matching_idx[tidy_result - .tidied_to_original[sub_matchings[sub_matching_index] - .indices[point_index]]] = - MatchingIndex{sub_matching_index, point_index}; + .tidied_to_original[sub_matchings[sub_matching_index] + .indices[point_index]]] = + MatchingIndex{sub_matching_index, point_index}; } } return trace_idx_to_matching_idx; diff --git a/include/engine/api/nearest_api.hpp b/include/engine/api/nearest_api.hpp index fff379065..88559097c 100644 --- a/include/engine/api/nearest_api.hpp +++ b/include/engine/api/nearest_api.hpp @@ -27,21 +27,21 @@ class NearestAPI final : public BaseAPI } void MakeResponse(const std::vector> &phantom_nodes, - osrm::engine::api::ResultT &response) const { + osrm::engine::api::ResultT &response) const + { BOOST_ASSERT(phantom_nodes.size() == 1); BOOST_ASSERT(parameters.coordinates.size() == 1); - if(response.is()) + if (response.is()) { - auto& fb_result = response.get(); + auto &fb_result = response.get(); MakeResponse(phantom_nodes, fb_result); } else { - auto& json_result = response.get(); + auto &json_result = response.get(); MakeResponse(phantom_nodes, json_result); } - } void MakeResponse(const std::vector> &phantom_nodes, @@ -51,49 +51,47 @@ class NearestAPI final : public BaseAPI std::vector> waypoints; waypoints.resize(phantom_nodes.front().size()); - std::transform( - phantom_nodes.front().begin(), - phantom_nodes.front().end(), - waypoints.begin(), - [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance) { - auto &phantom_node = phantom_with_distance.phantom_node; + std::transform(phantom_nodes.front().begin(), + phantom_nodes.front().end(), + waypoints.begin(), + [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance) { + auto &phantom_node = phantom_with_distance.phantom_node; - auto node_values = MakeNodes(phantom_node); - fbresult::Uint64Pair nodes{node_values.first, node_values.second}; + auto node_values = MakeNodes(phantom_node); + fbresult::Uint64Pair nodes{node_values.first, node_values.second}; - auto waypoint = MakeWaypoint(fb_result,phantom_node); - waypoint.add_nodes(&nodes); + auto waypoint = MakeWaypoint(fb_result, phantom_node); + waypoint.add_nodes(&nodes); - return waypoint.Finish(); - }); + return waypoint.Finish(); + }); auto waypoints_vector = fb_result.CreateVector(waypoints); response.add_waypoints(waypoints_vector); fb_result.Finish(response.Finish()); } - void MakeResponse(const std::vector> &phantom_nodes, + void MakeResponse(const std::vector> &phantom_nodes, util::json::Object &response) const { util::json::Array waypoints; waypoints.values.resize(phantom_nodes.front().size()); - std::transform( - phantom_nodes.front().begin(), - phantom_nodes.front().end(), - waypoints.values.begin(), - [this](const PhantomNodeWithDistance &phantom_with_distance) { - auto &phantom_node = phantom_with_distance.phantom_node; - auto waypoint = MakeWaypoint(phantom_node); + std::transform(phantom_nodes.front().begin(), + phantom_nodes.front().end(), + waypoints.values.begin(), + [this](const PhantomNodeWithDistance &phantom_with_distance) { + auto &phantom_node = phantom_with_distance.phantom_node; + auto waypoint = MakeWaypoint(phantom_node); - util::json::Array nodes; + util::json::Array nodes; - auto node_values = MakeNodes(phantom_node); + auto node_values = MakeNodes(phantom_node); - nodes.values.push_back(node_values.first); - nodes.values.push_back(node_values.second); - waypoint.values["nodes"] = std::move(nodes); + nodes.values.push_back(node_values.first); + nodes.values.push_back(node_values.second); + waypoint.values["nodes"] = std::move(nodes); - return waypoint; - }); + return waypoint; + }); response.values["code"] = "Ok"; response.values["waypoints"] = std::move(waypoints); @@ -101,8 +99,9 @@ class NearestAPI final : public BaseAPI const NearestParameters ¶meters; -protected: - std::pair MakeNodes(const PhantomNode& phantom_node) const { + protected: + std::pair MakeNodes(const PhantomNode &phantom_node) const + { std::uint64_t from_node = 0; std::uint64_t to_node = 0; @@ -113,8 +112,8 @@ protected: const auto geometry_id = facade.GetGeometryIndex(segment_id).id; forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id); - auto osm_node_id = facade.GetOSMNodeIDOfNode( - forward_geometry(phantom_node.fwd_segment_position)); + auto osm_node_id = + facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position)); to_node = static_cast(osm_node_id); } @@ -124,15 +123,14 @@ protected: const auto geometry_id = facade.GetGeometryIndex(segment_id).id; const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id); auto osm_node_id = - facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1)); + facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1)); from_node = static_cast(osm_node_id); } - else if (phantom_node.forward_segment_id.enabled && - phantom_node.fwd_segment_position > 0) + else if (phantom_node.forward_segment_id.enabled && phantom_node.fwd_segment_position > 0) { // In the case of one way, rely on forward segment only - auto osm_node_id = facade.GetOSMNodeIDOfNode( - forward_geometry(phantom_node.fwd_segment_position - 1)); + auto osm_node_id = + facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position - 1)); from_node = static_cast(osm_node_id); } diff --git a/include/engine/api/route_api.hpp b/include/engine/api/route_api.hpp index ca766f110..91dc01647 100644 --- a/include/engine/api/route_api.hpp +++ b/include/engine/api/route_api.hpp @@ -36,23 +36,29 @@ namespace engine namespace api { -class RouteAPI : public BaseAPI { -public: +class RouteAPI : public BaseAPI +{ + public: RouteAPI(const datafacade::BaseDataFacade &facade_, const RouteParameters ¶meters_) - : BaseAPI(facade_, parameters_), parameters(parameters_) { + : BaseAPI(facade_, parameters_), parameters(parameters_) + { } void MakeResponse(const InternalManyRoutesResult &raw_routes, const std::vector - &all_start_end_points, // all used coordinates, ignoring waypoints= parameter - osrm::engine::api::ResultT &response) const { + &all_start_end_points, // all used coordinates, ignoring waypoints= parameter + osrm::engine::api::ResultT &response) const + { BOOST_ASSERT(!raw_routes.routes.empty()); - if (response.is()) { + if (response.is()) + { auto &fb_result = response.get(); MakeResponse(raw_routes, all_start_end_points, fb_result); - } else { + } + else + { auto &json_result = response.get(); MakeResponse(raw_routes, all_start_end_points, json_result); } @@ -61,12 +67,13 @@ public: void MakeResponse(const InternalManyRoutesResult &raw_routes, const std::vector - &all_start_end_points, // all used coordinates, ignoring waypoints= parameter + &all_start_end_points, // all used coordinates, ignoring waypoints= parameter flatbuffers::FlatBufferBuilder &fb_result) const { - auto response = MakeFBResponse(raw_routes, fb_result, [this, &all_start_end_points, &fb_result]() { - return BaseAPI::MakeWaypoints(fb_result, all_start_end_points); - }); + auto response = + MakeFBResponse(raw_routes, fb_result, [this, &all_start_end_points, &fb_result]() { + return BaseAPI::MakeWaypoints(fb_result, all_start_end_points); + }); auto data_timestamp = facade.GetTimestamp(); if (!data_timestamp.empty()) @@ -109,10 +116,9 @@ public: protected: template - fbresult::FBResultBuilder - MakeFBResponse(const InternalManyRoutesResult &raw_routes, - flatbuffers::FlatBufferBuilder &fb_result, - GetWptsFn getWaypoints) const + fbresult::FBResultBuilder MakeFBResponse(const InternalManyRoutesResult &raw_routes, + flatbuffers::FlatBufferBuilder &fb_result, + GetWptsFn getWaypoints) const { fbresult::FBResultBuilder response(fb_result); @@ -140,37 +146,47 @@ public: template void MakeGeometry(BuilderType builder, ForwardIter begin, ForwardIter end) const { - if (parameters.geometries == RouteParameters::GeometriesType::Polyline) { + if (parameters.geometries == RouteParameters::GeometriesType::Polyline) + { auto polyline_string = builder.fbb_.CreateString(encodePolyline<100000>(begin, end)); builder.add_polyline(polyline_string); - } else if (parameters.geometries == RouteParameters::GeometriesType::Polyline6) { + } + else if (parameters.geometries == RouteParameters::GeometriesType::Polyline6) + { auto polyline_string = builder.fbb_.CreateString(encodePolyline<1000000>(begin, end)); builder.add_polyline(polyline_string); - } else { + } + else + { std::vector coordinates; coordinates.resize(std::distance(begin, end)); std::transform(begin, end, coordinates.begin(), [](const Coordinate &c) { return fbresult::Position{static_cast(util::toFloating(c.lon).__value), - static_cast(util::toFloating(c.lat).__value)}; + static_cast(util::toFloating(c.lat).__value)}; }); auto coordinates_vector = builder.fbb_.CreateVectorOfStructs(coordinates); builder.add_coordinates(coordinates_vector); } } - boost::optional MakeGeometry(boost::optional>&& annotations) const + boost::optional + MakeGeometry(boost::optional> &&annotations) const { boost::optional json_geometry; - if (annotations) { + if (annotations) + { auto begin = annotations->begin(); auto end = annotations->end(); if (parameters.geometries == RouteParameters::GeometriesType::Polyline) { json_geometry = json::makePolyline<100000>(begin, end); - } else if (parameters.geometries == RouteParameters::GeometriesType::Polyline6) + } + else if (parameters.geometries == RouteParameters::GeometriesType::Polyline6) { json_geometry = json::makePolyline<1000000>(begin, end); - } else { + } + else + { BOOST_ASSERT(parameters.geometries == RouteParameters::GeometriesType::GeoJSON); json_geometry = json::makeGeoJSONGeometry(begin, end); } @@ -179,7 +195,8 @@ public: } template - flatbuffers::Offset> GetAnnotations(flatbuffers::FlatBufferBuilder& fb_result, guidance::LegGeometry &leg, GetFn Get) const + flatbuffers::Offset> GetAnnotations( + flatbuffers::FlatBufferBuilder &fb_result, guidance::LegGeometry &leg, GetFn Get) const { std::vector annotations_store; annotations_store.reserve(leg.annotations.size()); @@ -206,76 +223,85 @@ public: return annotations_store; } - fbresult::ManeuverType WaypointTypeToFB(guidance::WaypointType type) const { - switch(type) { - case guidance::WaypointType::Arrive: - return fbresult::ManeuverType_Arrive; - case guidance::WaypointType::Depart: - return fbresult::ManeuverType_Depart; - default: - return fbresult::ManeuverType_Notification; + fbresult::ManeuverType WaypointTypeToFB(guidance::WaypointType type) const + { + switch (type) + { + case guidance::WaypointType::Arrive: + return fbresult::ManeuverType_Arrive; + case guidance::WaypointType::Depart: + return fbresult::ManeuverType_Depart; + default: + return fbresult::ManeuverType_Notification; } } - fbresult::ManeuverType TurnTypeToFB(osrm::guidance::TurnType::Enum turn) const { - static std::map mappings={ - {osrm::guidance::TurnType::Invalid, fbresult::ManeuverType_Notification}, - {osrm::guidance::TurnType::NewName, fbresult::ManeuverType_NewName}, - {osrm::guidance::TurnType::Continue, fbresult::ManeuverType_Continue}, - {osrm::guidance::TurnType::Turn, fbresult::ManeuverType_Turn}, - {osrm::guidance::TurnType::Merge, fbresult::ManeuverType_Merge}, - {osrm::guidance::TurnType::OnRamp, fbresult::ManeuverType_OnRamp}, - {osrm::guidance::TurnType::OffRamp, fbresult::ManeuverType_OffRamp}, - {osrm::guidance::TurnType::Fork, fbresult::ManeuverType_Fork}, - {osrm::guidance::TurnType::EndOfRoad, fbresult::ManeuverType_EndOfRoad}, - {osrm::guidance::TurnType::Notification, fbresult::ManeuverType_Notification}, - {osrm::guidance::TurnType::EnterRoundabout, fbresult::ManeuverType_Roundabout}, - {osrm::guidance::TurnType::EnterAndExitRoundabout, fbresult::ManeuverType_ExitRoundabout}, - {osrm::guidance::TurnType::EnterRotary, fbresult::ManeuverType_Rotary}, - {osrm::guidance::TurnType::EnterAndExitRotary, fbresult::ManeuverType_ExitRotary}, - {osrm::guidance::TurnType::EnterRoundaboutIntersection, fbresult::ManeuverType_Roundabout}, - {osrm::guidance::TurnType::EnterAndExitRoundaboutIntersection, fbresult::ManeuverType_ExitRoundabout}, - {osrm::guidance::TurnType::NoTurn, fbresult::ManeuverType_Notification}, - {osrm::guidance::TurnType::Suppressed, fbresult::ManeuverType_Notification}, - {osrm::guidance::TurnType::EnterRoundaboutAtExit, fbresult::ManeuverType_Roundabout}, - {osrm::guidance::TurnType::ExitRoundabout, fbresult::ManeuverType_ExitRoundabout}, - {osrm::guidance::TurnType::EnterRotaryAtExit, fbresult::ManeuverType_Rotary}, - {osrm::guidance::TurnType::ExitRotary, fbresult::ManeuverType_ExitRotary}, - {osrm::guidance::TurnType::EnterRoundaboutIntersectionAtExit, fbresult::ManeuverType_Roundabout}, - {osrm::guidance::TurnType::ExitRoundaboutIntersection, fbresult::ManeuverType_ExitRoundabout}, - {osrm::guidance::TurnType::StayOnRoundabout, fbresult::ManeuverType_RoundaboutTurn}, - {osrm::guidance::TurnType::Sliproad, fbresult::ManeuverType_Notification}, - {osrm::guidance::TurnType::MaxTurnType, fbresult::ManeuverType_Notification} - }; + fbresult::ManeuverType TurnTypeToFB(osrm::guidance::TurnType::Enum turn) const + { + static std::map mappings = { + {osrm::guidance::TurnType::Invalid, fbresult::ManeuverType_Notification}, + {osrm::guidance::TurnType::NewName, fbresult::ManeuverType_NewName}, + {osrm::guidance::TurnType::Continue, fbresult::ManeuverType_Continue}, + {osrm::guidance::TurnType::Turn, fbresult::ManeuverType_Turn}, + {osrm::guidance::TurnType::Merge, fbresult::ManeuverType_Merge}, + {osrm::guidance::TurnType::OnRamp, fbresult::ManeuverType_OnRamp}, + {osrm::guidance::TurnType::OffRamp, fbresult::ManeuverType_OffRamp}, + {osrm::guidance::TurnType::Fork, fbresult::ManeuverType_Fork}, + {osrm::guidance::TurnType::EndOfRoad, fbresult::ManeuverType_EndOfRoad}, + {osrm::guidance::TurnType::Notification, fbresult::ManeuverType_Notification}, + {osrm::guidance::TurnType::EnterRoundabout, fbresult::ManeuverType_Roundabout}, + {osrm::guidance::TurnType::EnterAndExitRoundabout, + fbresult::ManeuverType_ExitRoundabout}, + {osrm::guidance::TurnType::EnterRotary, fbresult::ManeuverType_Rotary}, + {osrm::guidance::TurnType::EnterAndExitRotary, fbresult::ManeuverType_ExitRotary}, + {osrm::guidance::TurnType::EnterRoundaboutIntersection, + fbresult::ManeuverType_Roundabout}, + {osrm::guidance::TurnType::EnterAndExitRoundaboutIntersection, + fbresult::ManeuverType_ExitRoundabout}, + {osrm::guidance::TurnType::NoTurn, fbresult::ManeuverType_Notification}, + {osrm::guidance::TurnType::Suppressed, fbresult::ManeuverType_Notification}, + {osrm::guidance::TurnType::EnterRoundaboutAtExit, fbresult::ManeuverType_Roundabout}, + {osrm::guidance::TurnType::ExitRoundabout, fbresult::ManeuverType_ExitRoundabout}, + {osrm::guidance::TurnType::EnterRotaryAtExit, fbresult::ManeuverType_Rotary}, + {osrm::guidance::TurnType::ExitRotary, fbresult::ManeuverType_ExitRotary}, + {osrm::guidance::TurnType::EnterRoundaboutIntersectionAtExit, + fbresult::ManeuverType_Roundabout}, + {osrm::guidance::TurnType::ExitRoundaboutIntersection, + fbresult::ManeuverType_ExitRoundabout}, + {osrm::guidance::TurnType::StayOnRoundabout, fbresult::ManeuverType_RoundaboutTurn}, + {osrm::guidance::TurnType::Sliproad, fbresult::ManeuverType_Notification}, + {osrm::guidance::TurnType::MaxTurnType, fbresult::ManeuverType_Notification}}; return mappings[turn]; } - fbresult::Turn TurnModifierToFB(osrm::guidance::DirectionModifier::Enum modifier) const { - static std::map mappings={ - {osrm::guidance::DirectionModifier::UTurn, fbresult::Turn_UTurn}, - {osrm::guidance::DirectionModifier::SharpRight, fbresult::Turn_SharpRight}, - {osrm::guidance::DirectionModifier::Right, fbresult::Turn_Right}, - {osrm::guidance::DirectionModifier::SlightRight, fbresult::Turn_SlightRight}, - {osrm::guidance::DirectionModifier::Straight, fbresult::Turn_Straight}, - {osrm::guidance::DirectionModifier::SlightLeft, fbresult::Turn_SlightLeft}, - {osrm::guidance::DirectionModifier::Left, fbresult::Turn_Left}, - {osrm::guidance::DirectionModifier::SharpLeft, fbresult::Turn_SharpLeft}, + fbresult::Turn TurnModifierToFB(osrm::guidance::DirectionModifier::Enum modifier) const + { + static std::map mappings = { + {osrm::guidance::DirectionModifier::UTurn, fbresult::Turn_UTurn}, + {osrm::guidance::DirectionModifier::SharpRight, fbresult::Turn_SharpRight}, + {osrm::guidance::DirectionModifier::Right, fbresult::Turn_Right}, + {osrm::guidance::DirectionModifier::SlightRight, fbresult::Turn_SlightRight}, + {osrm::guidance::DirectionModifier::Straight, fbresult::Turn_Straight}, + {osrm::guidance::DirectionModifier::SlightLeft, fbresult::Turn_SlightLeft}, + {osrm::guidance::DirectionModifier::Left, fbresult::Turn_Left}, + {osrm::guidance::DirectionModifier::SharpLeft, fbresult::Turn_SharpLeft}, }; return mappings[modifier]; } - std::vector TurnLaneTypeToFB(const extractor::TurnLaneType::Mask lane_type) const { + std::vector TurnLaneTypeToFB(const extractor::TurnLaneType::Mask lane_type) const + { const static fbresult::Turn mapping[] = {fbresult::Turn_None, - fbresult::Turn_Straight, - fbresult::Turn_SharpLeft, - fbresult::Turn_Left, - fbresult::Turn_SlightLeft, - fbresult::Turn_SlightRight, - fbresult::Turn_Right, - fbresult::Turn_SharpRight, - fbresult::Turn_UTurn, - fbresult::Turn_SlightLeft, - fbresult::Turn_SlightRight}; + fbresult::Turn_Straight, + fbresult::Turn_SharpLeft, + fbresult::Turn_Left, + fbresult::Turn_SlightLeft, + fbresult::Turn_SlightRight, + fbresult::Turn_Right, + fbresult::Turn_SharpRight, + fbresult::Turn_UTurn, + fbresult::Turn_SlightLeft, + fbresult::Turn_SlightRight}; std::vector result; std::bitset<8 * sizeof(extractor::TurnLaneType::Mask)> mask(lane_type); for (auto index : util::irange(0, extractor::TurnLaneType::NUM_TYPES)) @@ -286,22 +312,24 @@ public: } } return result; - } flatbuffers::Offset - MakeRoute(flatbuffers::FlatBufferBuilder &fb_result, - const std::vector &segment_end_coordinates, - const std::vector> &unpacked_path_segments, - const std::vector &source_traversed_in_reverse, - const std::vector &target_traversed_in_reverse) const + MakeRoute(flatbuffers::FlatBufferBuilder &fb_result, + const std::vector &segment_end_coordinates, + const std::vector> &unpacked_path_segments, + const std::vector &source_traversed_in_reverse, + const std::vector &target_traversed_in_reverse) const { fbresult::RouteObjectBuilder routeObject(fb_result); - auto legs_info = MakeLegs(segment_end_coordinates, unpacked_path_segments, source_traversed_in_reverse, target_traversed_in_reverse); + auto legs_info = MakeLegs(segment_end_coordinates, + unpacked_path_segments, + source_traversed_in_reverse, + target_traversed_in_reverse); std::vector legs = legs_info.first; std::vector leg_geometries = legs_info.second; - //Fill basix route info + // Fill basix route info auto route = guidance::assembleRoute(legs); routeObject.add_distance(route.distance); routeObject.add_duration(route.duration); @@ -309,137 +337,175 @@ public: auto weight_name_string = fb_result.CreateString(facade.GetWeightName()); routeObject.add_weight_name(weight_name_string); - //Fill legs + // Fill legs std::vector> routeLegs; routeLegs.reserve(legs.size()); - for (const auto idx : util::irange(0UL, legs.size())) { + for (const auto idx : util::irange(0UL, legs.size())) + { auto leg = legs[idx]; auto &leg_geometry = leg_geometries[idx]; fbresult::LegBuilder legBuilder(fb_result); legBuilder.add_distance(leg.distance); legBuilder.add_duration(leg.duration); legBuilder.add_weight(leg.weight); - if (!leg.summary.empty()) { + if (!leg.summary.empty()) + { auto summary_string = fb_result.CreateString(leg.summary); legBuilder.add_summary(summary_string); } - //Fill steps - if (!leg.steps.empty()) { + // Fill steps + if (!leg.steps.empty()) + { std::vector> legSteps; legSteps.resize(leg.steps.size()); - std::transform(leg.steps.begin(), leg.steps.end(), legSteps.begin(), [this, &leg_geometry, &fb_result](const guidance::RouteStep& step) { - fbresult::StepBuilder stepBuilder(fb_result); - stepBuilder.add_duration(step.duration); - stepBuilder.add_distance(step.distance); - stepBuilder.add_weight(step.weight); - auto name_string = fb_result.CreateString(step.name); - stepBuilder.add_name(name_string); - if (!step.ref.empty()) { - auto ref_string = fb_result.CreateString(step.ref); - stepBuilder.add_ref(ref_string); - } - if (!step.pronunciation.empty()) { - auto pronunciation_string = fb_result.CreateString(step.pronunciation); - stepBuilder.add_pronunciation(pronunciation_string); - } - if (!step.destinations.empty()) { - auto destinations_string = fb_result.CreateString(step.destinations); - stepBuilder.add_destinations(destinations_string); - } - if (!step.exits.empty()) { - auto exists_string = fb_result.CreateString(step.exits); - stepBuilder.add_exits(exists_string); - } - if(!step.rotary_name.empty()) { - auto rotary_name_string = fb_result.CreateString(step.rotary_name); - stepBuilder.add_rotary_name(rotary_name_string); - if (!step.rotary_pronunciation.empty()) { - auto rotary_pronunciation_string = fb_result.CreateString(step.rotary_pronunciation); - stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string); + std::transform( + leg.steps.begin(), + leg.steps.end(), + legSteps.begin(), + [this, &leg_geometry, &fb_result](const guidance::RouteStep &step) { + fbresult::StepBuilder stepBuilder(fb_result); + stepBuilder.add_duration(step.duration); + stepBuilder.add_distance(step.distance); + stepBuilder.add_weight(step.weight); + auto name_string = fb_result.CreateString(step.name); + stepBuilder.add_name(name_string); + if (!step.ref.empty()) + { + auto ref_string = fb_result.CreateString(step.ref); + stepBuilder.add_ref(ref_string); } - } - auto mode_string = fb_result.CreateString(extractor::travelModeToString(step.mode)); - stepBuilder.add_mode(mode_string); - stepBuilder.add_driving_side(step.is_left_hand_driving); - - //Geometry - MakeGeometry(stepBuilder, leg_geometry.locations.begin() + step.geometry_begin, leg_geometry.locations.begin() + step.geometry_end); - //Maneuver - fbresult::StepManeuverBuilder maneuver(fb_result); - fbresult::Position maneuverPosition{static_cast(util::toFloating(step.maneuver.location.lon).__value), - static_cast(util::toFloating(step.maneuver.location.lat).__value)}; - maneuver.add_location(&maneuverPosition); - maneuver.add_bearing_before(step.maneuver.bearing_before); - maneuver.add_bearing_after(step.maneuver.bearing_after); - if (step.maneuver.waypoint_type == guidance::WaypointType::None) - maneuver.add_type(TurnTypeToFB(step.maneuver.instruction.type)); - else - maneuver.add_type(WaypointTypeToFB(step.maneuver.waypoint_type)); - if (osrm::engine::api::json::detail::isValidModifier(step.maneuver)) { - maneuver.add_modifier(TurnModifierToFB(step.maneuver.instruction.direction_modifier)); - } - if (step.maneuver.exit != 0) { - maneuver.add_exit(step.maneuver.exit); - } - - //intersections - std::vector> intersections; - intersections.resize(step.intersections.size()); - std::transform(step.intersections.begin(), step.intersections.end(), intersections.begin(), [&fb_result, this](const guidance::IntermediateIntersection& intersection) { - fbresult::IntersectionBuilder intersectionBuilder(fb_result); - fbresult::Position maneuverPosition{static_cast(util::toFloating(intersection.location.lon).__value), - static_cast(util::toFloating(intersection.location.lat).__value)}; - intersectionBuilder.add_location(&maneuverPosition); - auto bearings_vector = fb_result.CreateVector(intersection.bearings); - intersectionBuilder.add_bearings(bearings_vector); - std::vector> classes; - classes.resize(intersection.classes.size()); - std::transform(intersection.classes.begin(), intersection.classes.end(), classes.begin(), [&fb_result](const std::string cls) { - return fb_result.CreateString(cls); - }); - auto classes_vector = fb_result.CreateVector(classes); - intersectionBuilder.add_classes(classes_vector); - auto entry_vector = fb_result.CreateVector(intersection.entry); - intersectionBuilder.add_entry(entry_vector); - intersectionBuilder.add_in(intersection.in); - intersectionBuilder.add_out(intersection.out); - if (api::json::detail::hasValidLanes(intersection)) { - BOOST_ASSERT(intersection.lanes.lanes_in_turn >= 1); - std::vector> lanes; - lanes.resize(intersection.lane_description.size()); - LaneID lane_id = intersection.lane_description.size(); - - for (const auto &lane_desc : intersection.lane_description) + if (!step.pronunciation.empty()) + { + auto pronunciation_string = fb_result.CreateString(step.pronunciation); + stepBuilder.add_pronunciation(pronunciation_string); + } + if (!step.destinations.empty()) + { + auto destinations_string = fb_result.CreateString(step.destinations); + stepBuilder.add_destinations(destinations_string); + } + if (!step.exits.empty()) + { + auto exists_string = fb_result.CreateString(step.exits); + stepBuilder.add_exits(exists_string); + } + if (!step.rotary_name.empty()) + { + auto rotary_name_string = fb_result.CreateString(step.rotary_name); + stepBuilder.add_rotary_name(rotary_name_string); + if (!step.rotary_pronunciation.empty()) { - --lane_id; - fbresult::LaneBuilder laneBuilder(fb_result); - auto indications_vector = fb_result.CreateVector(TurnLaneTypeToFB(lane_desc)); - laneBuilder.add_indications(indications_vector); - if (lane_id >= intersection.lanes.first_lane_from_the_right && - lane_id < - intersection.lanes.first_lane_from_the_right + intersection.lanes.lanes_in_turn) - laneBuilder.add_valid(true); - else - laneBuilder.add_valid(false); - - lanes.emplace_back(laneBuilder.Finish()); + auto rotary_pronunciation_string = + fb_result.CreateString(step.rotary_pronunciation); + stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string); } - auto lanes_vector = fb_result.CreateVector(lanes); - intersectionBuilder.add_lanes(lanes_vector); + } + auto mode_string = + fb_result.CreateString(extractor::travelModeToString(step.mode)); + stepBuilder.add_mode(mode_string); + stepBuilder.add_driving_side(step.is_left_hand_driving); + + // Geometry + MakeGeometry(stepBuilder, + leg_geometry.locations.begin() + step.geometry_begin, + leg_geometry.locations.begin() + step.geometry_end); + // Maneuver + fbresult::StepManeuverBuilder maneuver(fb_result); + fbresult::Position maneuverPosition{ + static_cast( + util::toFloating(step.maneuver.location.lon).__value), + static_cast( + util::toFloating(step.maneuver.location.lat).__value)}; + maneuver.add_location(&maneuverPosition); + maneuver.add_bearing_before(step.maneuver.bearing_before); + maneuver.add_bearing_after(step.maneuver.bearing_after); + if (step.maneuver.waypoint_type == guidance::WaypointType::None) + maneuver.add_type(TurnTypeToFB(step.maneuver.instruction.type)); + else + maneuver.add_type(WaypointTypeToFB(step.maneuver.waypoint_type)); + if (osrm::engine::api::json::detail::isValidModifier(step.maneuver)) + { + maneuver.add_modifier( + TurnModifierToFB(step.maneuver.instruction.direction_modifier)); + } + if (step.maneuver.exit != 0) + { + maneuver.add_exit(step.maneuver.exit); } - return intersectionBuilder.Finish(); + // intersections + std::vector> intersections; + intersections.resize(step.intersections.size()); + std::transform( + step.intersections.begin(), + step.intersections.end(), + intersections.begin(), + [&fb_result, + this](const guidance::IntermediateIntersection &intersection) { + fbresult::IntersectionBuilder intersectionBuilder(fb_result); + fbresult::Position maneuverPosition{ + static_cast( + util::toFloating(intersection.location.lon).__value), + static_cast( + util::toFloating(intersection.location.lat).__value)}; + intersectionBuilder.add_location(&maneuverPosition); + auto bearings_vector = + fb_result.CreateVector(intersection.bearings); + intersectionBuilder.add_bearings(bearings_vector); + std::vector> classes; + classes.resize(intersection.classes.size()); + std::transform(intersection.classes.begin(), + intersection.classes.end(), + classes.begin(), + [&fb_result](const std::string cls) { + return fb_result.CreateString(cls); + }); + auto classes_vector = fb_result.CreateVector(classes); + intersectionBuilder.add_classes(classes_vector); + auto entry_vector = fb_result.CreateVector(intersection.entry); + intersectionBuilder.add_entry(entry_vector); + intersectionBuilder.add_in(intersection.in); + intersectionBuilder.add_out(intersection.out); + if (api::json::detail::hasValidLanes(intersection)) + { + BOOST_ASSERT(intersection.lanes.lanes_in_turn >= 1); + std::vector> lanes; + lanes.resize(intersection.lane_description.size()); + LaneID lane_id = intersection.lane_description.size(); + + for (const auto &lane_desc : intersection.lane_description) + { + --lane_id; + fbresult::LaneBuilder laneBuilder(fb_result); + auto indications_vector = + fb_result.CreateVector(TurnLaneTypeToFB(lane_desc)); + laneBuilder.add_indications(indications_vector); + if (lane_id >= + intersection.lanes.first_lane_from_the_right && + lane_id < intersection.lanes.first_lane_from_the_right + + intersection.lanes.lanes_in_turn) + laneBuilder.add_valid(true); + else + laneBuilder.add_valid(false); + + lanes.emplace_back(laneBuilder.Finish()); + } + auto lanes_vector = fb_result.CreateVector(lanes); + intersectionBuilder.add_lanes(lanes_vector); + } + + return intersectionBuilder.Finish(); + }); + auto intersections_vector = fb_result.CreateVector(intersections); + stepBuilder.add_intersections(intersections_vector); + return stepBuilder.Finish(); }); - auto intersections_vector = fb_result.CreateVector(intersections); - stepBuilder.add_intersections(intersections_vector); - return stepBuilder.Finish(); - }); auto steps_vector = fb_result.CreateVector(legSteps); legBuilder.add_steps(steps_vector); } - //Fill annotations + // Fill annotations // To maintain support for uses of the old default constructors, we check // if annotations property was set manually after default construction auto requested_annotations = parameters.annotations_type; @@ -458,50 +524,53 @@ public: { double prev_speed = 0; auto speed = GetAnnotations( - fb_result, leg_geometry, [&prev_speed](const guidance::LegGeometry::Annotation &anno) { - if (anno.duration < std::numeric_limits::min()) - { - return prev_speed; - } - else - { - auto speed = std::round(anno.distance / anno.duration * 10.) / 10.; - prev_speed = speed; - return util::json::clamp_float(speed); - } - }); + fb_result, + leg_geometry, + [&prev_speed](const guidance::LegGeometry::Annotation &anno) { + if (anno.duration < std::numeric_limits::min()) + { + return prev_speed; + } + else + { + auto speed = std::round(anno.distance / anno.duration * 10.) / 10.; + prev_speed = speed; + return util::json::clamp_float(speed); + } + }); annotation.add_speed(speed); } if (requested_annotations & RouteParameters::AnnotationsType::Duration) { auto duration = GetAnnotations( - fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) { - return anno.duration; - }); + fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) { + return anno.duration; + }); annotation.add_duration(duration); } if (requested_annotations & RouteParameters::AnnotationsType::Distance) { auto distance = GetAnnotations( - fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) { - return anno.distance; - }); + fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) { + return anno.distance; + }); annotation.add_distance(distance); } if (requested_annotations & RouteParameters::AnnotationsType::Weight) { auto weight = GetAnnotations( - fb_result, leg_geometry, - [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; }); + fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) { + return anno.weight; + }); annotation.add_weight(weight); } if (requested_annotations & RouteParameters::AnnotationsType::Datasources) { auto datasources = GetAnnotations( - fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) { - return anno.datasource; - }); + fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) { + return anno.datasource; + }); annotation.add_datasources(datasources); } if (requested_annotations & RouteParameters::AnnotationsType::Nodes) @@ -527,7 +596,8 @@ public: // Length of 0 indicates the first empty name, so we can stop here if (name.size() == 0) break; - names.emplace_back(fb_result.CreateString(std::string(facade.GetDatasourceName(i)))); + names.emplace_back( + fb_result.CreateString(std::string(facade.GetDatasourceName(i)))); } auto datasource_names_vector = fb_result.CreateVector(names); metadata.add_datasource_names(datasource_names_vector); @@ -542,9 +612,10 @@ public: auto legs_vector = fb_result.CreateVector(routeLegs); routeObject.add_legs(legs_vector); - //Fill geometry + // Fill geometry auto overview = MakeOverview(leg_geometries); - if(overview) { + if (overview) + { MakeGeometry(routeObject, overview->begin(), overview->end()); } @@ -556,12 +627,16 @@ public: const std::vector &source_traversed_in_reverse, const std::vector &target_traversed_in_reverse) const { - auto legs_info = MakeLegs(segment_end_coordinates, unpacked_path_segments, source_traversed_in_reverse, target_traversed_in_reverse); + auto legs_info = MakeLegs(segment_end_coordinates, + unpacked_path_segments, + source_traversed_in_reverse, + target_traversed_in_reverse); std::vector legs = legs_info.first; std::vector leg_geometries = legs_info.second; auto route = guidance::assembleRoute(legs); - boost::optional json_overview = MakeGeometry(MakeOverview(leg_geometries)); + boost::optional json_overview = + MakeGeometry(MakeOverview(leg_geometries)); std::vector step_geometries; const auto total_step_count = @@ -712,10 +787,12 @@ public: MakeLegs(const std::vector &segment_end_coordinates, const std::vector> &unpacked_path_segments, const std::vector &source_traversed_in_reverse, - const std::vector &target_traversed_in_reverse) const { - auto result = std::make_pair(std::vector(), std::vector()); - auto& legs = result.first; - auto& leg_geometries = result.second; + const std::vector &target_traversed_in_reverse) const + { + auto result = + std::make_pair(std::vector(), std::vector()); + auto &legs = result.first; + auto &leg_geometries = result.second; auto number_of_legs = segment_end_coordinates.size(); legs.reserve(number_of_legs); leg_geometries.reserve(number_of_legs); @@ -811,12 +888,14 @@ public: return result; } - boost::optional> MakeOverview(const std::vector& leg_geometries) const { + boost::optional> + MakeOverview(const std::vector &leg_geometries) const + { boost::optional> overview; if (parameters.overview != RouteParameters::OverviewType::False) { const auto use_simplification = - parameters.overview == RouteParameters::OverviewType::Simplified; + parameters.overview == RouteParameters::OverviewType::Simplified; BOOST_ASSERT(use_simplification || parameters.overview == RouteParameters::OverviewType::Full); diff --git a/include/engine/api/table_api.hpp b/include/engine/api/table_api.hpp index 3efa2afe3..d87954a18 100644 --- a/include/engine/api/table_api.hpp +++ b/include/engine/api/table_api.hpp @@ -51,13 +51,14 @@ class TableAPI final : public BaseAPI const std::vector &fallback_speed_cells, osrm::engine::api::ResultT &response) const { - if(response.is()) { - auto& fb_result = response.get(); + if (response.is()) + { + auto &fb_result = response.get(); MakeResponse(tables, phantoms, fallback_speed_cells, fb_result); } else { - auto& json_result = response.get(); + auto &json_result = response.get(); MakeResponse(tables, phantoms, fallback_speed_cells, json_result); } } @@ -66,7 +67,8 @@ class TableAPI final : public BaseAPI MakeResponse(const std::pair, std::vector> &tables, const std::vector &phantoms, const std::vector &fallback_speed_cells, - flatbuffers::FlatBufferBuilder &fb_result) const { + flatbuffers::FlatBufferBuilder &fb_result) const + { auto number_of_sources = parameters.sources.size(); auto number_of_destinations = parameters.destinations.size(); @@ -169,21 +171,22 @@ class TableAPI final : public BaseAPI protected: virtual flatbuffers::Offset>> - MakeWaypoints(flatbuffers::FlatBufferBuilder& builder, const std::vector &phantoms) const + MakeWaypoints(flatbuffers::FlatBufferBuilder &builder, + const std::vector &phantoms) const { std::vector> waypoints; waypoints.reserve(phantoms.size()); BOOST_ASSERT(phantoms.size() == parameters.coordinates.size()); boost::range::transform( - phantoms, - std::back_inserter(waypoints), - [this, &builder](const PhantomNode &phantom) { return BaseAPI::MakeWaypoint(builder, phantom).Finish(); }); + phantoms, std::back_inserter(waypoints), [this, &builder](const PhantomNode &phantom) { + return BaseAPI::MakeWaypoint(builder, phantom).Finish(); + }); return builder.CreateVector(waypoints); } virtual flatbuffers::Offset>> - MakeWaypoints(flatbuffers::FlatBufferBuilder& builder, + MakeWaypoints(flatbuffers::FlatBufferBuilder &builder, const std::vector &phantoms, const std::vector &indices) const { @@ -199,49 +202,53 @@ class TableAPI final : public BaseAPI } virtual flatbuffers::Offset> - MakeDurationTable(flatbuffers::FlatBufferBuilder& builder, + MakeDurationTable(flatbuffers::FlatBufferBuilder &builder, const std::vector &values) const { std::vector distance_table; distance_table.resize(values.size()); - std::transform(values.begin(), values.end(), distance_table.begin(), [](const EdgeWeight duration) { - if (duration == MAXIMAL_EDGE_DURATION) { - return 0.; - } - return duration / 10.; - }); + std::transform( + values.begin(), values.end(), distance_table.begin(), [](const EdgeWeight duration) { + if (duration == MAXIMAL_EDGE_DURATION) + { + return 0.; + } + return duration / 10.; + }); return builder.CreateVector(distance_table); } virtual flatbuffers::Offset> - MakeDistanceTable(flatbuffers::FlatBufferBuilder& builder, + MakeDistanceTable(flatbuffers::FlatBufferBuilder &builder, const std::vector &values) const { std::vector duration_table; duration_table.resize(values.size()); - std::transform(values.begin(), values.end(), duration_table.begin(), [](const EdgeDistance distance) { - if (distance == INVALID_EDGE_DISTANCE) { - return 0.; - } - return std::round(distance * 10) / 10.; - }); + std::transform( + values.begin(), values.end(), duration_table.begin(), [](const EdgeDistance distance) { + if (distance == INVALID_EDGE_DISTANCE) + { + return 0.; + } + return std::round(distance * 10) / 10.; + }); return builder.CreateVector(duration_table); } virtual flatbuffers::Offset> - MakeEstimatesTable(flatbuffers::FlatBufferBuilder& builder, const std::vector &fallback_speed_cells) const + MakeEstimatesTable(flatbuffers::FlatBufferBuilder &builder, + const std::vector &fallback_speed_cells) const { std::vector fb_table; fb_table.reserve(fallback_speed_cells.size()); std::for_each( - fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) { - fb_table.push_back(cell.row); - fb_table.push_back(cell.column); - }); + fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) { + fb_table.push_back(cell.row); + fb_table.push_back(cell.column); + }); return builder.CreateVector(fb_table); } - virtual util::json::Array MakeWaypoints(const std::vector &phantoms) const { util::json::Array json_waypoints; diff --git a/include/engine/api/trip_api.hpp b/include/engine/api/trip_api.hpp index ed3f0bf3b..90cc395b9 100644 --- a/include/engine/api/trip_api.hpp +++ b/include/engine/api/trip_api.hpp @@ -31,21 +31,26 @@ class TripAPI final : public RouteAPI { BOOST_ASSERT(sub_trips.size() == sub_routes.size()); - if (response.is()) { + if (response.is()) + { auto &fb_result = response.get(); MakeResponse(sub_trips, sub_routes, phantoms, fb_result); - } else { + } + else + { auto &json_result = response.get(); MakeResponse(sub_trips, sub_routes, phantoms, json_result); } - } void MakeResponse(const std::vector> &sub_trips, const std::vector &sub_routes, const std::vector &phantoms, flatbuffers::FlatBufferBuilder &fb_result) const { - auto response = MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_trips, &phantoms]() { return MakeWaypoints(fb_result, sub_trips, phantoms); }); + auto response = + MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_trips, &phantoms]() { + return MakeWaypoints(fb_result, sub_trips, phantoms); + }); fb_result.Finish(response.Finish()); } @@ -74,25 +79,29 @@ class TripAPI final : public RouteAPI // FIXME this logic is a little backwards. We should change the output format of the // trip plugin routing algorithm to be easier to consume here. - struct TripIndex { + struct TripIndex + { TripIndex() = default; TripIndex(unsigned sub_trip_index_, unsigned point_index_) - : sub_trip_index(sub_trip_index_), point_index(point_index_) { + : sub_trip_index(sub_trip_index_), point_index(point_index_) + { } unsigned sub_trip_index = std::numeric_limits::max(); unsigned point_index = std::numeric_limits::max(); - bool NotUsed() { + bool NotUsed() + { return sub_trip_index == std::numeric_limits::max() && point_index == std::numeric_limits::max(); } }; - flatbuffers::Offset>> MakeWaypoints(flatbuffers::FlatBufferBuilder &fb_result, - const std::vector> &sub_trips, - const std::vector &phantoms) const + flatbuffers::Offset>> + MakeWaypoints(flatbuffers::FlatBufferBuilder &fb_result, + const std::vector> &sub_trips, + const std::vector &phantoms) const { std::vector> waypoints; waypoints.reserve(parameters.coordinates.size()); @@ -135,13 +144,15 @@ class TripAPI final : public RouteAPI return waypoints; } - std::vector - MakeTripIndices(const std::vector> &sub_trips) const { + std::vector MakeTripIndices(const std::vector> &sub_trips) const + { std::vector input_idx_to_trip_idx(parameters.coordinates.size()); - for (auto sub_trip_index : util::irange(0u, sub_trips.size())) { - for (auto point_index : util::irange(0u, sub_trips[sub_trip_index].size())) { + for (auto sub_trip_index : util::irange(0u, sub_trips.size())) + { + for (auto point_index : util::irange(0u, sub_trips[sub_trip_index].size())) + { input_idx_to_trip_idx[sub_trips[sub_trip_index][point_index]] = - TripIndex{sub_trip_index, point_index}; + TripIndex{sub_trip_index, point_index}; } } return input_idx_to_trip_idx; diff --git a/include/engine/engine.hpp b/include/engine/engine.hpp index 3d0f9b3a6..d7b533970 100644 --- a/include/engine/engine.hpp +++ b/include/engine/engine.hpp @@ -32,18 +32,13 @@ class EngineInterface { public: virtual ~EngineInterface() = default; - virtual Status Route(const api::RouteParameters ¶meters, - api::ResultT &result) const = 0; - virtual Status Table(const api::TableParameters ¶meters, - api::ResultT &result) const = 0; + virtual Status Route(const api::RouteParameters ¶meters, api::ResultT &result) const = 0; + virtual Status Table(const api::TableParameters ¶meters, api::ResultT &result) const = 0; virtual Status Nearest(const api::NearestParameters ¶meters, api::ResultT &result) const = 0; - virtual Status Trip(const api::TripParameters ¶meters, - api::ResultT &result) const = 0; - virtual Status Match(const api::MatchParameters ¶meters, - api::ResultT &result) const = 0; - virtual Status Tile(const api::TileParameters ¶meters, - api::ResultT &result) const = 0; + virtual Status Trip(const api::TripParameters ¶meters, api::ResultT &result) const = 0; + virtual Status Match(const api::MatchParameters ¶meters, api::ResultT &result) const = 0; + virtual Status Tile(const api::TileParameters ¶meters, api::ResultT &result) const = 0; }; template class Engine final : public EngineInterface @@ -90,38 +85,32 @@ template class Engine final : public EngineInterface Engine &operator=(const Engine &) = delete; virtual ~Engine() = default; - Status Route(const api::RouteParameters ¶ms, - api::ResultT &result) const override final + Status Route(const api::RouteParameters ¶ms, api::ResultT &result) const override final { return route_plugin.HandleRequest(GetAlgorithms(params), params, result); } - Status Table(const api::TableParameters ¶ms, - api::ResultT &result) const override final + Status Table(const api::TableParameters ¶ms, api::ResultT &result) const override final { return table_plugin.HandleRequest(GetAlgorithms(params), params, result); } - Status Nearest(const api::NearestParameters ¶ms, - api::ResultT &result) const override final + Status Nearest(const api::NearestParameters ¶ms, api::ResultT &result) const override final { return nearest_plugin.HandleRequest(GetAlgorithms(params), params, result); } - Status Trip(const api::TripParameters ¶ms, - api::ResultT &result) const override final + Status Trip(const api::TripParameters ¶ms, api::ResultT &result) const override final { return trip_plugin.HandleRequest(GetAlgorithms(params), params, result); } - Status Match(const api::MatchParameters ¶ms, - api::ResultT &result) const override final + Status Match(const api::MatchParameters ¶ms, api::ResultT &result) const override final { return match_plugin.HandleRequest(GetAlgorithms(params), params, result); } - Status Tile(const api::TileParameters ¶ms, - api::ResultT &result) const override final + Status Tile(const api::TileParameters ¶ms, api::ResultT &result) const override final { return tile_plugin.HandleRequest(GetAlgorithms(params), params, result); } diff --git a/include/engine/plugins/plugin_base.hpp b/include/engine/plugins/plugin_base.hpp index 8d9289a8d..a42d82807 100644 --- a/include/engine/plugins/plugin_base.hpp +++ b/include/engine/plugins/plugin_base.hpp @@ -64,17 +64,21 @@ class BasePlugin return false; } - struct ErrorRenderer { + struct ErrorRenderer + { std::string code; std::string message; - ErrorRenderer(std::string code, std::string message) : code(std::move(code)), message(std::move(message)) {}; + ErrorRenderer(std::string code, std::string message) + : code(std::move(code)), message(std::move(message)){}; - void operator()(util::json::Object& json_result) { + void operator()(util::json::Object &json_result) + { json_result.values["code"] = code; json_result.values["message"] = message; }; - void operator()(flatbuffers::FlatBufferBuilder& fb_result) { + void operator()(flatbuffers::FlatBufferBuilder &fb_result) + { api::fbresult::FBResultBuilder error(fb_result); error.add_error(true); @@ -84,7 +88,8 @@ class BasePlugin error.add_code(codeBuilder.Finish()); fb_result.Finish(error.Finish()); }; - void operator()(std::string& str_result) { + void operator()(std::string &str_result) + { str_result = str(boost::format("code=%1% message=%2%") % code % message); }; }; diff --git a/include/osrm/osrm.hpp b/include/osrm/osrm.hpp index af3b7f248..74c73f7dd 100644 --- a/include/osrm/osrm.hpp +++ b/include/osrm/osrm.hpp @@ -28,9 +28,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef OSRM_HPP #define OSRM_HPP +#include "engine/api/base_result.hpp" #include "osrm/osrm_fwd.hpp" #include "osrm/status.hpp" -#include "engine/api/base_result.hpp" #include #include diff --git a/include/server/api/base_parameters_grammar.hpp b/include/server/api/base_parameters_grammar.hpp index c7fc2e091..dc196ae2b 100644 --- a/include/server/api/base_parameters_grammar.hpp +++ b/include/server/api/base_parameters_grammar.hpp @@ -169,10 +169,11 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar qi::lit("snapping=") > snapping_type[ph::bind(&engine::api::BaseParameters::snapping, qi::_r1) = qi::_1]; - format_type.add(".json", engine::api::BaseParameters::OutputFormatType::JSON) - (".flatbuffers", engine::api::BaseParameters::OutputFormatType::FLATBUFFERS); + format_type.add(".json", engine::api::BaseParameters::OutputFormatType::JSON)( + ".flatbuffers", engine::api::BaseParameters::OutputFormatType::FLATBUFFERS); - format_rule = -format_type[ph::bind(&engine::api::BaseParameters::format, qi::_r1) = qi::_1]; + format_rule = + -format_type[ph::bind(&engine::api::BaseParameters::format, qi::_r1) = qi::_1]; exclude_rule = qi::lit("exclude=") > (qi::as_string[+qi::char_("a-zA-Z0-9")] % diff --git a/include/server/service/match_service.hpp b/include/server/service/match_service.hpp index 139b690e4..1c3e51226 100644 --- a/include/server/service/match_service.hpp +++ b/include/server/service/match_service.hpp @@ -22,8 +22,9 @@ class MatchService final : public BaseService public: MatchService(OSRM &routing_machine) : BaseService(routing_machine) {} - engine::Status - RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) final override; + engine::Status RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) final override; unsigned GetVersion() final override { return 1; } }; diff --git a/include/server/service/nearest_service.hpp b/include/server/service/nearest_service.hpp index a75381cf1..454ec710b 100644 --- a/include/server/service/nearest_service.hpp +++ b/include/server/service/nearest_service.hpp @@ -22,8 +22,9 @@ class NearestService final : public BaseService public: NearestService(OSRM &routing_machine) : BaseService(routing_machine) {} - engine::Status - RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) final override; + engine::Status RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) final override; unsigned GetVersion() final override { return 1; } }; diff --git a/include/server/service/route_service.hpp b/include/server/service/route_service.hpp index c51386a7e..12dbe0916 100644 --- a/include/server/service/route_service.hpp +++ b/include/server/service/route_service.hpp @@ -22,8 +22,9 @@ class RouteService final : public BaseService public: RouteService(OSRM &routing_machine) : BaseService(routing_machine) {} - engine::Status - RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) final override; + engine::Status RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) final override; unsigned GetVersion() final override { return 1; } }; diff --git a/include/server/service/table_service.hpp b/include/server/service/table_service.hpp index 2610d6de1..76f4c32fa 100644 --- a/include/server/service/table_service.hpp +++ b/include/server/service/table_service.hpp @@ -22,8 +22,9 @@ class TableService final : public BaseService public: TableService(OSRM &routing_machine) : BaseService(routing_machine) {} - engine::Status - RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) final override; + engine::Status RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) final override; unsigned GetVersion() final override { return 1; } }; diff --git a/include/server/service/tile_service.hpp b/include/server/service/tile_service.hpp index 74339fa84..5efd2a9b2 100644 --- a/include/server/service/tile_service.hpp +++ b/include/server/service/tile_service.hpp @@ -22,8 +22,9 @@ class TileService final : public BaseService public: TileService(OSRM &routing_machine) : BaseService(routing_machine) {} - engine::Status - RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) final override; + engine::Status RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) final override; unsigned GetVersion() final override { return 1; } }; diff --git a/include/server/service/trip_service.hpp b/include/server/service/trip_service.hpp index fbd668fc8..a86657dad 100644 --- a/include/server/service/trip_service.hpp +++ b/include/server/service/trip_service.hpp @@ -22,8 +22,9 @@ class TripService final : public BaseService public: TripService(OSRM &routing_machine) : BaseService(routing_machine) {} - engine::Status - RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) final override; + engine::Status RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) final override; unsigned GetVersion() final override { return 1; } }; diff --git a/include/server/service_handler.hpp b/include/server/service_handler.hpp index 00a514925..150174982 100644 --- a/include/server/service_handler.hpp +++ b/include/server/service_handler.hpp @@ -3,8 +3,8 @@ #include "server/service/base_service.hpp" -#include "osrm/osrm.hpp" #include "engine/api/base_api.hpp" +#include "osrm/osrm.hpp" #include diff --git a/src/benchmarks/match.cpp b/src/benchmarks/match.cpp index 91d96b016..7c1b3608b 100644 --- a/src/benchmarks/match.cpp +++ b/src/benchmarks/match.cpp @@ -216,8 +216,9 @@ int main(int argc, const char *argv[]) try { engine::api::ResultT result = json::Object(); const auto rc = osrm.Match(params, result); - auto& json_result=result.get(); - if (rc != Status::Ok || json_result.values.at("matchings").get().values.size() != 1) + auto &json_result = result.get(); + if (rc != Status::Ok || + json_result.values.at("matchings").get().values.size() != 1) { return EXIT_FAILURE; } diff --git a/src/engine/plugins/match.cpp b/src/engine/plugins/match.cpp index b64deeff0..5650b6609 100644 --- a/src/engine/plugins/match.cpp +++ b/src/engine/plugins/match.cpp @@ -158,8 +158,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms, if (!time_increases_monotonically) { - return Error( - "InvalidValue", "Timestamps need to be monotonically increasing.", result); + return Error("InvalidValue", "Timestamps need to be monotonically increasing.", result); } SubMatchingList sub_matchings; @@ -180,9 +179,8 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms, (tidied.parameters.waypoints[0] != 0 || tidied.parameters.waypoints.back() != (tidied.parameters.coordinates.size() - 1))) { - return Error("InvalidValue", - "First and last coordinates must be specified as waypoints.", - result); + return Error( + "InvalidValue", "First and last coordinates must be specified as waypoints.", result); } // assuming radius is the standard deviation of a normal distribution @@ -260,8 +258,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms, } if (!tidied_waypoints.empty()) { - return Error( - "NoMatch", "Requested waypoint parameter could not be matched.", result); + return Error("NoMatch", "Requested waypoint parameter could not be matched.", result); } } // we haven't errored yet, only allow leg collapsing if it was originally requested diff --git a/src/engine/plugins/tile.cpp b/src/engine/plugins/tile.cpp index 825d749f6..9a46f1d0c 100644 --- a/src/engine/plugins/tile.cpp +++ b/src/engine/plugins/tile.cpp @@ -669,7 +669,7 @@ Status TilePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms, { BOOST_ASSERT(parameters.IsValid()); - auto& pbf_buffer = result.get(); + auto &pbf_buffer = result.get(); const auto &facade = algorithms.GetFacade(); auto edges = getEdges(facade, parameters.x, parameters.y, parameters.z); auto segregated_nodes = getSegregatedNodes(facade, edges); diff --git a/src/engine/plugins/viaroute.cpp b/src/engine/plugins/viaroute.cpp index 379ac6d46..8c4e3e891 100644 --- a/src/engine/plugins/viaroute.cpp +++ b/src/engine/plugins/viaroute.cpp @@ -78,9 +78,8 @@ Status ViaRoutePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithm (route_parameters.waypoints[0] != 0 || route_parameters.waypoints.back() != (route_parameters.coordinates.size() - 1))) { - return Error("InvalidValue", - "First and last coordinates must be specified as waypoints.", - result); + return Error( + "InvalidValue", "First and last coordinates must be specified as waypoints.", result); } if (!CheckAlgorithms(route_parameters, algorithms, result)) diff --git a/src/nodejs/node_osrm.cpp b/src/nodejs/node_osrm.cpp index e3361c437..c5ca5c9c1 100644 --- a/src/nodejs/node_osrm.cpp +++ b/src/nodejs/node_osrm.cpp @@ -152,7 +152,7 @@ inline void async(const Nan::FunctionCallbackInfo &info, void Execute() override try { osrm::engine::api::ResultT r; - r=osrm::util::json::Object(); + r = osrm::util::json::Object(); const auto status = ((*osrm).*(service))(*params, r); auto json_result = r.get(); ParseResult(status, json_result); diff --git a/src/server/request_handler.cpp b/src/server/request_handler.cpp index 94668193b..3e7135bdf 100644 --- a/src/server/request_handler.cpp +++ b/src/server/request_handler.cpp @@ -110,15 +110,16 @@ void RequestHandler::HandleRequest(const http::request ¤t_request, http::r util::json::render(current_reply.content, result.get()); } - else if(result.is()) + else if (result.is()) { - auto& buffer = result.get(); + auto &buffer = result.get(); current_reply.content.resize(buffer.GetSize()); std::copy(buffer.GetBufferPointer(), buffer.GetBufferPointer() + buffer.GetSize(), current_reply.content.begin()); - current_reply.headers.emplace_back("Content-Type", "application/x-flatbuffers;schema=osrm.engine.api.fbresult"); + current_reply.headers.emplace_back( + "Content-Type", "application/x-flatbuffers;schema=osrm.engine.api.fbresult"); } else { diff --git a/src/server/service/match_service.cpp b/src/server/service/match_service.cpp index 3a5ea1753..aca391bf4 100644 --- a/src/server/service/match_service.cpp +++ b/src/server/service/match_service.cpp @@ -41,8 +41,9 @@ std::string getWrongOptionHelp(const engine::api::MatchParameters ¶meters) } } // anon. ns -engine::Status -MatchService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) +engine::Status MatchService::RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) { result = util::json::Object(); auto &json_result = result.get(); @@ -70,7 +71,8 @@ MatchService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engi if (parameters->format) { - if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) { + if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) + { result = flatbuffers::FlatBufferBuilder(); } } diff --git a/src/server/service/nearest_service.cpp b/src/server/service/nearest_service.cpp index 31ffeaba1..ca9811719 100644 --- a/src/server/service/nearest_service.cpp +++ b/src/server/service/nearest_service.cpp @@ -35,8 +35,9 @@ std::string getWrongOptionHelp(const engine::api::NearestParameters ¶meters) } } // anon. ns -engine::Status -NearestService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) +engine::Status NearestService::RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) { result = util::json::Object(); auto &json_result = result.get(); @@ -64,7 +65,8 @@ NearestService::RunQuery(std::size_t prefix_length, std::string &query, osrm::en if (parameters->format) { - if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) { + if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) + { result = flatbuffers::FlatBufferBuilder(); } } diff --git a/src/server/service/route_service.cpp b/src/server/service/route_service.cpp index a56164ffe..9459e7bbf 100644 --- a/src/server/service/route_service.cpp +++ b/src/server/service/route_service.cpp @@ -39,8 +39,9 @@ std::string getWrongOptionHelp(const engine::api::RouteParameters ¶meters) } } // anon. ns -engine::Status -RouteService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) +engine::Status RouteService::RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) { result = util::json::Object(); auto &json_result = result.get(); @@ -68,7 +69,8 @@ RouteService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engi if (parameters->format) { - if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) { + if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) + { result = flatbuffers::FlatBufferBuilder(); } } diff --git a/src/server/service/table_service.cpp b/src/server/service/table_service.cpp index 2eeb206c1..b2c1f6548 100644 --- a/src/server/service/table_service.cpp +++ b/src/server/service/table_service.cpp @@ -70,8 +70,9 @@ std::string getWrongOptionHelp(const engine::api::TableParameters ¶meters) } } // anon. ns -engine::Status -TableService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) +engine::Status TableService::RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) { result = util::json::Object(); auto &json_result = result.get(); @@ -99,7 +100,8 @@ TableService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engi if (parameters->format) { - if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) { + if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) + { result = flatbuffers::FlatBufferBuilder(); } } diff --git a/src/server/service/tile_service.cpp b/src/server/service/tile_service.cpp index c125bc38f..bdf7996d7 100644 --- a/src/server/service/tile_service.cpp +++ b/src/server/service/tile_service.cpp @@ -15,7 +15,9 @@ namespace server namespace service { -engine::Status TileService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) +engine::Status TileService::RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) { auto query_iterator = query.begin(); auto parameters = diff --git a/src/server/service/trip_service.cpp b/src/server/service/trip_service.cpp index 1ba8e1635..20af63c12 100644 --- a/src/server/service/trip_service.cpp +++ b/src/server/service/trip_service.cpp @@ -41,7 +41,9 @@ std::string getWrongOptionHelp(const engine::api::TripParameters ¶meters) } } // anon. ns -engine::Status TripService::RunQuery(std::size_t prefix_length, std::string &query, osrm::engine::api::ResultT &result) +engine::Status TripService::RunQuery(std::size_t prefix_length, + std::string &query, + osrm::engine::api::ResultT &result) { result = util::json::Object(); auto &json_result = result.get(); @@ -71,7 +73,8 @@ engine::Status TripService::RunQuery(std::size_t prefix_length, std::string &que if (parameters->format) { - if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) { + if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) + { result = flatbuffers::FlatBufferBuilder(); } } diff --git a/unit_tests/library/limits.cpp b/unit_tests/library/limits.cpp index 5b1816638..26e2efc7d 100644 --- a/unit_tests/library/limits.cpp +++ b/unit_tests/library/limits.cpp @@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(test_trip_limits) BOOST_CHECK(rc == Status::Error); // Make sure we're not accidentally hitting a guard code path before - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values["code"].get().value; BOOST_CHECK(code == "TooBig"); // per the New-Server API spec } @@ -74,7 +74,7 @@ BOOST_AUTO_TEST_CASE(test_route_limits) BOOST_CHECK(rc == Status::Error); // Make sure we're not accidentally hitting a guard code path before - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values["code"].get().value; BOOST_CHECK(code == "TooBig"); // per the New-Server API spec } @@ -102,7 +102,7 @@ BOOST_AUTO_TEST_CASE(test_table_limits) BOOST_CHECK(rc == Status::Error); // Make sure we're not accidentally hitting a guard code path before - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values["code"].get().value; BOOST_CHECK(code == "TooBig"); // per the New-Server API spec } @@ -130,7 +130,7 @@ BOOST_AUTO_TEST_CASE(test_match_coordinate_limits) BOOST_CHECK(rc == Status::Error); // Make sure we're not accidentally hitting a guard code path before - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values["code"].get().value; BOOST_CHECK(code == "TooBig"); // per the New-Server API spec } @@ -163,7 +163,7 @@ BOOST_AUTO_TEST_CASE(test_match_radiuses_limits) BOOST_CHECK(rc == Status::Error); // Make sure we're not accidentally hitting a guard code path before - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values["code"].get().value; BOOST_CHECK(code == "TooBig"); // per the New-Server API spec } @@ -190,7 +190,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_limits) BOOST_CHECK(rc == Status::Error); // Make sure we're not accidentally hitting a guard code path before - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values["code"].get().value; BOOST_CHECK(code == "TooBig"); // per the New-Server API spec } diff --git a/unit_tests/library/match.cpp b/unit_tests/library/match.cpp index b98947245..c7c3b1eae 100644 --- a/unit_tests/library/match.cpp +++ b/unit_tests/library/match.cpp @@ -30,7 +30,7 @@ BOOST_AUTO_TEST_CASE(test_match) const auto rc = osrm.Match(params, result); - auto& json_result=result.get(); + auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -79,7 +79,7 @@ BOOST_AUTO_TEST_CASE(test_match_split) const auto rc = osrm.Match(params, result); - auto& json_result=result.get(); + auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); diff --git a/unit_tests/library/nearest.cpp b/unit_tests/library/nearest.cpp index 4fd6451a1..24960a7f6 100644 --- a/unit_tests/library/nearest.cpp +++ b/unit_tests/library/nearest.cpp @@ -27,7 +27,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_response) const auto rc = osrm.Nearest(params, result); BOOST_REQUIRE(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -54,7 +54,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates) const auto rc = osrm.Nearest(params, result); BOOST_REQUIRE(rc == Status::Error); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "InvalidOptions"); } @@ -73,7 +73,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates) const auto rc = osrm.Nearest(params, result); BOOST_REQUIRE(rc == Status::Error); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "InvalidOptions"); } @@ -94,7 +94,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component) const auto rc = osrm.Nearest(params, result); BOOST_REQUIRE(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); diff --git a/unit_tests/library/route.cpp b/unit_tests/library/route.cpp index f61bcbc9d..4ce8e6a3c 100644 --- a/unit_tests/library/route.cpp +++ b/unit_tests/library/route.cpp @@ -32,7 +32,7 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); // unset snapping dependent hint for (auto &itr : json_result.values["waypoints"].get().values) { @@ -132,7 +132,7 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -286,7 +286,7 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -322,7 +322,7 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -360,7 +360,7 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -395,7 +395,7 @@ BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); for (auto waypoint : json_result.values["waypoints"].get().values) BOOST_CHECK_EQUAL(waypoint.get().values.count("hint"), 0); } @@ -417,7 +417,7 @@ BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto &routes = json_result.values["routes"].get().values; const auto &legs = routes[0].get().values.at("legs").get().values; const auto &annotation = @@ -458,7 +458,7 @@ BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property) const auto rc = osrm.Route(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); diff --git a/unit_tests/library/table.cpp b/unit_tests/library/table.cpp index fba6c5394..f463b32c9 100644 --- a/unit_tests/library/table.cpp +++ b/unit_tests/library/table.cpp @@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix) const auto rc = osrm.Table(params, result); - auto& json_result=result.get(); + auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -61,7 +61,8 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix) } // check destinations array of waypoint objects - const auto &destinations_array = json_result.values.at("destinations").get().values; + const auto &destinations_array = + json_result.values.at("destinations").get().values; BOOST_CHECK_EQUAL(destinations_array.size(), params.destinations.size()); for (const auto &destination : destinations_array) { @@ -91,7 +92,7 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix) const auto rc = osrm.Table(params, result); - auto& json_result=result.get(); + auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -108,7 +109,8 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix) params.sources.size() * params.coordinates.size()); } // check destinations array of waypoint objects - const auto &destinations_array = json_result.values.at("destinations").get().values; + const auto &destinations_array = + json_result.values.at("destinations").get().values; BOOST_CHECK_EQUAL(destinations_array.size(), params.coordinates.size()); for (const auto &destination : destinations_array) { @@ -139,7 +141,7 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix) const auto rc = osrm.Table(params, result); - auto& json_result=result.get(); + auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -154,7 +156,8 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix) BOOST_CHECK_EQUAL(durations_matrix[i].get().value, 0); BOOST_CHECK_EQUAL(durations_matrix.size(), params.coordinates.size()); } - const auto &destinations_array = json_result.values.at("destinations").get().values; + const auto &destinations_array = + json_result.values.at("destinations").get().values; for (const auto &destination : destinations_array) { BOOST_CHECK(waypoint_check(destination)); @@ -185,7 +188,7 @@ BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates) const auto rc = osrm.Table(params, result); - auto& json_result=result.get(); + auto &json_result = result.get(); BOOST_CHECK(rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "NoSegment"); diff --git a/unit_tests/library/tile.cpp b/unit_tests/library/tile.cpp index 1e9195bd2..eb453a272 100644 --- a/unit_tests/library/tile.cpp +++ b/unit_tests/library/tile.cpp @@ -166,7 +166,7 @@ void validate_tile(const osrm::OSRM &osrm) const auto rc = osrm.Tile(params, result); BOOST_CHECK(rc == Status::Ok); - auto& str_result = result.get(); + auto &str_result = result.get(); BOOST_CHECK(str_result.size() > 114000); vtzero::vector_tile tile{str_result}; @@ -212,7 +212,7 @@ void test_tile_turns(const osrm::OSRM &osrm) const auto rc = osrm.Tile(params, result); BOOST_CHECK(rc == Status::Ok); - auto& str_result = result.get(); + auto &str_result = result.get(); BOOST_CHECK_GT(str_result.size(), 128); vtzero::vector_tile tile{str_result}; @@ -354,7 +354,7 @@ void test_tile_speeds(const osrm::OSRM &osrm) const auto rc = osrm.Tile(params, result); BOOST_CHECK(rc == Status::Ok); - auto& str_result = result.get(); + auto &str_result = result.get(); BOOST_CHECK_GT(str_result.size(), 128); vtzero::vector_tile tile{str_result}; @@ -435,7 +435,7 @@ void test_tile_nodes(const osrm::OSRM &osrm) const auto rc = osrm.Tile(params, result); BOOST_CHECK(rc == Status::Ok); - auto& str_result = result.get(); + auto &str_result = result.get(); BOOST_CHECK_GT(str_result.size(), 128); vtzero::vector_tile tile{str_result}; diff --git a/unit_tests/library/trip.cpp b/unit_tests/library/trip.cpp index 789acc495..bfe1108c5 100644 --- a/unit_tests/library/trip.cpp +++ b/unit_tests/library/trip.cpp @@ -30,7 +30,7 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component) const auto rc = osrm.Trip(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -73,7 +73,7 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component) const auto rc = osrm.Trip(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -118,7 +118,7 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components) const auto rc = osrm.Trip(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -167,7 +167,7 @@ BOOST_AUTO_TEST_CASE(test_tfse_1) const auto rc = osrm.Trip(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -214,7 +214,7 @@ BOOST_AUTO_TEST_CASE(test_tfse_2) const auto rc = osrm.Trip(params, result); BOOST_CHECK(rc == Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -254,7 +254,7 @@ void CheckNotImplemented(const osrm::OSRM &osrm, osrm::TripParameters ¶ms) engine::api::ResultT result = json::Object(); auto rc = osrm.Trip(params, result); BOOST_REQUIRE(rc == osrm::Status::Error); - auto& json_result=result.get(); + auto &json_result = result.get(); auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "NotImplemented"); } @@ -265,7 +265,7 @@ void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters ¶ms) engine::api::ResultT result = json::Object(); auto rc = osrm.Trip(params, result); BOOST_REQUIRE(rc == osrm::Status::Ok); - auto& json_result=result.get(); + auto &json_result = result.get(); auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); }