feat: serializers are default constructible and assignable

Author: vinniefalco

include/boost/http_proto/serializer.hpp

@@ -66,6 +66,63 @@ class serializer
     using const_buffers_type =
         boost::span<buffers::const_buffer const>;
 
+    /** Destructor
+    */
+    BOOST_HTTP_PROTO_DECL
+    ~serializer();
+
+    /** Constructor
+        Default-constructed serializers do not reference any implementation;
+        the only valid operations are destruction and assignment.
+    */
+    serializer() = default;
+
+    /** Constructor.
+
+        The states of `other` are transferred
+        to the newly constructed object,
+        which includes the allocated buffer.
+        After construction, the only valid
+        operations on the moved-from object
+        are destruction and assignment.
+
+        Buffer sequences previously obtained
+        using @ref prepare or @ref stream::prepare
+        remain valid.
+
+        @par Postconditions
+        @code
+        other.is_done() == true
+        @endcode
+
+        @par Complexity
+        Constant.
+
+        @param other The serializer to move from.
+    */
+    BOOST_HTTP_PROTO_DECL
+    serializer(
+        serializer&& other) noexcept;
+
+    /** Assignment.
+        The states of `other` are transferred
+        to this object, which includes the
+        allocated buffer. After assignment,
+        the only valid operations on the
+        moved-from object are destruction and
+        assignment.
+        Buffer sequences previously obtained
+        using @ref prepare or @ref stream::prepare
+        remain valid.
+        @par Complexity
+        Constant.
+        @param other The serializer to move from.
+        @return A reference to this object.
+    */
+    BOOST_HTTP_PROTO_DECL
+    serializer&
+    operator=(serializer&& other) noexcept;
+
     /** Constructor.
 
         Constructs a serializer that uses the @ref
@@ -116,38 +173,6 @@ class serializer
     serializer(
         const rts::context& ctx);
 
-    /** Constructor.
-
-        The states of `other` are transferred
-        to the newly constructed object,
-        which includes the allocated buffer.
-        After construction, the only valid
-        operations on the moved-from object
-        are destruction and assignment.
-
-        Buffer sequences previously obtained
-        using @ref prepare or @ref stream::prepare
-        remain valid.
-
-        @par Postconditions
-        @code
-        other.is_done() == true
-        @endcode
-
-        @par Complexity
-        Constant.
-
-        @param other The serializer to move from.
-    */
-    BOOST_HTTP_PROTO_DECL
-    serializer(
-        serializer&& other) noexcept;
-
-    /** Destructor
-    */
-    BOOST_HTTP_PROTO_DECL
-    ~serializer();
-
     /** Reset the serializer for a new message.
 
         Aborts any ongoing serialization and
@@ -536,7 +561,7 @@ class serializer
         message_base const&,
         source&);
 
-    impl* impl_;
+    impl* impl_ = nullptr;
 };
 
 /** Serializer configuration settings.

src/serializer.cpp

@@ -931,11 +931,9 @@ class serializer::impl
 //------------------------------------------------
 
 serializer::
-serializer(const rts::context& ctx)
-    : impl_(new impl(ctx))
+~serializer()
 {
-    // TODO: use a single allocation for
-    // impl and workspace buffer.
+    delete impl_;
 }
 
 serializer::
@@ -945,10 +943,25 @@ serializer(serializer&& other) noexcept
     other.impl_ = nullptr;
 }
 
+serializer&
 serializer::
-~serializer()
+operator=(serializer&& other) noexcept
 {
-    delete impl_;
+    if(this != &other)
+    {
+        delete impl_;
+        impl_ = other.impl_;
+        other.impl_ = nullptr;
+    }
+    return *this;
+}
+
+serializer::
+serializer(rts::context const& ctx)
+    : impl_(new impl(ctx))
+{
+    // TODO: use a single allocation for
+    // impl and workspace buffer.
 }
 
 void

test/unit/serializer.cpp

@@ -211,7 +211,7 @@ struct serializer_test
     }
 
     void
-    testSpecialMembers()
+    testSpecial()
     {
         rts::context ctx;
         install_serializer_service(ctx, {});
@@ -222,6 +222,21 @@ struct serializer_test
         // empty body final chunk
         expected.append("0\r\n\r\n");
 
+        // serializer()
+        {
+            BOOST_TEST_NO_THROW(serializer());
+        }
+
+        // operator=(serializer&&)
+        {
+            serializer sr;
+            BOOST_TEST_NO_THROW(sr = serializer());
+        }
+        {
+            serializer sr;
+            BOOST_TEST_NO_THROW(sr = serializer(ctx));
+        }
+
         // serializer(serializer&&)
         {
             std::string message;
@@ -956,7 +971,7 @@ struct serializer_test
     run()
     {
         testSyntax();
-        testSpecialMembers();
+        testSpecial();
         testEmptyBody();
         testOutput();
         testExpect100Continue();