diff --git a/include/engine/api/base_parameters.hpp b/include/engine/api/base_parameters.hpp index 3335a994f..ce8a6094c 100644 --- a/include/engine/api/base_parameters.hpp +++ b/include/engine/api/base_parameters.hpp @@ -28,9 +28,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ENGINE_API_BASE_PARAMETERS_HPP #define ENGINE_API_BASE_PARAMETERS_HPP +#include "engine/approach.hpp" #include "engine/bearing.hpp" #include "engine/hint.hpp" -#include "engine/approach.hpp" #include "util/coordinate.hpp" #include diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp index c33b73e0e..017b71b8b 100644 --- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp +++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp @@ -6,8 +6,8 @@ #include "engine/datafacade/datafacade_base.hpp" #include "engine/algorithm.hpp" -#include "engine/geospatial_query.hpp" #include "engine/approach.hpp" +#include "engine/geospatial_query.hpp" #include "customizer/edge_based_graph.hpp" @@ -656,7 +656,8 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade { BOOST_ASSERT(m_geospatial_query.get()); - return m_geospatial_query->NearestPhantomNodesInRange(input_coordinate, max_distance, approach); + return m_geospatial_query->NearestPhantomNodesInRange( + input_coordinate, max_distance, approach); } std::vector @@ -690,7 +691,8 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade { BOOST_ASSERT(m_geospatial_query.get()); - return m_geospatial_query->NearestPhantomNodes(input_coordinate, max_results, max_distance, approach); + return m_geospatial_query->NearestPhantomNodes( + input_coordinate, max_results, max_distance, approach); } std::vector @@ -720,9 +722,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade input_coordinate, max_results, max_distance, bearing, bearing_range, approach); } - std::pair - NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate, - const engine::Approach approach) const override final + std::pair NearestPhantomNodeWithAlternativeFromBigComponent( + const util::Coordinate input_coordinate, + const engine::Approach approach) const override final { BOOST_ASSERT(m_geospatial_query.get()); @@ -731,7 +733,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade } std::pair NearestPhantomNodeWithAlternativeFromBigComponent( - const util::Coordinate input_coordinate, const double max_distance, const engine::Approach approach) const override final + const util::Coordinate input_coordinate, + const double max_distance, + const engine::Approach approach) const override final { BOOST_ASSERT(m_geospatial_query.get()); @@ -739,12 +743,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade input_coordinate, max_distance, approach); } - std::pair - NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate, - const double max_distance, - const int bearing, - const int bearing_range, - const engine::Approach approach) const override final + std::pair NearestPhantomNodeWithAlternativeFromBigComponent( + const util::Coordinate input_coordinate, + const double max_distance, + const int bearing, + const int bearing_range, + const engine::Approach approach) const override final { BOOST_ASSERT(m_geospatial_query.get()); @@ -752,11 +756,11 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade input_coordinate, max_distance, bearing, bearing_range, approach); } - std::pair - NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate, - const int bearing, - const int bearing_range, - const engine::Approach approach) const override final + std::pair NearestPhantomNodeWithAlternativeFromBigComponent( + const util::Coordinate input_coordinate, + const int bearing, + const int bearing_range, + const engine::Approach approach) const override final { BOOST_ASSERT(m_geospatial_query.get()); @@ -894,7 +898,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade bool IsLeftHandDriving() const override final { - return m_profile_properties->left_hand_driving; + return m_profile_properties->left_hand_driving; } }; diff --git a/include/engine/datafacade/datafacade_base.hpp b/include/engine/datafacade/datafacade_base.hpp index b8056a9ba..0d9a9e903 100644 --- a/include/engine/datafacade/datafacade_base.hpp +++ b/include/engine/datafacade/datafacade_base.hpp @@ -9,8 +9,8 @@ #include "extractor/guidance/turn_instruction.hpp" #include "extractor/guidance/turn_lane_types.hpp" #include "extractor/original_edge_data.hpp" -#include "engine/phantom_node.hpp" #include "engine/approach.hpp" +#include "engine/phantom_node.hpp" #include "util/exception.hpp" #include "util/guidance/bearing_class.hpp" #include "util/guidance/entry_class.hpp" diff --git a/include/engine/geospatial_query.hpp b/include/engine/geospatial_query.hpp index 6b7d27522..c807a1893 100644 --- a/include/engine/geospatial_query.hpp +++ b/include/engine/geospatial_query.hpp @@ -1,8 +1,8 @@ #ifndef GEOSPATIAL_QUERY_HPP #define GEOSPATIAL_QUERY_HPP -#include "engine/phantom_node.hpp" #include "engine/approach.hpp" +#include "engine/phantom_node.hpp" #include "util/bearing.hpp" #include "util/coordinate_calculation.hpp" #include "util/rectangle.hpp" @@ -56,15 +56,16 @@ template class GeospatialQuery const double max_distance, const engine::Approach approach) const { - auto results = - rtree.Nearest(input_coordinate, - [this, approach, &input_coordinate](const CandidateSegment &segment) { - return boolPairAnd(HasValidEdge(segment), approach_usage(input_coordinate, segment, approach)); - }, - [this, max_distance, input_coordinate](const std::size_t, - const CandidateSegment &segment) { - return CheckSegmentDistance(input_coordinate, segment, max_distance); - }); + auto results = rtree.Nearest( + input_coordinate, + [this, approach, &input_coordinate](const CandidateSegment &segment) { + return boolPairAnd(HasValidEdge(segment), + approach_usage(input_coordinate, segment, approach)); + }, + [this, max_distance, input_coordinate](const std::size_t, + const CandidateSegment &segment) { + return CheckSegmentDistance(input_coordinate, segment, max_distance); + }); return MakePhantomNodes(input_coordinate, results); } @@ -80,11 +81,12 @@ template class GeospatialQuery { auto results = rtree.Nearest( input_coordinate, - [this, approach, &input_coordinate, bearing, bearing_range, max_distance](const CandidateSegment &segment) { - auto use_direction = boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range), - HasValidEdge(segment)); - use_direction = boolPairAnd(use_direction, - approach_usage(input_coordinate, segment, approach)); + [this, approach, &input_coordinate, bearing, bearing_range, max_distance]( + const CandidateSegment &segment) { + auto use_direction = boolPairAnd( + CheckSegmentBearing(segment, bearing, bearing_range), HasValidEdge(segment)); + use_direction = + boolPairAnd(use_direction, approach_usage(input_coordinate, segment, approach)); return use_direction; }, [this, max_distance, input_coordinate](const std::size_t, @@ -106,10 +108,12 @@ template class GeospatialQuery { auto results = rtree.Nearest( input_coordinate, - [this, approach, &input_coordinate, bearing, bearing_range](const CandidateSegment &segment) { - auto use_direction = boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range), - HasValidEdge(segment)); - return boolPairAnd(use_direction, approach_usage(input_coordinate, segment, approach)); + [this, approach, &input_coordinate, bearing, bearing_range]( + const CandidateSegment &segment) { + auto use_direction = boolPairAnd( + CheckSegmentBearing(segment, bearing, bearing_range), HasValidEdge(segment)); + return boolPairAnd(use_direction, + approach_usage(input_coordinate, segment, approach)); }, [max_results](const std::size_t num_results, const CandidateSegment &) { return num_results >= max_results; @@ -131,10 +135,12 @@ template class GeospatialQuery { auto results = rtree.Nearest( input_coordinate, - [this, approach, &input_coordinate, bearing, bearing_range](const CandidateSegment &segment) { - auto use_direction = boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range), - HasValidEdge(segment)); - return boolPairAnd(use_direction, approach_usage(input_coordinate, segment, approach)); + [this, approach, &input_coordinate, bearing, bearing_range]( + const CandidateSegment &segment) { + auto use_direction = boolPairAnd( + CheckSegmentBearing(segment, bearing, bearing_range), HasValidEdge(segment)); + return boolPairAnd(use_direction, + approach_usage(input_coordinate, segment, approach)); }, [this, max_distance, max_results, input_coordinate](const std::size_t num_results, const CandidateSegment &segment) { @@ -152,14 +158,15 @@ template class GeospatialQuery const unsigned max_results, const engine::Approach approach) const { - auto results = - rtree.Nearest(input_coordinate, - [this, approach, &input_coordinate](const CandidateSegment &segment) { - return boolPairAnd(HasValidEdge(segment), approach_usage(input_coordinate, segment, approach)); - }, - [max_results](const std::size_t num_results, const CandidateSegment &) { - return num_results >= max_results; - }); + auto results = rtree.Nearest( + input_coordinate, + [this, approach, &input_coordinate](const CandidateSegment &segment) { + return boolPairAnd(HasValidEdge(segment), + approach_usage(input_coordinate, segment, approach)); + }, + [max_results](const std::size_t num_results, const CandidateSegment &) { + return num_results >= max_results; + }); return MakePhantomNodes(input_coordinate, results); } @@ -172,16 +179,17 @@ template class GeospatialQuery const double max_distance, const engine::Approach approach) const { - auto results = - rtree.Nearest(input_coordinate, - [this, approach, &input_coordinate](const CandidateSegment &segment) { - return boolPairAnd(HasValidEdge(segment), approach_usage(input_coordinate, segment, approach)); - }, - [this, max_distance, max_results, input_coordinate]( - const std::size_t num_results, const CandidateSegment &segment) { - return num_results >= max_results || - CheckSegmentDistance(input_coordinate, segment, max_distance); - }); + auto results = rtree.Nearest( + input_coordinate, + [this, approach, &input_coordinate](const CandidateSegment &segment) { + return boolPairAnd(HasValidEdge(segment), + approach_usage(input_coordinate, segment, approach)); + }, + [this, max_distance, max_results, input_coordinate](const std::size_t num_results, + const CandidateSegment &segment) { + return num_results >= max_results || + CheckSegmentDistance(input_coordinate, segment, max_distance); + }); return MakePhantomNodes(input_coordinate, results); } @@ -197,13 +205,15 @@ template class GeospatialQuery bool has_big_component = false; auto results = rtree.Nearest( input_coordinate, - [this, approach, &input_coordinate, &has_big_component, &has_small_component](const CandidateSegment &segment) { + [this, approach, &input_coordinate, &has_big_component, &has_small_component]( + const CandidateSegment &segment) { auto use_segment = (!has_small_component || (!has_big_component && !IsTinyComponent(segment))); auto use_directions = std::make_pair(use_segment, use_segment); const auto valid_edges = HasValidEdge(segment); use_directions = boolPairAnd(use_directions, valid_edges); - use_directions = boolPairAnd(use_directions, approach_usage(input_coordinate, segment, approach)); + use_directions = boolPairAnd(use_directions, + approach_usage(input_coordinate, segment, approach)); if (use_directions.first || use_directions.second) { @@ -274,15 +284,23 @@ template class GeospatialQuery // Returns the nearest phantom node. If this phantom node is not from a big component // a second phantom node is return that is the nearest coordinate in a big component. - std::pair NearestPhantomNodeWithAlternativeFromBigComponent( - const util::Coordinate input_coordinate, const int bearing, const int bearing_range, const engine::Approach approach) const + std::pair + NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate, + const int bearing, + const int bearing_range, + const engine::Approach approach) const { bool has_small_component = false; bool has_big_component = false; auto results = rtree.Nearest( input_coordinate, - [this, approach, &input_coordinate, bearing, bearing_range, &has_big_component, &has_small_component]( - const CandidateSegment &segment) { + [this, + approach, + &input_coordinate, + bearing, + bearing_range, + &has_big_component, + &has_small_component](const CandidateSegment &segment) { auto use_segment = (!has_small_component || (!has_big_component && !IsTinyComponent(segment))); auto use_directions = std::make_pair(use_segment, use_segment); @@ -293,8 +311,8 @@ template class GeospatialQuery use_directions = boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range), HasValidEdge(segment)); - use_directions = boolPairAnd(use_directions, - approach_usage(input_coordinate, segment, approach)); + use_directions = boolPairAnd( + use_directions, approach_usage(input_coordinate, segment, approach)); if (use_directions.first || use_directions.second) { @@ -332,8 +350,13 @@ template class GeospatialQuery bool has_big_component = false; auto results = rtree.Nearest( input_coordinate, - [this, approach, &input_coordinate, bearing, bearing_range, &has_big_component, &has_small_component]( - const CandidateSegment &segment) { + [this, + approach, + &input_coordinate, + bearing, + bearing_range, + &has_big_component, + &has_small_component](const CandidateSegment &segment) { auto use_segment = (!has_small_component || (!has_big_component && !IsTinyComponent(segment))); auto use_directions = std::make_pair(use_segment, use_segment); @@ -344,8 +367,8 @@ template class GeospatialQuery use_directions = boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range), HasValidEdge(segment)); - use_directions = boolPairAnd(use_directions, - approach_usage(input_coordinate, segment, approach)); + use_directions = boolPairAnd( + use_directions, approach_usage(input_coordinate, segment, approach)); if (use_directions.first || use_directions.second) { @@ -579,11 +602,11 @@ template class GeospatialQuery } std::pair approach_usage(const util::Coordinate &input_coordinate, - const CandidateSegment &segment, - const engine::Approach approach) const + const CandidateSegment &segment, + const engine::Approach approach) const { - bool isOnewaySegment = !(segment.data.forward_segment_id.enabled && - segment.data.reverse_segment_id.enabled); + bool isOnewaySegment = + !(segment.data.forward_segment_id.enabled && segment.data.reverse_segment_id.enabled); if (!isOnewaySegment && approach == CURB) { // Check the counter clockwise @@ -596,7 +619,7 @@ template class GeospatialQuery bool input_coordinate_is_at_right = !util::coordinate_calculation::isCCW( coordinates[segment.data.u], coordinates[segment.data.v], input_coordinate); - if(datafacade.IsLeftHandDriving()) + if (datafacade.IsLeftHandDriving()) input_coordinate_is_at_right = !input_coordinate_is_at_right; return std::make_pair(input_coordinate_is_at_right, (!input_coordinate_is_at_right)); diff --git a/include/engine/plugins/plugin_base.hpp b/include/engine/plugins/plugin_base.hpp index fc29ea48b..5d985627a 100644 --- a/include/engine/plugins/plugin_base.hpp +++ b/include/engine/plugins/plugin_base.hpp @@ -149,8 +149,8 @@ class BasePlugin } else { - phantom_nodes[i] = - facade.NearestPhantomNodesInRange(parameters.coordinates[i], radiuses[i], approach); + phantom_nodes[i] = facade.NearestPhantomNodesInRange( + parameters.coordinates[i], radiuses[i], approach); } } @@ -212,13 +212,15 @@ class BasePlugin { if (use_radiuses && parameters.radiuses[i]) { - phantom_nodes[i] = facade.NearestPhantomNodes( - parameters.coordinates[i], number_of_results, *parameters.radiuses[i], approach); + phantom_nodes[i] = facade.NearestPhantomNodes(parameters.coordinates[i], + number_of_results, + *parameters.radiuses[i], + approach); } else { - phantom_nodes[i] = - facade.NearestPhantomNodes(parameters.coordinates[i], number_of_results, approach); + phantom_nodes[i] = facade.NearestPhantomNodes( + parameters.coordinates[i], number_of_results, approach); } } @@ -275,8 +277,7 @@ class BasePlugin parameters.coordinates[i], parameters.bearings[i]->bearing, parameters.bearings[i]->range, - approach - ); + approach); } } else diff --git a/include/nodejs/node_osrm_support.hpp b/include/nodejs/node_osrm_support.hpp index 1b6c20ce7..759a38c75 100644 --- a/include/nodejs/node_osrm_support.hpp +++ b/include/nodejs/node_osrm_support.hpp @@ -3,8 +3,8 @@ #include "nodejs/json_v8_renderer.hpp" -#include "osrm/bearing.hpp" #include "osrm/approach.hpp" +#include "osrm/bearing.hpp" #include "osrm/coordinate.hpp" #include "osrm/engine_config.hpp" #include "osrm/json_container.hpp" @@ -332,7 +332,7 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo &arg { const Nan::Utf8String approach_utf8str(approach_raw); std::string approach_str{*approach_utf8str, - *approach_utf8str + approach_utf8str.length()}; + *approach_utf8str + approach_utf8str.length()}; if (approach_str == "curb") { params->approaches.push_back(osrm::Approach::CURB); @@ -344,7 +344,7 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo &arg else { Nan::ThrowError("'approach' param must be one of [curb, unrestricted]"); - return false; + return false; } } else diff --git a/include/server/api/base_parameters_grammar.hpp b/include/server/api/base_parameters_grammar.hpp index f446de67a..8d3c5af7c 100644 --- a/include/server/api/base_parameters_grammar.hpp +++ b/include/server/api/base_parameters_grammar.hpp @@ -149,16 +149,16 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar qi::lit("bearings=") > (-(qi::short_ > ',' > qi::short_))[ph::bind(add_bearing, qi::_r1, qi::_1)] % ';'; - approach_type.add("unrestricted", engine::Approach::UNRESTRICTED)("curb", engine::Approach::CURB); - approach_rule = - qi::lit("approaches=") > - (-approach_type % ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1]; + approach_type.add("unrestricted", engine::Approach::UNRESTRICTED)("curb", + engine::Approach::CURB); + approach_rule = qi::lit("approaches=") > + (-approach_type % + ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1]; base_rule = radiuses_rule(qi::_r1) // | hints_rule(qi::_r1) // | bearings_rule(qi::_r1) // - | generate_hints_rule(qi::_r1) - | approach_rule(qi::_r1); + | generate_hints_rule(qi::_r1) | approach_rule(qi::_r1); } protected: diff --git a/unit_tests/mocks/mock_datafacade.hpp b/unit_tests/mocks/mock_datafacade.hpp index bc91cc32f..e4d9d4f9d 100644 --- a/unit_tests/mocks/mock_datafacade.hpp +++ b/unit_tests/mocks/mock_datafacade.hpp @@ -152,35 +152,39 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade } std::pair - NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/, - const engine::Approach /*approach*/) const override + NearestPhantomNodeWithAlternativeFromBigComponent( + const util::Coordinate /*input_coordinate*/, + const engine::Approach /*approach*/) const override { return {}; } std::pair - NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/, - const double /*max_distance*/, - const engine::Approach /*approach*/) const override + NearestPhantomNodeWithAlternativeFromBigComponent( + const util::Coordinate /*input_coordinate*/, + const double /*max_distance*/, + const engine::Approach /*approach*/) const override { return {}; } std::pair - NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/, - const double /*max_distance*/, - const int /*bearing*/, - const int /*bearing_range*/, - const engine::Approach /*approach*/) const override + NearestPhantomNodeWithAlternativeFromBigComponent( + const util::Coordinate /*input_coordinate*/, + const double /*max_distance*/, + const int /*bearing*/, + const int /*bearing_range*/, + const engine::Approach /*approach*/) const override { return {}; } std::pair - NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/, - const int /*bearing*/, - const int /*bearing_range*/, - const engine::Approach /*approach*/) const override + NearestPhantomNodeWithAlternativeFromBigComponent( + const util::Coordinate /*input_coordinate*/, + const int /*bearing*/, + const int /*bearing_range*/, + const engine::Approach /*approach*/) const override { return {}; } diff --git a/unit_tests/server/parameters_io.hpp b/unit_tests/server/parameters_io.hpp index ad601984c..e5e00d517 100644 --- a/unit_tests/server/parameters_io.hpp +++ b/unit_tests/server/parameters_io.hpp @@ -2,8 +2,8 @@ #define OSRM_TEST_SERVER_PARAMETERS_IO #include "engine/api/route_parameters.hpp" -#include "engine/bearing.hpp" #include "engine/approach.hpp" +#include "engine/bearing.hpp" #include diff --git a/unit_tests/server/parameters_parser.cpp b/unit_tests/server/parameters_parser.cpp index 341055f0f..96473fc0c 100644 --- a/unit_tests/server/parameters_parser.cpp +++ b/unit_tests/server/parameters_parser.cpp @@ -400,7 +400,7 @@ BOOST_AUTO_TEST_CASE(valid_route_urls) BOOST_CHECK_EQUAL(result_17->annotations, true); std::vector> approaches_18 = { - boost::none, engine::Approach::CURB, engine::Approach::UNRESTRICTED, engine::Approach::CURB, + boost::none, engine::Approach::CURB, engine::Approach::UNRESTRICTED, engine::Approach::CURB, }; RouteParameters reference_18{false, false, @@ -414,7 +414,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls) std::vector>{}, approaches_18}; - auto result_18 = parseParameters("1,2;3,4;5,6;7,8?steps=false&approaches=;curb;unrestricted;curb"); + auto result_18 = parseParameters( + "1,2;3,4;5,6;7,8?steps=false&approaches=;curb;unrestricted;curb"); BOOST_CHECK(result_18); BOOST_CHECK_EQUAL(reference_18.steps, result_18->steps); BOOST_CHECK_EQUAL(reference_18.alternatives, result_18->alternatives); diff --git a/unit_tests/util/static_rtree.cpp b/unit_tests/util/static_rtree.cpp index 516ba8e3c..2b11a832b 100644 --- a/unit_tests/util/static_rtree.cpp +++ b/unit_tests/util/static_rtree.cpp @@ -420,12 +420,14 @@ BOOST_AUTO_TEST_CASE(bearing_tests) } { - auto results = query.NearestPhantomNodesInRange(input, 11000, 270, 10, osrm::engine::UNRESTRICTED); + auto results = + query.NearestPhantomNodesInRange(input, 11000, 270, 10, osrm::engine::UNRESTRICTED); BOOST_CHECK_EQUAL(results.size(), 0); } { - auto results = query.NearestPhantomNodesInRange(input, 11000, 45, 10, osrm::engine::UNRESTRICTED); + auto results = + query.NearestPhantomNodesInRange(input, 11000, 45, 10, osrm::engine::UNRESTRICTED); BOOST_CHECK_EQUAL(results.size(), 2); BOOST_CHECK(results[0].phantom_node.forward_segment_id.enabled);