chore: route_params

Author: vinniefalco

include/boost/http_proto/server/basic_router.hpp

@@ -795,7 +795,7 @@ class basic_router : public /*detail::*/any_router
     }
 
 private:
-    // used to avoid a race when modifying res.resume_
+    // used to avoid a race when modifying req.resume_
     struct set_resume
     {
         std::size_t& resume;
@@ -806,10 +806,10 @@ class basic_router : public /*detail::*/any_router
                 resume = 0;
         }
         set_resume(
-            basic_response& res) noexcept
-            : resume(res.resume_)
+            basic_request& req) noexcept
+            : resume(req.resume_)
         {
-            resume = res.pos_;
+            resume = req.pos_;
         }
         void apply() noexcept
         {
@@ -877,11 +877,11 @@ class basic_router : public /*detail::*/any_router
         route_result invoke(Req& req, Res& res,
             std::integral_constant<int, 1>) const
         {
-            basic_response& res_(res);
-            if( res_.ec_.failed() ||
-                res_.ep_)
+            basic_request& req_(req);
+            if( req_.ec_.failed() ||
+                req_.ep_)
                 return http_proto::route::next;
-            set_resume u(res_);
+            set_resume u(req_);
             auto rv = h(req, res);
             if(rv == http_proto::route::detach)
             {
@@ -896,11 +896,11 @@ class basic_router : public /*detail::*/any_router
         invoke(Req& req, Res& res,
             std::integral_constant<int, 2>) const
         {
-            basic_response& res_(res);
-            if(! res_.ec_.failed())
+            basic_request& req_(req);
+            if(! req_.ec_.failed())
                 return http_proto::route::next;
-            set_resume u(res_);
-            auto rv = h(req, res, res_.ec_);
+            set_resume u(req_);
+            auto rv = h(req, res, req_.ec_);
             if(rv == http_proto::route::detach)
             {
                 u.apply();
@@ -913,10 +913,10 @@ class basic_router : public /*detail::*/any_router
         route_result invoke(Req& req, Res& res,
             std::integral_constant<int, 4>) const
         {
-            basic_response& res_(res);
-            if( res_.resume_ > 0 ||
-                (   ! res_.ec_.failed() &&
-                    ! res_.ep_))
+            basic_request& req_(req);
+            if( req_.resume_ > 0 ||
+                (   ! req_.ec_.failed() &&
+                    ! req_.ep_))
                 return h.dispatch_impl(req, res);
             return http_proto::route::next;
         }
@@ -944,16 +944,16 @@ class basic_router : public /*detail::*/any_router
         invoke(Req& req, Res& res) const override
         {
         #ifndef BOOST_NO_EXCEPTIONS
-            basic_response& res_(res);
-            if(! res_.ep_)
+            basic_request& req_(req);
+            if(! req_.ep_)
                 return http_proto::route::next;
             try
             {
-                std::rethrow_exception(res_.ep_);
+                std::rethrow_exception(req_.ep_);
             }
             catch(E const& ex)
             {
-                set_resume u(res_);
+                set_resume u(req_);
                 // VFALCO What if h throws?
                 auto rv = h(req, res, ex);
                 if(rv == http_proto::route::detach)
@@ -965,7 +965,7 @@ class basic_router : public /*detail::*/any_router
             }
             catch(...)
             {
-                BOOST_ASSERT(res_.ep_);
+                BOOST_ASSERT(req_.ep_);
                 return http_proto::route::next;
             }
         #else

include/boost/http_proto/server/router_types.hpp

@@ -314,11 +314,20 @@ class basic_request
 
 private:
     friend class /*detail::*/any_router;
+    template<class, class>
+    friend class basic_router;
     struct match_result;
-    http_proto::method verb_ =
-        http_proto::method::unknown;
+    basic_request& operator=(
+        basic_request const&) = delete;
+
     std::string verb_str_;
     std::string decoded_path_;
+    system::error_code ec_;
+    std::exception_ptr ep_;
+    std::size_t pos_ = 0;
+    std::size_t resume_ = 0;
+    http_proto::method verb_ =
+        http_proto::method::unknown;
     bool addedSlash_ = false;
     bool case_sensitive = false;
     bool strict = false;
@@ -337,11 +346,6 @@ class basic_response
     friend class /*detail::*/any_router;
     template<class, class>
     friend class basic_router;
-
-    std::size_t pos_ = 0;
-    std::size_t resume_ = 0;
-    system::error_code ec_;
-    std::exception_ptr ep_;
 };
 
 } // http_proto

src/server/basic_router.cpp

@@ -592,7 +592,7 @@ resume_impl(
     route_result ec) const ->
         route_result
 {
-    BOOST_ASSERT(res.resume_ > 0);
+    BOOST_ASSERT(req.resume_ > 0);
     if( ec == route::send ||
         ec == route::close ||
         ec == route::complete)
@@ -611,9 +611,9 @@ resume_impl(
         req.path.remove_suffix(1);
 
     // resume_ was set in the handler's wrapper
-    BOOST_ASSERT(res.resume_ == res.pos_);
-    res.pos_ = 0;
-    res.ec_ = ec;
+    BOOST_ASSERT(req.resume_ == req.pos_);
+    req.pos_ = 0;
+    req.ec_ = ec;
     return do_dispatch(req, res);
 }
 
@@ -627,9 +627,17 @@ dispatch_impl(
     basic_request& req,
     basic_response& res) const
 {
-    // VFALCO we could reuse the string storage by not clearing them
-    // set req.case_sensitive, req.strict to default of false
-    req = {};
+    req.verb_str_.clear();
+    req.decoded_path_.clear();
+    req.ec_.clear();
+    req.ep_ = nullptr;
+    req.pos_ = 0;
+    req.resume_ = 0;
+    req.verb_ = method::unknown;
+    req.addedSlash_ = false;
+    req.case_sensitive = false;
+    req.strict = false;
+
     if(verb == http_proto::method::unknown)
     {
         BOOST_ASSERT(! verb_str.empty());
@@ -664,13 +672,13 @@ dispatch_impl(
     auto rv = do_dispatch(req, res);
     if(rv == route::detach)
         return rv;
-    if(res.ep_)
+    if(req.ep_)
     {
-        res.ep_ = nullptr;
+        req.ep_ = nullptr;
         return error::unhandled_exception;
     }
-    if( res.ec_.failed())
-        res.ec_ = {};
+    if( req.ec_.failed())
+        req.ec_ = {};
     return rv;
 }
 
@@ -728,12 +736,12 @@ dispatch_impl(
     match_result mr;
     for(auto const& i : impl_->layers)
     {
-        if(res.resume_ > 0)
+        if(req.resume_ > 0)
         {
             auto const n = i.count(); // handlers in layer
-            if(res.pos_ + n < res.resume_)
+            if(req.pos_ + n < req.resume_)
             {
-                res.pos_ += n; // skip layer
+                req.pos_ += n; // skip layer
                 continue;
             }
             // repeat match to recreate the stack
@@ -743,29 +751,29 @@ dispatch_impl(
         }
         else
         {
-            if(i.match.end && res.ec_.failed())
+            if(i.match.end && req.ec_.failed())
             {
                 // routes can't have error handlers
-                res.pos_ += i.count(); // skip layer
+                req.pos_ += i.count(); // skip layer
                 continue;
             }
             if(! i.match(req, mr))
             {
                 // not a match
-                res.pos_ += i.count(); // skip layer
+                req.pos_ += i.count(); // skip layer
                 continue;
             }
         }
         for(auto it = i.entries.begin();
             it != i.entries.end(); ++it)
         {
             auto const& e(*it);
-            if(res.resume_)
+            if(req.resume_)
             {
                 auto const n = e.handler->count();
-                if(res.pos_ + n < res.resume_)
+                if(req.pos_ + n < req.resume_)
                 {
-                    res.pos_ += n; // skip entry
+                    req.pos_ += n; // skip entry
                     continue;
                 }
                 BOOST_ASSERT(e.match_method(req));
@@ -775,15 +783,15 @@ dispatch_impl(
                 // check verb for match 
                 if(! e.match_method(req))
                 {
-                    res.pos_ += e.handler->count(); // skip entry
+                    req.pos_ += e.handler->count(); // skip entry
                     continue;
                 }
             }
 
             route_result rv;
             // increment before invoke
-            ++res.pos_;
-            if(res.pos_ != res.resume_)
+            ++req.pos_;
+            if(req.pos_ != req.resume_)
             {
                 // call the handler
             #ifdef BOOST_NO_EXCEPTIONS
@@ -792,19 +800,19 @@ dispatch_impl(
                 try
                 {
                     rv = e.handler->invoke(req, res);
-                    if(res.ec_.failed())
-                        res.ep_ = {}; // transition to error mode
+                    if(req.ec_.failed())
+                        req.ep_ = {}; // transition to error mode
                 }
                 catch(...)
                 {
-                    if(res.ec_.failed())
-                        res.ec_ = {}; // transition to except mode
-                    res.ep_ = std::current_exception();
+                    if(req.ec_.failed())
+                        req.ec_ = {}; // transition to except mode
+                    req.ep_ = std::current_exception();
                     rv = route::next;
                 }
             #endif
 
-                // res.pos_ can be incremented further
+                // req.pos_ can be incremented further
                 // inside the above call to invoke.
                 if(rv == route::detach)
                 {
@@ -821,21 +829,21 @@ dispatch_impl(
                 // a subrouter never detaches on its own
                 BOOST_ASSERT(e.handler->count() == 1);
                 // can't detach on resume
-                if(res.ec_ == route::detach)
+                if(req.ec_ == route::detach)
                     detail::throw_invalid_argument();
                 // do resume
-                res.resume_ = 0;
-                rv = res.ec_;
-                res.ec_ = {};
+                req.resume_ = 0;
+                rv = req.ec_;
+                req.ec_ = {};
             }
             if( rv == route::send ||
                 rv == route::complete ||
                 rv == route::close)
             {
-                if( res.ec_.failed())
-                    res.ec_ = {};
-                if( res.ep_)
-                    res.ep_ = nullptr;
+                if( req.ec_.failed())
+                    req.ec_ = {};
+                if( req.ep_)
+                    req.ep_ = nullptr;
                 return rv;
             }
             if(rv == route::next)
@@ -846,7 +854,7 @@ dispatch_impl(
                 if(! i.match.end)
                     detail::throw_invalid_argument();
                 while(++it != i.entries.end())
-                    res.pos_ += it->handler->count();
+                    req.pos_ += it->handler->count();
                 break; // skip remaining entries
             }
             // we must handle all route enums
@@ -857,12 +865,12 @@ dispatch_impl(
                 detail::throw_invalid_argument();
             }
             // error handling mode
-            res.ec_ = rv;
+            req.ec_ = rv;
             if(! i.match.end)
                 continue; // next entry
             // routes don't have error handlers
             while(++it != i.entries.end())
-                res.pos_ += it->handler->count();
+                req.pos_ += it->handler->count();
             break; // skip remaining entries
         }
 
@@ -887,13 +895,13 @@ do_dispatch(
         // without attempting to perform any additional operations.
         return rv;
     }
-    if(! res.ec_.failed())
+    if(! req.ec_.failed())
     {
         // unhandled route
         return route::next;
     }
     // error condition
-    return res.ec_;
+    return req.ec_;
 }
 
 //} // detail