Move bearing to public namespace

CMakeLists.txt

@@ -382,7 +382,7 @@ set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 file(GLOB VariantGlob third_party/variant/*.hpp)
 file(GLOB LibraryGlob include/osrm/*.hpp)
 file(GLOB ParametersGlob include/engine/api/*.hpp)
-set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/object_encoder.hpp include/engine/phantom_node.hpp)
+set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/object_encoder.hpp include/engine/phantom_node.hpp)
 set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/strong_typedef.hpp)
 set(ExtractorHeader include/extractor/extractor.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
 set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)

include/engine/api/base_parameters.hpp

@@ -2,6 +2,7 @@
 #define ENGINE_API_BASE_PARAMETERS_HPP
 
 #include "engine/hint.hpp"
+#include "engine/bearing.hpp"
 #include "util/coordinate.hpp"
 
 #include <boost/optional.hpp>
@@ -17,12 +18,6 @@ namespace api
 {
 struct BaseParameters
 {
-    struct Bearing
-    {
-        short bearing;
-        short range;
-    };
-
     std::vector<util::Coordinate> coordinates;
     std::vector<boost::optional<Hint>> hints;
     std::vector<boost::optional<double>> radiuses;
@@ -39,24 +34,12 @@ struct BaseParameters
                            {
                                if (bearing_and_range)
                                {
-                                   return bearing_and_range->bearing >= 0 &&
+                                   return bearing_and_range->IsValid();
-                                          bearing_and_range->bearing <= 360 &&
-                                          bearing_and_range->range >= 0 &&
-                                          bearing_and_range->range <= 180;
                                }
                                return true;
                            });
     }
 };
-
-inline bool operator==(const BaseParameters::Bearing lhs, const BaseParameters::Bearing rhs)
-{
-    return lhs.bearing == rhs.bearing && lhs.range == rhs.range;
-}
-inline bool operator!=(const BaseParameters::Bearing lhs, const BaseParameters::Bearing rhs)
-{
-    return !(lhs == rhs);
-}
 }
 }
 }

include/engine/bearing.hpp

@@ -0,0 +1,25 @@
+#ifndef OSRM_ENGINE_BEARING_HPP
+#define OSRM_ENGINE_BEARING_HPP
+
+namespace osrm
+{
+namespace engine
+{
+
+struct Bearing
+{
+    short bearing;
+    short range;
+
+    bool IsValid() const { return bearing >= 0 && bearing <= 360 && range >= 0 && range <= 180; }
+};
+
+inline bool operator==(const Bearing lhs, const Bearing rhs)
+{
+    return lhs.bearing == rhs.bearing && lhs.range == rhs.range;
+}
+inline bool operator!=(const Bearing lhs, const Bearing rhs) { return !(lhs == rhs); }
+}
+}
+
+#endif

include/osrm/bearing.hpp

@@ -0,0 +1,11 @@
+#ifndef OSRM_BEARING_HPP
+#define OSRM_BEARING_HPP
+
+#include "engine/bearing.hpp"
+
+namespace osrm
+{
+  using engine::Bearing;
+}
+
+#endif

include/osrm/tile_parameters.hpp

@@ -0,0 +1,11 @@
+#ifndef GLOBAL_TILE_PARAMETERS_HPP
+#define GLOBAL_TILE_PARAMETERS_HPP
+
+#include "engine/api/tile_parameters.hpp"
+
+namespace osrm
+{
+using engine::api::TileParameters;
+}
+
+#endif

include/server/api/base_parameters_grammar.hpp

@@ -5,6 +5,7 @@
 
 #include "engine/polyline_compressor.hpp"
 #include "engine/hint.hpp"
+#include "engine/bearing.hpp"
 
 #include <boost/spirit/include/qi_lit.hpp>
 #include <boost/spirit/include/qi_char_.hpp>
@@ -39,11 +40,11 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<std::string::iterator>
         const auto add_bearing =
             [this](boost::optional<boost::fusion::vector2<short, short>> bearing_range)
         {
-            boost::optional<engine::api::BaseParameters::Bearing> bearing;
+            boost::optional<engine::Bearing> bearing;
             if (bearing_range)
             {
-                bearing = engine::api::BaseParameters::Bearing{
+                bearing = engine::Bearing{boost::fusion::at_c<0>(*bearing_range),
-                    boost::fusion::at_c<0>(*bearing_range), boost::fusion::at_c<1>(*bearing_range)};
+                                          boost::fusion::at_c<1>(*bearing_range)};
             }
             base_parameters.bearings.push_back(std::move(bearing));
         };

unit_tests/server/parameters_parser.cpp

@@ -5,6 +5,7 @@
 #include "engine/api/table_parameters.hpp"
 #include "engine/api/match_parameters.hpp"
 #include "engine/api/trip_parameters.hpp"
+#include "engine/api/tile_parameters.hpp"
 #include "engine/api/nearest_parameters.hpp"
 
 #include <fstream>
@@ -48,14 +49,14 @@ std::ostream &operator<<(std::ostream &out, api::RouteParameters::OverviewType o
     }
     return out;
 }
-std::ostream &operator<<(std::ostream &out, api::RouteParameters::Bearing bearing)
+}
+std::ostream &operator<<(std::ostream &out, Bearing bearing)
 {
     out << bearing.bearing << "," << bearing.range;
     return out;
 }
 }
 }
-}
 
 #include <boost/test/unit_test.hpp>
 #include <boost/test/test_tools.hpp>
@@ -175,16 +176,15 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
             "_4ghA4JuzAD_IAAAo28BAOYAAAAzAAAAAgAAAEwAAAAAAAAAdIwAAJ4AAAAXiSEDfm7MAAEAAQGLSzmR"),
         engine::Hint::FromBase64(
             "03AhA0vnzAA_SAAA_____3wEAAAYAAAAQAAAAB4AAABAAAAAoUYBAJ4AAADlcCEDSefMAAMAAQGLSzmR")};
-    engine::api::RouteParameters reference_4{
+    engine::api::RouteParameters reference_4{false,
-        false,
+                                             true,
-        true,
+                                             engine::api::RouteParameters::GeometriesType::Polyline,
-        engine::api::RouteParameters::GeometriesType::Polyline,
+                                             engine::api::RouteParameters::OverviewType::Simplified,
-        engine::api::RouteParameters::OverviewType::Simplified,
+                                             std::vector<boost::optional<bool>>{},
-        std::vector<boost::optional<bool>>{},
+                                             coords_1,
-        coords_1,
+                                             hints_4,
-        hints_4,
+                                             std::vector<boost::optional<double>>{},
-        std::vector<boost::optional<double>>{},
+                                             std::vector<boost::optional<engine::Bearing>>{}};
-        std::vector<boost::optional<engine::api::BaseParameters::Bearing>>{}};
     auto result_4 = api::parseParameters<engine::api::RouteParameters>(
         "1,2;3,4?steps=false&hints="
         "rVghAzxMzABMAwAA5h4CAKMIAAAQAAAAGAAAAAYAAAAAAAAAch8BAJ4AAACpWCED_"
@@ -201,9 +201,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     CHECK_EQUAL_RANGE(reference_4.radiuses, result_4->radiuses);
     CHECK_EQUAL_RANGE(reference_4.coordinates, result_4->coordinates);
 
-    std::vector<boost::optional<engine::api::BaseParameters::Bearing>> bearings_4 = {
+    std::vector<boost::optional<engine::Bearing>> bearings_4 = {
-        boost::none, engine::api::BaseParameters::Bearing{200, 10},
+        boost::none, engine::Bearing{200, 10}, engine::Bearing{100, 5},
-        engine::api::BaseParameters::Bearing{100, 5},
     };
     engine::api::RouteParameters reference_5{false,
                                              true,