Add support for tile plugin

include/osrm/osrm.hpp

@@ -32,6 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "osrm/status.hpp"
 
 #include <memory>
+#include <string>
 
 namespace osrm
 {
@@ -42,6 +43,7 @@ using engine::api::TableParameters;
 using engine::api::NearestParameters;
 using engine::api::TripParameters;
 using engine::api::MatchParameters;
+using engine::api::TileParameters;
 
 class OSRM final
 {
@@ -57,6 +59,7 @@ class OSRM final
     Status Nearest(const NearestParameters &parameters, json::Object &result);
     Status Trip(const TripParameters &parameters, json::Object &result);
     Status Match(const MatchParameters &parameters, json::Object &result);
+    Status Tile(const TileParameters &parameters, std::string &result);
 
   private:
     std::unique_ptr<engine::Engine> engine_;

include/osrm/osrm_fwd.hpp

@@ -24,6 +24,7 @@ struct TableParameters;
 struct NearestParameters;
 struct TripParameters;
 struct MatchParameters;
+struct TileParameters;
 } // ns api
 
 class Engine;

include/server/api/base_parameters_grammar.hpp

@@ -33,9 +33,9 @@ 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,
+    BaseParametersGrammar(qi::rule<Iterator> &root_rule_,
                           engine::api::BaseParameters &parameters_)
-        : BaseParametersGrammar::base_type(child_rule), base_parameters(parameters_)
+        : BaseParametersGrammar::base_type(root_rule_), base_parameters(parameters_)
     {
         const auto add_bearing = [this](boost::optional<boost::fusion::vector2<short, short>> bearing_range) {
             boost::optional<engine::api::BaseParameters::Bearing> bearing;
@@ -54,26 +54,45 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<std::string::iterator>
                 base_parameters.hints.push_back(engine::Hint::FromBase64(hint_string));
             }
         };
+        const auto add_coordinate = [this](const boost::fusion::vector<double, double> &lonLat)
+        {
+            base_parameters.coordinates.emplace_back(
+                util::Coordinate(util::FixedLongitude(boost::fusion::at_c<0>(lonLat) * COORDINATE_PRECISION),
+                                 util::FixedLatitude(boost::fusion::at_c<1>(lonLat) * COORDINATE_PRECISION)));
+        };
+        const auto polyline_to_coordinates = [this](const std::string &polyline)
+        {
+            base_parameters.coordinates = engine::decodePolyline(polyline);
+        };
 
         alpha_numeral = +qi::char_("a-zA-Z0-9");
+        polyline_chars = 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] % ";";
+        polyline_rule = qi::as_string[qi::lit("polyline(") >> +polyline_chars >>
+                                      qi::lit(")")][polyline_to_coordinates];
+        location_rule = (qi::double_ >> qi::lit(',') >> qi::double_)[add_coordinate];
+        query_rule = (location_rule % ';') | polyline_rule;
+
         base_rule = bearings_rule | radiuses_rule[set_radiuses] | hints_rule;
     }
 
+protected:
     qi::rule<Iterator> base_rule;
+    qi::rule<Iterator> query_rule;
 
 private:
     engine::api::BaseParameters &base_parameters;
     qi::rule<Iterator> bearings_rule;
     qi::rule<Iterator> hints_rule;
+    qi::rule<Iterator> polyline_rule, location_rule;
     qi::rule<Iterator, RadiusesT()> radiuses_rule;
     qi::rule<Iterator, unsigned char()> base64_char;
-    qi::rule<Iterator, std::string()> alpha_numeral;
+    qi::rule<Iterator, std::string()> alpha_numeral, polyline_chars;
 };
 }
 }

include/server/api/match_parameter_grammar.hpp

@@ -70,7 +70,7 @@ struct MatchParametersGrammar final : public BaseParametersGrammar
         timestamps_rule = qi::lit("timestamps=") >> qi::uint_ % ";";
         match_rule = steps_rule[set_steps] | geometries_rule |
                      overview_rule | timestamps_rule[set_timestamps];
-        root_rule = -((base_rule | match_rule) % '&');
+        root_rule = query_rule >> -qi::lit(".json") >> -(qi::lit("?") >> (match_rule | base_rule) % '&');
     }
 
     engine::api::MatchParameters parameters;

include/server/api/nearest_parameter_grammar.hpp

@@ -31,13 +31,14 @@ struct NearestParametersGrammar final : public BaseParametersGrammar
             parameters.number_of_results = number;
         };
         nearest_rule = (qi::lit("number=") >> qi::uint_)[set_number];
-        root_rule = *(base_rule | nearest_rule);
+        root_rule = query_rule >> -qi::lit(".json") >> -(qi::lit("?") >> (nearest_rule | base_rule) % '&');
     }
 
     engine::api::NearestParameters parameters;
 
   private:
-    qi::rule<Iterator> root_rule, nearest_rule;
+    qi::rule<Iterator> root_rule;
+    qi::rule<Iterator> nearest_rule;
 };
 }
 }

include/server/api/parameters_parser.hpp

@@ -1,8 +1,8 @@
 #ifndef SERVER_API_ROUTE_PARAMETERS_PARSER_HPP
 #define SERVER_API_ROUTE_PARAMETERS_PARSER_HPP
 
-#include "engine/api/route_parameters.hpp"
-#include "engine/api/table_parameters.hpp"
+#include "engine/api/base_parameters.hpp"
+#include "engine/api/tile_parameters.hpp"
 
 #include <boost/optional/optional.hpp>
 
@@ -20,7 +20,11 @@ namespace api
 
 namespace detail
 {
-template <typename T> using is_parameter_t = std::is_base_of<engine::api::BaseParameters, T>;
+template <typename T>
+using is_parameter_t =
+    std::integral_constant<bool,
+                           std::is_base_of<engine::api::BaseParameters, T>::value ||
+                               std::is_same<engine::api::TileParameters, T>::value>;
 } // ns detail
 
 // Starts parsing and iter and modifies it until iter == end or parsing failed

include/server/api/parsed_url.hpp

@@ -18,8 +18,7 @@ struct ParsedURL
     std::string service;
     unsigned version;
     std::string profile;
-    std::vector<util::Coordinate> coordinates;
-    std::string options;
+    std::string query;
 };
 }
 }

include/server/api/route_parameters_grammar.hpp

@@ -75,13 +75,15 @@ struct RouteParametersGrammar : public BaseParametersGrammar
         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) % '&');
+
+        root_rule = query_rule >> -qi::lit(".json") >> -(qi::lit("?") >> (route_rule | base_rule) % '&');
     }
 
     engine::api::RouteParameters parameters;
 
   private:
-    qi::rule<Iterator> root_rule, route_rule, geometries_rule, overview_rule;
+    qi::rule<Iterator> root_rule;
+    qi::rule<Iterator> route_rule, geometries_rule, overview_rule;
     qi::rule<Iterator, UturnsT()> uturns_rule;
     qi::rule<Iterator, StepsT()> steps_rule;
     qi::rule<Iterator, AlternativeT()> alternative_rule;

include/server/api/table_parameter_grammar.hpp

@@ -39,13 +39,15 @@ struct TableParametersGrammar final : public BaseParametersGrammar
         destinations_rule = (qi::lit("destinations=") >> (qi::ulong_ % ";")[set_destiantions]) | qi::lit("destinations=all");
         sources_rule = (qi::lit("sources=") >> (qi::ulong_ % ";")[set_sources]) | qi::lit("sources=all");
         table_rule = destinations_rule | sources_rule;
-        root_rule = -((base_rule | table_rule) % '&');
+
+        root_rule = query_rule >> -qi::lit(".json") >> -(qi::lit("?") >> (table_rule | base_rule) % '&');
     }
 
     engine::api::TableParameters parameters;
 
   private:
-    qi::rule<Iterator> root_rule, table_rule;
+    qi::rule<Iterator> root_rule;
+    qi::rule<Iterator> table_rule;
     qi::rule<Iterator> sources_rule;
     qi::rule<Iterator> destinations_rule;
 };

include/server/api/tile_parameter_grammar.hpp

@@ -0,0 +1,50 @@
+#ifndef SERVER_API_TILE_PARAMETERS_GRAMMAR_HPP
+#define SERVER_API_TILE_PARAMETERS_GRAMMAR_HPP
+
+#include "engine/api/tile_parameters.hpp"
+
+#include "engine/polyline_compressor.hpp"
+#include "engine/hint.hpp"
+
+#include <boost/spirit/include/qi_lit.hpp>
+#include <boost/spirit/include/qi_uint.hpp>
+#include <boost/spirit/include/qi_grammar.hpp>
+#include <boost/spirit/include/qi_action.hpp>
+#include <boost/spirit/include/qi_operator.hpp>
+
+#include <string>
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+namespace qi = boost::spirit::qi;
+struct TileParametersGrammar final : boost::spirit::qi::grammar<std::string::iterator>
+{
+    using Iterator = std::string::iterator;
+
+    TileParametersGrammar()
+        : TileParametersGrammar::base_type(root_rule)
+    {
+        const auto set_x = [this](const unsigned x_) { parameters.x = x_; };
+        const auto set_y = [this](const unsigned y_) { parameters.y = y_; };
+        const auto set_z = [this](const unsigned z_) { parameters.z = z_; };
+
+        query_rule = qi::lit("tile(") >> qi::uint_[set_x] >> qi::lit(",") >> qi::uint_[set_y] >> qi::lit(",") >> qi::uint_[set_z] >> qi::lit(")");
+
+        root_rule = query_rule >> qi::lit(".mvt");
+    }
+    engine::api::TileParameters parameters;
+
+private:
+    qi::rule<Iterator> root_rule;
+    qi::rule<Iterator> query_rule;
+};
+}
+}
+}
+
+#endif

include/server/api/trip_parameter_grammar.hpp

@@ -63,7 +63,8 @@ struct TripParametersGrammar final : public BaseParametersGrammar
                         qi::lit("overview=full")[set_full_type] |
                         qi::lit("overview=false")[set_false_type];
         trip_rule = steps_rule[set_steps] | geometries_rule | overview_rule;
-        root_rule = -((base_rule | trip_rule) % '&');
+
+        root_rule = query_rule >> -qi::lit(".json") >> -(qi::lit("?") >> (trip_rule | base_rule) % '&');
     }
 
     engine::api::TripParameters parameters;

include/server/service/base_service.hpp

@@ -5,6 +5,8 @@
 #include "util/coordinate.hpp"
 #include "osrm/osrm.hpp"
 
+#include <variant/variant.hpp>
+
 #include <string>
 #include <vector>
 
@@ -18,12 +20,12 @@ namespace service
 class BaseService
 {
   public:
+    using ResultT = mapbox::util::variant<util::json::Object, std::string>;
+
     BaseService(OSRM &routing_machine) : routing_machine(routing_machine) {}
     virtual ~BaseService() = default;
 
-    virtual engine::Status RunQuery(std::vector<util::Coordinate> coordinates,
-                                    std::string &options,
-                                    util::json::Object &json_result) = 0;
+    virtual engine::Status RunQuery(std::string &query, ResultT &result) = 0;
 
     virtual unsigned GetVersion() = 0;
 

include/server/service/match_service.hpp

@@ -22,9 +22,7 @@ class MatchService final : public BaseService
   public:
     MatchService(OSRM &routing_machine) : BaseService(routing_machine) {}
 
-    engine::Status RunQuery(std::vector<util::Coordinate> coordinates,
-                            std::string &options,
-                            util::json::Object &result) final override;
+    engine::Status RunQuery(std::string &query, ResultT &result) final override;
 
     unsigned GetVersion() final override { return 1; }
 };

include/server/service/nearest_service.hpp

@@ -22,9 +22,7 @@ class NearestService final : public BaseService
   public:
     NearestService(OSRM &routing_machine) : BaseService(routing_machine) {}
 
-    engine::Status RunQuery(std::vector<util::Coordinate> coordinates,
-                            std::string &options,
-                            util::json::Object &result) final override;
+    engine::Status RunQuery(std::string &query, ResultT &result) final override;
 
     unsigned GetVersion() final override { return 1; }
 };

include/server/service/route_service.hpp

@@ -22,9 +22,7 @@ class RouteService final : public BaseService
   public:
     RouteService(OSRM &routing_machine) : BaseService(routing_machine) {}
 
-    engine::Status RunQuery(std::vector<util::Coordinate> coordinates,
-                            std::string &options,
-                            util::json::Object &result) final override;
+    engine::Status RunQuery(std::string &query, ResultT &result) final override;
 
     unsigned GetVersion() final override { return 1; }
 };

include/server/service/table_service.hpp

@@ -22,9 +22,7 @@ class TableService final : public BaseService
   public:
     TableService(OSRM &routing_machine) : BaseService(routing_machine) {}
 
-    engine::Status RunQuery(std::vector<util::Coordinate> coordinates,
-                            std::string &options,
-                            util::json::Object &result) final override;
+    engine::Status RunQuery(std::string &query, ResultT &result) final override;
 
     unsigned GetVersion() final override { return 1; }
 };

include/server/service/tile_service.hpp

@@ -0,0 +1,33 @@
+#ifndef SERVER_SERVICE_TILE_SERVICE_HPP
+#define SERVER_SERVICE_TILE_SERVICE_HPP
+
+#include "server/service/base_service.hpp"
+
+#include "engine/status.hpp"
+#include "util/coordinate.hpp"
+#include "osrm/osrm.hpp"
+
+#include <string>
+#include <vector>
+
+namespace osrm
+{
+namespace server
+{
+namespace service
+{
+
+class TileService final : public BaseService
+{
+  public:
+    TileService(OSRM &routing_machine) : BaseService(routing_machine) {}
+
+    engine::Status RunQuery(std::string &query, ResultT &result) final override;
+
+    unsigned GetVersion() final override { return 1; }
+};
+}
+}
+}
+
+#endif

include/server/service/trip_service.hpp

@@ -22,9 +22,7 @@ class TripService final : public BaseService
   public:
     TripService(OSRM &routing_machine) : BaseService(routing_machine) {}
 
-    engine::Status RunQuery(std::vector<util::Coordinate> coordinates,
-                            std::string &options,
-                            util::json::Object &result) final override;
+    engine::Status RunQuery(std::string &query, ResultT &result) final override;
 
     unsigned GetVersion() final override { return 1; }
 };

include/server/service_handler.hpp

@@ -27,10 +27,12 @@ class ServiceHandler
 {
   public:
     ServiceHandler(osrm::EngineConfig &config);
+    using ResultT = service::BaseService::ResultT;
 
-    engine::Status RunQuery(api::ParsedURL parsed_url, util::json::Object &json_result);
+    engine::Status RunQuery(api::ParsedURL parsed_url, ResultT &result);
 
   private:
+
     std::unordered_map<std::string, std::unique_ptr<service::BaseService>> service_map;
     OSRM routing_machine;
 };

include/util/json_container.hpp

@@ -50,15 +50,6 @@ namespace json
 struct Object;
 struct Array;
 
-// For encoding raw binary data in a JSON response
-struct Buffer
-{
-    Buffer() = default;
-    Buffer(const char *value) : value(value) {}
-    Buffer(std::string value) : value(std::move(value)) {}
-    std::string value;
-};
-
 struct String
 {
     String() = default;
@@ -87,7 +78,6 @@ struct Null
 };
 
 using Value = mapbox::util::variant<String,
-                                    Buffer,
                                     Number,
                                     mapbox::util::recursive_wrapper<Object>,
                                     mapbox::util::recursive_wrapper<Array>,

include/util/json_renderer.hpp

@@ -25,13 +25,6 @@ struct Renderer
 {
     explicit Renderer(std::ostream &_out) : out(_out) {}
 
-    void operator()(const Buffer &buffer) const
-    {
-        out << "\"";
-        out << escape_JSON(buffer.value);
-        out << "\"";
-    }
-
     void operator()(const String &string) const
     {
         out << "\"";
@@ -88,14 +81,6 @@ struct ArrayRenderer
 {
     explicit ArrayRenderer(std::vector<char> &_out) : out(_out) {}
 
-    void operator()(const Buffer &buffer) const
-    {
-        out.push_back('\"');
-        const auto string_to_insert = escape_JSON(buffer.value);
-        out.insert(std::end(out), std::begin(string_to_insert), std::end(string_to_insert));
-        out.push_back('\"');
-    }
-
     void operator()(const String &string) const
     {
         out.push_back('\"');