router converting constructors

Author: vinniefalco

include/boost/http/server/router.hpp

@@ -391,6 +391,8 @@ struct identity
 template<class P = route_params, class HT = identity>
 class router : public detail::router_base
 {
+    template<class, class> friend class router;
+
     HT ht_{};
 
     static_assert(std::derived_from<P, route_params>);
@@ -601,25 +603,43 @@ class router : public detail::router_base
     /** Construct a router from another router with compatible types.
 
         This constructs a router that shares the same underlying routing
-        state as another router whose params type is a base class of `Params`.
+        state as another router whose params and handler transform types
+        may differ.
 
-        The resulting router participates in shared ownership of the
-        implementation; copying the router does not duplicate routes or
-        handlers, and changes visible through one router are visible
-        through all routers that share the same underlying state.
+        The handler transform is initialized as follows:
+        - If `HT` is constructible from `OtherHT`, the transform is
+          move-constructed from the source router's transform.
+        - Otherwise, if `HT` is default-constructible, the transform
+          is value-initialized.
 
         @par Constraints
 
-        `Params` must be derived from `OtherParams`.
+        `OtherParams` must be derived from `Params`, and `HT` must be
+        either constructible from `OtherHT` or default-constructible.
 
         @param other The router to construct from.
 
         @tparam OtherParams The params type of the source router.
+
+        @tparam OtherHT The handler transform type of the source router.
     */
-    template<class OtherP>
-        requires std::derived_from<OtherP, P>
+    template<class OtherP, class OtherHT>
+        requires std::derived_from<OtherP, P> &&
+            std::constructible_from<HT, OtherHT>
+    router(
+        router<OtherP, OtherHT>&& other) noexcept
+        : detail::router_base(std::move(other))
+        , ht_(std::move(other.ht_))
+    {
+    }
+
+    /// @copydoc router(router<OtherP,OtherHT>&&)
+    template<class OtherP, class OtherHT>
+        requires std::derived_from<OtherP, P> &&
+            (!std::constructible_from<HT, OtherHT>) &&
+            std::default_initializable<HT>
     router(
-        router<OtherP>&& other) noexcept
+        router<OtherP, OtherHT>&& other) noexcept
         : detail::router_base(std::move(other))
     {
     }

test/unit/server/router.cpp

@@ -21,6 +21,24 @@ struct router_test
     using params = route_params;
     using test_router = router<params>;
 
+    struct derived_params : params {};
+
+    struct my_transform
+    {
+        template<class T>
+        T operator()(T&& t) const
+        { return std::forward<T>(t); }
+    };
+
+    struct base_ht
+    {
+        template<class T>
+        T operator()(T&& t) const
+        { return std::forward<T>(t); }
+    };
+
+    struct derived_ht : base_ht {};
+
     //--------------------------------------------
     // Simple handlers - no destructor verification
     //--------------------------------------------
@@ -435,6 +453,51 @@ struct router_test
         { test_router r; r.add(GET, "/auth/login", h_next); check(r, GET, "/auth%2flogin", route_next); }
     }
 
+    void testCrossTypeConstruction()
+    {
+        // HT constructible from OtherHT (identity -> identity)
+        {
+            router<params> r1;
+            r1.use(h_send);
+            router<params> r2(std::move(r1));
+            check(r2, "/");
+        }
+
+        // different P, same default HT
+        {
+            router<derived_params> r1;
+            r1.use([](derived_params&) -> route_task
+                { co_return route_result{}; });
+            router<params> r2(std::move(r1));
+            (void)r2;
+        }
+
+        // HT not constructible from OtherHT, but default constructible
+        {
+            router<params> r1;
+            r1.use(h_send);
+            router<params, my_transform> r2(std::move(r1));
+            (void)r2;
+        }
+
+        // HT constructible from OtherHT (derived -> base)
+        {
+            router<params, derived_ht> r1;
+            r1.use(h_send);
+            router<params, base_ht> r2(std::move(r1));
+            (void)r2;
+        }
+
+        // both P and HT differ
+        {
+            router<derived_params> r1;
+            r1.use([](derived_params&) -> route_task
+                { co_return route_result{}; });
+            router<params, my_transform> r2(std::move(r1));
+            (void)r2;
+        }
+    }
+
     void run()
     {
         testUse();
@@ -445,6 +508,7 @@ struct router_test
         testOptions();
         testDispatch();
         testPathDecoding();
+        testCrossTypeConstruction();
     }
 };