dynamic_invoke

Author: vinniefalco

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

@@ -39,6 +39,28 @@ using find_key_t =
     std::remove_cv_t<
         std::remove_reference_t<T>>;
 
+// Polystore lookup key: also strips pointer
+template<class T>
+using lookup_key_t =
+    std::remove_cv_t<
+        std::remove_pointer_t<
+            find_key_t<T>>>;
+
+// True when parameter is a pointer (optional dependency)
+template<class T>
+constexpr bool is_optional_v =
+    std::is_pointer_v<find_key_t<T>>;
+
+// Resolve a polystore pointer to the handler's expected arg
+template<class Arg, class T>
+auto resolve_arg(T* p)
+{
+    if constexpr (is_optional_v<Arg>)
+        return static_cast<find_key_t<Arg>>(p);
+    else
+        return static_cast<Arg>(*p);
+}
+
 //------------------------------------------------
 
 template<class F, class... Args>
@@ -49,43 +71,47 @@ dynamic_invoke_impl(
     type_list<Args...> const&)
 {
     static_assert(
-        are_unique<find_key_t<Args>...>::value,
+        are_unique<lookup_key_t<Args>...>::value,
         "callable has duplicate parameter types");
 
     auto ptrs = std::make_tuple(
-        ps.find<find_key_t<Args>>()...);
-
-    bool all_found = std::apply(
-        [](auto*... p)
-        {
-            return (... && (p != nullptr));
-        }, ptrs);
-
-    if(! all_found)
-        return route_next;
+        ps.find<lookup_key_t<Args>>()...);
 
-    return std::apply(
-        [&](auto*... p) -> route_result
+    return [&]<std::size_t... I>(
+        std::index_sequence<I...>) -> route_result
+    {
+        if constexpr (!(is_optional_v<Args> && ...))
         {
-            return f(*p...);
-        }, ptrs);
+            if(! (... && (is_optional_v<Args> ||
+                std::get<I>(ptrs) != nullptr)))
+                return route_next;
+        }
+        return f(resolve_arg<Args>(
+            std::get<I>(ptrs))...);
+    }(std::index_sequence_for<Args...>{});
 }
 
 /** Invoke a callable, resolving arguments from a polystore.
 
     Each parameter type of the callable is looked up in the
-    polystore via @ref polystore::find. If all parameters are
-    found, the callable is invoked with the resolved arguments
-    and its result is returned. If any parameter is not found,
-    @ref route_next is returned without invoking the callable.
+    polystore via @ref polystore::find. If all required
+    parameters are found, the callable is invoked with the
+    resolved arguments and its result is returned. If any
+    required parameter is not found, @ref route_next is
+    returned without invoking the callable.
+
+    Parameters declared as pointer types (e.g. `A*`) are
+    optional: `nullptr` is passed when the type is absent.
+    Rvalue reference parameters (e.g. `A&&`) are supported
+    and receive a moved reference to the stored object.
 
-    Duplicate parameter types (after stripping cv-ref) produce
-    a compile-time error.
+    Duplicate parameter types (after stripping cv-ref and
+    pointer) produce a compile-time error.
 
     @param ps The polystore to resolve arguments from.
     @param f The callable to invoke.
     @return The result of the callable, or @ref route_next
-    if any parameter was not found.
+    if any required parameter was not found.
 */
 template<class F>
 route_result
@@ -101,26 +127,139 @@ dynamic_invoke(
 
 //------------------------------------------------
 
+/** 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&");
+        using R = std::invoke_result_t<
+            F const&, route_params&>;
+        if constexpr (std::is_same_v<R, route_task>)
+            return f(p);
+        else
+            return wrap_result(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&");
+        return invoke_extras(p, type_list<E1, Extra...>{});
+    }
+
+    template<class... Extras>
+    route_task
+    invoke_extras(
+        route_params& p,
+        type_list<Extras...> const&) const
+    {
+        static_assert(
+            are_unique<
+                lookup_key_t<Extras>...>::value,
+            "callable has duplicate parameter types");
+
+        auto ptrs = std::make_tuple(
+            p.route_data.template find<
+                lookup_key_t<Extras>>()...);
+
+        return [this, &p, &ptrs]<std::size_t... I>(
+            std::index_sequence<I...>) -> route_task
+        {
+            if constexpr (!(is_optional_v<Extras> && ...))
+            {
+                if(! (... && (is_optional_v<Extras> ||
+                    std::get<I>(ptrs) != nullptr)))
+                    return make_route_next();
+            }
+
+            using R = std::invoke_result_t<
+                F const&, route_params&, Extras...>;
+            if constexpr (std::is_same_v<R, route_task>)
+                return f(p, resolve_arg<Extras>(
+                    std::get<I>(ptrs))...);
+            else
+                return wrap_result(f(p,
+                    resolve_arg<Extras>(
+                        std::get<I>(ptrs))...));
+        }(std::index_sequence_for<Extras...>{});
+    }
+
     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 required parameters are found the handler is invoked;
+    otherwise @ref route_next is returned.
+
+    Parameters declared as pointer types (e.g. `A*`) are
+    optional: `nullptr` is passed when the type is absent.
+    Rvalue reference parameters (e.g. `A&&`) are supported
+    and receive a moved reference to the stored object.
+
+    Duplicate extra parameter types (after stripping cv-ref
+    and pointer) 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
 {

test/limits/Jamfile

@@ -22,6 +22,7 @@ project
       <include>../..
       <include>../../../url/extra/test_suite
       <library>/boost//capy
+      <library>/boost/json//boost_json/<warnings-as-errors>off
       <library>/boost//url
     ;
 

test/unit/server/router.cpp

@@ -10,6 +10,7 @@
 // Test that header file is self-contained.
 #include <boost/http/server/router.hpp>
 
+#include <boost/http/server/detail/dynamic_invoke.hpp>
 #include <boost/capy/test/run_blocking.hpp>
 #include "test_suite.hpp"
 
@@ -39,6 +40,8 @@ struct router_test
 
     struct derived_ht : base_ht {};
 
+    struct A { int value = 0; };
+
     //--------------------------------------------
     // Simple handlers - no destructor verification
     //--------------------------------------------
@@ -498,6 +501,63 @@ struct router_test
         }
     }
 
+    void testDynamicTransform()
+    {
+        // A&& parameter with A present
+        {
+            test_router base;
+            auto r = base.with_transform(
+                detail::dynamic_transform{});
+            r.use([](params& p) -> route_result
+            {
+                p.route_data.insert(A{42});
+                return route_next;
+            });
+            r.use([](params&) -> route_result
+            {
+                return route_next;
+            });
+            r.use([](params&, A&& a) -> route_result
+            {
+                BOOST_TEST_EQ(a.value, 42);
+                return route_done;
+            });
+            check(base, "/");
+        }
+
+        // A* parameter with A present
+        {
+            test_router base;
+            auto r = base.with_transform(
+                detail::dynamic_transform{});
+            r.use([](params& p) -> route_result
+            {
+                p.route_data.insert(A{99});
+                return route_next;
+            });
+            r.use([](params&, A* a) -> route_result
+            {
+                BOOST_TEST(a != nullptr);
+                BOOST_TEST_EQ(a->value, 99);
+                return route_done;
+            });
+            check(base, "/");
+        }
+
+        // A* parameter with A absent
+        {
+            test_router base;
+            auto r = base.with_transform(
+                detail::dynamic_transform{});
+            r.use([](params&, A* a) -> route_result
+            {
+                BOOST_TEST(a == nullptr);
+                return route_done;
+            });
+            check(base, "/");
+        }
+    }
+
     void run()
     {
         testUse();
@@ -509,6 +569,7 @@ struct router_test
         testDispatch();
         testPathDecoding();
         testCrossTypeConstruction();
+        testDynamicTransform();
     }
 };