store/accept individual annotations parameters in addition to bool

include/engine/api/route_parameters.hpp

@@ -67,6 +67,14 @@ struct RouteParameters : public BaseParameters
         Full,
         False
     };
+    enum class AnnotationsType
+    {
+        None = 0,
+        Duration = 1 << 1,
+        Nodes = 1 << 2,
+        Distance = 1 << 3,
+        All = Duration | Nodes | Distance
+    };
 
     RouteParameters() = default;
 
@@ -78,7 +86,7 @@ struct RouteParameters : public BaseParameters
                     const boost::optional<bool> continue_straight_,
                     Args... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          annotations{false}, geometries{geometries_}, overview{overview_},
+          annotations{false}, annotations_type{AnnotationsType::None}, geometries{geometries_}, overview{overview_},
           continue_straight{continue_straight_}
     // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one below.
     {
@@ -94,7 +102,22 @@ struct RouteParameters : public BaseParameters
                     const boost::optional<bool> continue_straight_,
                     Args... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          annotations{annotations_}, geometries{geometries_}, overview{overview_},
+          annotations{annotations_}, annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None}, geometries{geometries_}, overview{overview_},
+          continue_straight{continue_straight_}
+    {
+    }
+
+    // enum based implementation of annotations parameter
+    template <typename... Args>
+    RouteParameters(const bool steps_,
+                    const bool alternatives_,
+                    const AnnotationsType annotations_,
+                    const GeometriesType geometries_,
+                    const OverviewType overview_,
+                    const boost::optional<bool> continue_straight_,
+                    Args... args_)
+        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
+          annotations_type{annotations_}, annotations{true}, geometries{geometries_}, overview{overview_},
           continue_straight{continue_straight_}
     {
     }
@@ -102,6 +125,7 @@ struct RouteParameters : public BaseParameters
     bool steps = false;
     bool alternatives = false;
     bool annotations = false;
+    AnnotationsType annotations_type = AnnotationsType::None;
     GeometriesType geometries = GeometriesType::Polyline;
     OverviewType overview = OverviewType::Simplified;
     boost::optional<bool> continue_straight;

include/server/api/route_parameters_grammar.hpp

@@ -26,6 +26,15 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
 {
     using BaseGrammar = BaseParametersGrammar<Iterator, Signature>;
 
+    const auto add_annotation = [](engine::api::RouteParameters &route_parameters,
+                                   engine::api::RouteParameters::AnnotationsType &route_param) {
+        // bitflag each parameter
+        if (route_param)
+        {
+            route_parameters.annotations_ = route_parameters.annotations_ | route_param;
+        }
+    };
+
     RouteParametersGrammar() : RouteParametersGrammar(root_rule)
     {
         route_rule =
@@ -50,17 +59,23 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
             "full", engine::api::RouteParameters::OverviewType::Full)(
             "false", engine::api::RouteParameters::OverviewType::False);
 
+        annotations_type.add("all", engine::api::RouteParameters::AnnotationsType::All)(
+            "none", engine::api::RouteParameters::AnnotationsType::None)(
+            "duration", engine::api::RouteParameters::AnnotationsType::Duration)(
+            "nodes", engine::api::RouteParameters::AnnotationsType::Nodes)(
+            "distance", engine::api::RouteParameters::AnnotationsType::Distance);
+
         base_rule =
             BaseGrammar::base_rule(qi::_r1) |
             (qi::lit("steps=") >
              qi::bool_[ph::bind(&engine::api::RouteParameters::steps, qi::_r1) = qi::_1]) |
-            (qi::lit("annotations=") >
-             qi::bool_[ph::bind(&engine::api::RouteParameters::annotations, qi::_r1) = qi::_1]) |
             (qi::lit("geometries=") >
              geometries_type[ph::bind(&engine::api::RouteParameters::geometries, qi::_r1) =
                                  qi::_1]) |
             (qi::lit("overview=") >
-             overview_type[ph::bind(&engine::api::RouteParameters::overview, qi::_r1) = qi::_1]);
+             overview_type[ph::bind(&engine::api::RouteParameters::overview, qi::_r1) = qi::_1]) |
+            (qi::lit("annotations=") >
+             annotations_type[ph::bind(add_annotation, qi::_r1, qi::_1)] % ',');
 
         query_rule = BaseGrammar::query_rule(qi::_r1);
     }
@@ -75,6 +90,7 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
 
     qi::symbols<char, engine::api::RouteParameters::GeometriesType> geometries_type;
     qi::symbols<char, engine::api::RouteParameters::OverviewType> overview_type;
+    qi::symbols<char, engine::api::RouteParameters::AnnotationsType> annotations_type;
 };
 }
 }