Fix parameter parsing tests

include/server/api/parameters_parser.hpp

@@ -0,0 +1,35 @@
+#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"
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+// Starts parsing and iter and modifies it until iter == end or parsing failed
+template<typename ParameterT>
+boost::optional<ParameterT> parseParameters(std::string::iterator& iter, std::string::iterator end);
+
+// copy on purpose because we need mutability
+template<typename ParameterT>
+inline boost::optional<ParameterT> parseParameters(std::string options_string)
+{
+    auto iter = options_string.begin();
+    return parseParameters<ParameterT>(iter, options_string.end());
+}
+
+template<>
+boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator& iter, std::string::iterator end);
+template<>
+boost::optional<engine::api::TableParameters> parseParameters(std::string::iterator& iter, std::string::iterator end);
+
+}
+}
+}
+
+#endif

include/server/api/route_parameters_grammar.hpp

@@ -29,40 +29,40 @@ struct RouteParametersGrammar : public BaseParametersGrammar
     using UturnsT = std::vector<boost::optional<bool>>;
 
     RouteParametersGrammar()
-        : BaseParametersGrammar(root_rule, route_parameters)
+        : BaseParametersGrammar(root_rule, parameters)
     {
         const auto set_geojson_type = [this]()
         {
-            route_parameters.geometries = engine::api::RouteParameters::GeometriesType::GeoJSON;
+            parameters.geometries = engine::api::RouteParameters::GeometriesType::GeoJSON;
         };
         const auto set_polyline_type = [this]()
         {
-            route_parameters.geometries = engine::api::RouteParameters::GeometriesType::Polyline;
+            parameters.geometries = engine::api::RouteParameters::GeometriesType::Polyline;
         };
 
         const auto set_simplified_type = [this]()
         {
-            route_parameters.overview = engine::api::RouteParameters::OverviewType::Simplified;
+            parameters.overview = engine::api::RouteParameters::OverviewType::Simplified;
         };
         const auto set_full_type = [this]()
         {
-            route_parameters.overview = engine::api::RouteParameters::OverviewType::Full;
+            parameters.overview = engine::api::RouteParameters::OverviewType::Full;
         };
         const auto set_false_type = [this]()
         {
-            route_parameters.overview = engine::api::RouteParameters::OverviewType::False;
+            parameters.overview = engine::api::RouteParameters::OverviewType::False;
         };
         const auto set_steps = [this](const StepsT steps)
         {
-            route_parameters.steps = steps;
+            parameters.steps = steps;
         };
         const auto set_alternative = [this](const AlternativeT alternative)
         {
-            route_parameters.alternative = alternative;
+            parameters.alternative = alternative;
         };
         const auto set_uturns = [this](UturnsT &uturns)
         {
-            route_parameters.uturns = std::move(uturns);
+            parameters.uturns = std::move(uturns);
         };
 
         alternative_rule = qi::lit("alternative=") >> qi::bool_;
@@ -78,7 +78,7 @@ struct RouteParametersGrammar : public BaseParametersGrammar
         root_rule = -((base_rule | route_rule) % '&');
     }
 
-    engine::api::RouteParameters route_parameters;
+    engine::api::RouteParameters parameters;
   private:
     qi::rule<Iterator> root_rule, route_rule, geometries_rule, overview_rule;
     qi::rule<Iterator, UturnsT()> uturns_rule;

include/server/api/route_parameters_parser.hpp

@@ -1,28 +0,0 @@
-#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/table_parameter_grammar.hpp

@@ -0,0 +1,55 @@
+#ifndef TABLE_PARAMETERS_GRAMMAR_HPP
+#define TABLE_PARAMETERS_GRAMMAR_HPP
+
+#include "engine/api/table_parameters.hpp"
+
+#include "server/api/base_parameters_grammar.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_optional.hpp>
+
+namespace osrm
+{
+namespace server
+{
+namespace api
+{
+
+namespace qi = boost::spirit::qi;
+struct TableParametersGrammar : public BaseParametersGrammar
+{
+    using Iterator = std::string::iterator;
+    using SourcesT = std::vector<std::size_t>;
+    using DestinationsT = std::vector<std::size_t>;
+
+    TableParametersGrammar() : BaseParametersGrammar(root_rule, parameters)
+    {
+        const auto set_destiantions = [this](DestinationsT &dests)
+        {
+            parameters.destinations = std::move(dests);
+        };
+        const auto set_sources = [this](SourcesT &sources)
+        {
+            parameters.sources = std::move(sources);
+        };
+        destinations_rule = qi::lit("destinations=") >> -qi::uint_ % ";";
+        sources_rule = qi::lit("sources=") >> -qi::uint_ % ";";
+        table_rule = destinations_rule[set_destiantions] | sources_rule[set_sources];
+        root_rule = -((base_rule | table_rule) % '&');
+    }
+
+    engine::api::TableParameters parameters;
+
+  private:
+    qi::rule<Iterator> root_rule, table_rule;
+    qi::rule<Iterator, SourcesT()> sources_rule;
+    qi::rule<Iterator, DestinationsT()> destinations_rule;
+};
+}
+}
+}
+
+#endif