parser constructs sink in-place

Author: ashtum

include/boost/http_proto/impl/parser.hpp

@@ -91,14 +91,13 @@ set_body(
 
 //------------------------------------------------
 
-template<class Sink>
-typename std::enable_if<
-    is_sink<Sink>::value,
-    typename std::decay<Sink>::type
-        >::type&
+template<
+    class Sink,
+    class... Args,
+    class>
+Sink&
 parser::
-set_body(
-    Sink&& sink)
+set_body(Args&&... args)
 {
     // body must not be set already
     if(how_ != how::in_place)
@@ -109,7 +108,7 @@ set_body(
         detail::throw_logic_error();
 
     auto& s = ws_.emplace<Sink>(
-        std::forward<Sink>(sink));
+        std::forward<Args>(args)...);
     sink_ = &s;
     how_ = how::sink;
     on_set_body();

include/boost/http_proto/parser.hpp

@@ -312,16 +312,16 @@ class BOOST_SYMBOL_VISIBLE
 
     /** Attach a body
     */
-    template<class Sink>
+    template<
+        class Sink,
+        class... Args
 #ifndef BOOST_HTTP_PROTO_DOCS
-    typename std::enable_if<
-            is_sink<Sink>::value,
-        typename std::decay<Sink>::type
-            >::type&
-#else
-    typename std::decay<Sink>::type&
+        ,class = typename std::enable_if<
+            is_sink<Sink>::value>::type
 #endif
-    set_body(Sink&& sink);
+    >
+    Sink&
+    set_body(Args&&... args);
 
     /** Return the available body data.
 
@@ -374,7 +374,7 @@ class BOOST_SYMBOL_VISIBLE
 
     BOOST_HTTP_PROTO_DECL
     void
-    on_set_body();
+    on_set_body() noexcept;
 
     std::size_t
     apply_filter(

include/boost/http_proto/sink.hpp

@@ -34,7 +34,6 @@ namespace http_proto {
 */
 struct BOOST_HTTP_PROTO_DECL
     sink
-    : buffered_base
 {
     /** The results of consuming data.
     */

src/parser.cpp

@@ -1492,24 +1492,16 @@ on_headers(
 // Called at the end of set_body
 void
 parser::
-on_set_body()
+on_set_body() noexcept
 {
-    // This function is called after all
-    // limit checking and calculation of
-    // chunked or filter.
-
-    BOOST_ASSERT(got_header());
+    BOOST_ASSERT(
+        st_ == state::complete_in_place ||
+        st_ == state::body);
 
     nprepare_ = 0; // invalidate
 
     if(st_ == state::body)
-    {
         st_ = state::set_body;
-        return;
-    }
-
-    BOOST_ASSERT(
-        st_ == state::complete_in_place);
 }
 
 std::size_t

test/unit/parser.cpp

@@ -1336,7 +1336,7 @@ struct parser_test
             BOOST_TEST_EQ(ec, ex);
             return;
         }
-        auto& ts = pr_->set_body(test_sink{});
+        auto& ts = pr_->set_body<test_sink>();
         pr_->parse(ec);
         BOOST_TEST(pr_->body().empty());
         if(! pr_->is_complete())

test/unit/zlib.cpp

@@ -616,7 +616,6 @@ struct zlib_test
         response_parser& pr,
         buffers::const_buffer input)
     {
-        std::string rs;
         std::size_t n1 = buffers::buffer_copy(
                 pr.prepare(), input);
         input = buffers::sans_prefix(input, n1);
@@ -627,30 +626,30 @@ struct zlib_test
 
         class sink_t : public sink
         {
-            std::string* body_;
+            std::string body_;
 
         public:
-            sink_t(std::string* body)
-                : body_{ body }
+            std::string
+            get_body()
             {
+                return body_;
             }
 
             results
             on_write(
                 buffers::const_buffer b,
                 bool) override
             {
-                body_->append(
-                    static_cast<
-                        const char*>(b.data()),
+                body_.append(
+                    static_cast<const char*>(b.data()),
                     b.size());
                 results rv;
                 rv.bytes = b.size();
                 return rv;
             }
         };
 
-        pr.set_body<sink_t>(&rs);
+        auto& sink = pr.set_body<sink_t>();
         pr.parse(ec);
 
         while(ec == error::need_data)
@@ -667,7 +666,7 @@ struct zlib_test
                 break;
             }
         }
-        return rs;
+        return sink.get_body();
     }
 
     void