dynamic_invoke

Author: vinniefalco

include/boost/http/server/detail/dynamic_invoke.hpp

@@ -101,26 +101,133 @@ dynamic_invoke(
 
 //------------------------------------------------
 
+template<class F, class Tuple, std::size_t... I>
+auto
+apply_tuple_deref(
+    F const& f,
+    route_params& p,
+    Tuple& t,
+    std::index_sequence<I...>)
+{
+    return f(p, *std::get<I>(t)...);
+}
+
+//------------------------------------------------
+
+/** Wraps a callable whose first parameter is `route_params&`
+    and whose remaining parameters are resolved from
+    @ref route_params::route_data at dispatch time.
+
+    Produced by @ref dynamic_transform. Stored inside
+    the router's handler table.
+*/
 template<class F>
 struct dynamic_handler
 {
     F f;
 
+    // No extra parameters -- just forward to the callable
+    template<class First>
+    route_task
+    invoke_impl(
+        route_params& p,
+        type_list<First> const&) const
+    {
+        static_assert(
+            std::is_convertible_v<route_params&, First>,
+            "first parameter must accept route_params&");
+        return f(p);
+    }
+
+    static route_task
+    make_route_next()
+    {
+        co_return route_next;
+    }
+
+    static route_task
+    wrap_result(route_result r)
+    {
+        co_return r;
+    }
+
+    // Extra parameters resolved from route_data
+    template<class First, class E1, class... Extra>
+    route_task
+    invoke_impl(
+        route_params& p,
+        type_list<First, E1, Extra...> const&) const
+    {
+        static_assert(
+            std::is_convertible_v<route_params&, First>,
+            "first parameter must accept route_params&");
+        static_assert(
+            are_unique<
+                find_key_t<E1>,
+                find_key_t<Extra>...>::value,
+            "callable has duplicate parameter types");
+
+        auto ptrs = std::make_tuple(
+            p.route_data.template find<find_key_t<E1>>(),
+            p.route_data.template find<find_key_t<Extra>>()...);
+
+        bool all_found = std::apply(
+            [](auto*... pp)
+            {
+                return (... && (pp != nullptr));
+            }, ptrs);
+
+        if(! all_found)
+            return make_route_next();
+
+        using R = std::invoke_result_t<
+            F const&, route_params&,
+            find_key_t<E1>&,
+            find_key_t<Extra>&...>;
+        if constexpr (std::is_same_v<R, route_task>)
+            return apply_tuple_deref(
+                f, p, ptrs, std::index_sequence_for<E1, Extra...>{});
+        else
+            return wrap_result(apply_tuple_deref(
+                f, p, ptrs, std::index_sequence_for<E1, Extra...>{}));
+    }
+
     route_task
     operator()(route_params& p) const
     {
-        co_return dynamic_invoke(
-            p.route_data, f);
+        return invoke_impl(p,
+            typename call_traits<
+                std::decay_t<F>>::arg_types{});
     }
 };
 
-/** A handler transform that resolves parameters from route_data.
+/** A handler transform that resolves extra parameters from route_data.
 
     When used with @ref router::with_transform, handlers may
-    declare parameters of arbitrary types. At dispatch time,
-    each parameter type is looked up in @ref route_params::route_data.
-    If all parameters are found the handler is invoked; otherwise
-    @ref route_next is returned.
+    declare a first parameter of type `route_params&` followed
+    by additional parameters of arbitrary types. At dispatch time,
+    each extra parameter type is looked up in
+    @ref route_params::route_data via @ref polystore::find.
+    If all extra parameters are found the handler is invoked;
+    otherwise @ref route_next is returned.
+
+    Duplicate extra parameter types (after stripping cv-ref)
+    produce a compile-time error.
+
+    @par Example
+    @code
+    router<route_params> base;
+    auto r = base.with_transform( dynamic_transform{} );
+
+    r.get( "/users", [](
+        route_params& p,
+        UserService& svc,
+        Config const& cfg) -> route_result
+    {
+        // svc and cfg resolved from p.route_data
+        return route_done;
+    });
+    @endcode
 */
 struct dynamic_transform
 {