Add viaroute suport for new API

include/server/api/base_parameters_grammar.hpp

@@ -0,0 +1,82 @@
+#ifndef SERVER_API_BASE_PARAMETERS_GRAMMAR_HPP
+#define SERVER_API_BASE_PARAMETERS_GRAMMAR_HPP
+
+#include "engine/api/base_parameters.hpp"
+
+#include "engine/polyline_compressor.hpp"
+#include "engine/hint.hpp"
+
+#include <boost/spirit/include/qi_lit.hpp>
+#include <boost/spirit/include/qi_char_.hpp>
+#include <boost/spirit/include/qi_int.hpp>
+#include <boost/spirit/include/qi_real.hpp>
+#include <boost/spirit/include/qi_grammar.hpp>
+#include <boost/spirit/include/qi_action.hpp>
+#include <boost/spirit/include/qi_optional.hpp>
+#include <boost/spirit/include/qi_attr_cast.hpp>
+#include <boost/spirit/include/qi_operator.hpp>
+#include <boost/spirit/include/qi_repeat.hpp>
+#include <boost/spirit/include/qi_as_string.hpp>
+
+#include <string>
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+namespace qi = boost::spirit::qi;
+struct BaseParametersGrammar : boost::spirit::qi::grammar<std::string::iterator>
+{
+    using Iterator = std::string::iterator;
+    using RadiusesT = std::vector<boost::optional<double>>;
+
+    BaseParametersGrammar(qi::rule<Iterator> &child_rule,
+                          engine::api::BaseParameters &parameters_)
+        : BaseParametersGrammar::base_type(child_rule), base_parameters(parameters_)
+    {
+        const auto add_bearing = [this](const boost::optional<boost::fusion::vector<short, short>> &bearing_range) {
+            boost::optional<engine::api::BaseParameters::Bearing> bearing;
+            if (bearing_range)
+            {
+                bearing = engine::api::BaseParameters::Bearing {boost::fusion::at_c<0>(*bearing_range), boost::fusion::at_c<1>(*bearing_range)};
+            }
+            base_parameters.bearings.push_back(std::move(bearing));
+        };
+        const auto set_radiuses = [this](RadiusesT& radiuses) {
+            base_parameters.radiuses = std::move(radiuses);
+        };
+        const auto add_hint = [this](const std::string& hint_string) {
+            if (hint_string.size() > 0)
+            {
+                base_parameters.hints.push_back(engine::Hint::FromBase64(hint_string));
+            }
+        };
+
+        alpha_numeral = +qi::char_("a-zA-Z0-9");
+        base64_char = qi::char_("a-zA-Z0-9--_");
+
+        radiuses_rule = qi::lit("radiuses=") >> -qi::double_ % ";";
+        hints_rule = qi::lit("hints=") >> qi::as_string[qi::repeat(engine::ENCODED_HINT_SIZE)[base64_char]][add_hint] % ";";
+        bearings_rule =
+            qi::lit("bearings=") >> -((qi::short_ >> ',' >> qi::short_))[add_bearing] % ";";
+        base_rule = bearings_rule | radiuses_rule[set_radiuses] | hints_rule;
+    }
+
+    qi::rule<Iterator> base_rule;
+
+private:
+    engine::api::BaseParameters &base_parameters;
+    qi::rule<Iterator> bearings_rule;
+    qi::rule<Iterator> hints_rule;
+    qi::rule<Iterator, RadiusesT()> radiuses_rule;
+    qi::rule<Iterator, unsigned char()> base64_char;
+    qi::rule<Iterator, std::string()> alpha_numeral;
+};
+}
+}
+}
+
+#endif

include/server/api/parsed_url.hpp

@@ -0,0 +1,29 @@
+#ifndef SERVER_API_PARSED_URL_HPP
+#define SERVER_API_PARSED_URL_HPP
+
+#include "util/coordinate.hpp"
+
+#include <string>
+#include <vector>
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+struct ParsedURL
+{
+    std::string service;
+    unsigned version;
+    std::string profile;
+    std::vector<util::FixedPointCoordinate> coordinates;
+    std::string options;
+};
+
+}
+}
+}
+
+#endif

include/server/api/route_parameters_grammar.hpp

@@ -0,0 +1,92 @@
+#ifndef ROUTE_PARAMETERS_GRAMMAR_HPP
+#define ROUTE_PARAMETERS_GRAMMAR_HPP
+
+#include "engine/api/route_parameters.hpp"
+
+#include "server/api/base_parameters_grammar.hpp"
+
+#include <boost/spirit/include/qi_lit.hpp>
+#include <boost/spirit/include/qi_bool.hpp>
+#include <boost/spirit/include/qi_grammar.hpp>
+#include <boost/spirit/include/qi_action.hpp>
+#include <boost/spirit/include/qi_optional.hpp>
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+namespace qi = boost::spirit::qi;
+struct RouteParametersGrammar : public BaseParametersGrammar
+{
+    using Iterator = std::string::iterator;
+    using StepsT = bool;
+    using AlternativeT = bool;
+    using GeometriesT = engine::api::RouteParameters::GeometriesType;
+    using OverviewT = engine::api::RouteParameters::OverviewType;
+    using UturnsT = std::vector<boost::optional<bool>>;
+
+    RouteParametersGrammar()
+        : BaseParametersGrammar(root_rule, route_parameters)
+    {
+        const auto set_geojson_type = [this]()
+        {
+            route_parameters.geometries = engine::api::RouteParameters::GeometriesType::GeoJSON;
+        };
+        const auto set_polyline_type = [this]()
+        {
+            route_parameters.geometries = engine::api::RouteParameters::GeometriesType::Polyline;
+        };
+
+        const auto set_simplified_type = [this]()
+        {
+            route_parameters.overview = engine::api::RouteParameters::OverviewType::Simplified;
+        };
+        const auto set_full_type = [this]()
+        {
+            route_parameters.overview = engine::api::RouteParameters::OverviewType::Full;
+        };
+        const auto set_false_type = [this]()
+        {
+            route_parameters.overview = engine::api::RouteParameters::OverviewType::False;
+        };
+        const auto set_steps = [this](const StepsT steps)
+        {
+            route_parameters.steps = steps;
+        };
+        const auto set_alternative = [this](const AlternativeT alternative)
+        {
+            route_parameters.alternative = alternative;
+        };
+        const auto set_uturns = [this](UturnsT &uturns)
+        {
+            route_parameters.uturns = std::move(uturns);
+        };
+
+        alternative_rule = qi::lit("alternative=") >> qi::bool_;
+        steps_rule = qi::lit("steps=") >> qi::bool_;
+        geometries_rule = qi::lit("geometries=geojson")[set_geojson_type] |
+                          qi::lit("geometries=polyline")[set_polyline_type];
+        overview_rule = qi::lit("overview=simplified")[set_simplified_type] |
+                        qi::lit("overview=full")[set_full_type] |
+                        qi::lit("overview=false")[set_false_type];
+        uturns_rule = qi::lit("uturns=") >> -qi::bool_ % ";";
+        route_rule = steps_rule[set_steps] | alternative_rule[set_alternative] | geometries_rule |
+                     overview_rule | uturns_rule[set_uturns];
+        root_rule = -((base_rule | route_rule) % '&');
+    }
+
+    engine::api::RouteParameters route_parameters;
+  private:
+    qi::rule<Iterator> root_rule, route_rule, geometries_rule, overview_rule;
+    qi::rule<Iterator, UturnsT()> uturns_rule;
+    qi::rule<Iterator, StepsT()> steps_rule;
+    qi::rule<Iterator, AlternativeT()> alternative_rule;
+};
+}
+}
+}
+
+#endif

include/server/api/route_parameters_parser.hpp

@@ -0,0 +1,28 @@
+#ifndef SERVER_API_ROUTE_PARAMETERS_PARSER_HPP
+#define SERVER_API_ROUTE_PARAMETERS_PARSER_HPP
+
+#include "engine/api/route_parameters.hpp"
+#include "server/api/route_parameters_parser.hpp"
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+// Starts parsing and iter and modifies it until iter == end or parsing failed
+boost::optional<engine::api::RouteParameters> parseRouteParameters(std::string::iterator& iter, std::string::iterator end);
+
+// copy on purpose because we need mutability
+inline boost::optional<engine::api::RouteParameters> parseRouteParameters(std::string options_string)
+{
+    auto iter = options_string.begin();
+    return parseRouteParameters(iter, options_string.end());
+}
+
+}
+}
+}
+
+#endif

include/server/api/url_parser.hpp

@@ -0,0 +1,30 @@
+#ifndef SERVER_URL_PARSER_HPP
+#define SERVER_URL_PARSER_HPP
+
+#include "server/api/parsed_url.hpp"
+
+#include <boost/optional.hpp>
+
+#include <string>
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+// Starts parsing and iter and modifies it until iter == end or parsing failed
+boost::optional<ParsedURL> parseURL(std::string::iterator& iter, std::string::iterator end);
+// copy on purpose because we need mutability
+inline boost::optional<ParsedURL> parseURL(std::string url_string)
+{
+    auto iter = url_string.begin();
+    return parseURL(iter, url_string.end());
+}
+
+}
+}
+}
+
+#endif