Require a BaseParameters type at compile time via enable_if

include/server/api/parameters_parser.hpp

@@ -4,6 +4,10 @@
 #include "engine/api/route_parameters.hpp"
 #include "engine/api/table_parameters.hpp"
 
+#include <boost/optional/optional.hpp>
+
+#include <type_traits>
+
 namespace osrm
 {
 namespace server
@@ -11,25 +15,28 @@ namespace server
 namespace api
 {
 
-// Starts parsing and iter and modifies it until iter == end or parsing failed
+namespace detail
-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();
+template <typename T> using is_parameter_t = std::is_base_of<engine::api::BaseParameters, T>;
-    return parseParameters<ParameterT>(iter, options_string.end());
+} // ns detail
+
+// Starts parsing and iter and modifies it until iter == end or parsing failed
+template <typename ParameterT,
+          typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
+boost::optional<ParameterT> parseParameters(std::string::iterator &iter, std::string::iterator end);
+
+// Copy on purpose because we need mutability
+template <typename ParameterT,
+          typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
+boost::optional<ParameterT> parseParameters(std::string options_string)
+{
+    const auto first = options_string.begin();
+    const auto last = options_string.end();
+    return parseParameters<ParameterT>(first, last);
 }
 
-template<>
+} // ns api
-boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator& iter, std::string::iterator end);
+} // ns server
-template<>
+} // ns osrm
-boost::optional<engine::api::TableParameters> parseParameters(std::string::iterator& iter, std::string::iterator end);
-
-}
-}
-}
 
 #endif

src/server/api/parameters_parser.cpp

@@ -3,6 +3,8 @@
 #include "server/api/route_parameters_grammar.hpp"
 #include "server/api/table_parameter_grammar.hpp"
 
+#include <type_traits>
+
 namespace osrm
 {
 namespace server
@@ -10,37 +12,37 @@ namespace server
 namespace api
 {
 
-template<>
+namespace detail
-boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator& iter, std::string::iterator end)
 {
-    RouteParametersGrammar grammar;
+
+template <typename ParameterT, typename GrammarT>
+boost::optional<ParameterT> parseParameters(std::string::iterator &iter, std::string::iterator end)
+{
+    GrammarT grammar;
     const auto result = boost::spirit::qi::parse(iter, end, grammar);
 
-    boost::optional<engine::api::RouteParameters> parameters;
+    boost::optional<ParameterT> parameters;
     if (result && iter == end)
-    {
         parameters = std::move(grammar.parameters);
-    }
 
     return parameters;
 }
+} // ns detail
 
-template<>
+template <>
-boost::optional<engine::api::TableParameters> parseParameters(std::string::iterator& iter, std::string::iterator end)
+boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
+                                                              std::string::iterator end)
 {
-    TableParametersGrammar grammar;
+    return detail::parseParameters<engine::api::RouteParameters, RouteParametersGrammar>(iter, end);
-    const auto result = boost::spirit::qi::parse(iter, end, grammar);
-
-    boost::optional<engine::api::TableParameters> parameters;
-    if (result && iter == end)
-    {
-        parameters = std::move(grammar.parameters);
-    }
-
-    return parameters;
 }
 
-}
+template <>
-}
+boost::optional<engine::api::TableParameters> parseParameters(std::string::iterator &iter,
+                                                              std::string::iterator end)
+{
+    return detail::parseParameters<engine::api::TableParameters, TableParametersGrammar>(iter, end);
 }
 
+} // ns api
+} // ns server
+} // ns osrm