CXX-630 - Improve move semantics of model::write

Author: Tess Avitabile

src/bsoncxx/view_or_value.hpp

@@ -88,7 +88,8 @@ class view_or_value {
     ///
     /// Construct a view_or_value from a moved-in view_or_value.
     ///
-    BSONCXX_INLINE view_or_value(view_or_value&& other)
+    /// TODO CXX-800: Create a noexcept expression to check the conditions that must be met.
+    BSONCXX_INLINE view_or_value(view_or_value&& other) noexcept
         : _value{std::move(other._value)}, _view{_value ? _value->view() : std::move(other._view)} {
         other._view = View();
         other._value = stdx::nullopt;
@@ -97,7 +98,8 @@ class view_or_value {
     ///
     /// Assign to this view_or_value from a moved-in view_or_value.
     ///
-    BSONCXX_INLINE view_or_value& operator=(view_or_value&& other) {
+    /// TODO CXX-800: Create a noexcept expression to check the conditions that must be met.
+    BSONCXX_INLINE view_or_value& operator=(view_or_value&& other) noexcept {
         _value = std::move(other._value);
         _view = _value ? _value->view() : std::move(other._view);
         other._view = View();

src/mongocxx/bulk_write.cpp

@@ -90,8 +90,6 @@ void bulk_write::append(const model::write& operation) {
                                                   upsert);
             break;
         }
-        case write_type::k_uninitialized:
-            break;  // TODO: something exceptiony (see CXX-630)
     }
 }
 

src/mongocxx/model/write.cpp

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <type_traits>
+
 #include <mongocxx/model/write.hpp>
 
 #include <mongocxx/config/prelude.hpp>
@@ -21,23 +23,56 @@ MONGOCXX_INLINE_NAMESPACE_BEGIN
 namespace model {
 
 write::write(insert_one value) : _type(write_type::k_insert_one), _insert_one(std::move(value)) {
+    static_assert(std::is_nothrow_move_constructible<insert_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_assignable<insert_one>::value, "Move-assign may throw");
 }
 write::write(delete_one value) : _type(write_type::k_delete_one), _delete_one(std::move(value)) {
+    static_assert(std::is_nothrow_move_constructible<delete_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_assignable<delete_one>::value, "Move-assign may throw");
 }
 write::write(delete_many value) : _type(write_type::k_delete_many), _delete_many(std::move(value)) {
+    static_assert(std::is_nothrow_move_constructible<delete_many>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_assignable<delete_many>::value, "Move-assign may throw");
 }
 write::write(update_one value) : _type(write_type::k_update_one), _update_one(std::move(value)) {
+    static_assert(std::is_nothrow_move_constructible<update_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_assignable<update_one>::value, "Move-assign may throw");
 }
 write::write(update_many value) : _type(write_type::k_update_many), _update_many(std::move(value)) {
+    static_assert(std::is_nothrow_move_constructible<update_many>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_assignable<update_many>::value, "Move-assign may throw");
 }
 write::write(replace_one value) : _type(write_type::k_replace_one), _replace_one(std::move(value)) {
+    static_assert(std::is_nothrow_move_constructible<replace_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_assignable<replace_one>::value, "Move-assign may throw");
 }
 
-write::write(write&& rhs) noexcept : _type(write_type::k_uninitialized) {
-    *this = std::move(rhs);
+write::write(write&& rhs) noexcept {
+    switch (rhs._type) {
+        case write_type::k_insert_one:
+            new (&_insert_one) insert_one(std::move(rhs._insert_one));
+            break;
+        case write_type::k_update_one:
+            new (&_update_one) update_one(std::move(rhs._update_one));
+            break;
+        case write_type::k_update_many:
+            new (&_update_many) update_many(std::move(rhs._update_many));
+            break;
+        case write_type::k_delete_one:
+            new (&_delete_one) delete_one(std::move(rhs._delete_one));
+            break;
+        case write_type::k_delete_many:
+            new (&_delete_many) delete_many(std::move(rhs._delete_many));
+            break;
+        case write_type::k_replace_one:
+            new (&_replace_one) replace_one(std::move(rhs._replace_one));
+            break;
+    }
+
+    _type = rhs._type;
 }
 
-void write::destroy_member() {
+void write::destroy_member() noexcept {
     switch (_type) {
         case write_type::k_insert_one:
             _insert_one.~insert_one();
@@ -57,36 +92,34 @@ void write::destroy_member() {
         case write_type::k_replace_one:
             _replace_one.~replace_one();
             break;
-        case write_type::k_uninitialized:
-            break;
     }
-
-    _type = write_type::k_uninitialized;
 }
 
 write& write::operator=(write&& rhs) noexcept {
+    if (this == &rhs) {
+        return *this;
+    }
+
     destroy_member();
 
     switch (rhs._type) {
         case write_type::k_insert_one:
-            _insert_one = std::move(rhs._insert_one);
+            new (&_insert_one) insert_one(std::move(rhs._insert_one));
             break;
         case write_type::k_update_one:
-            _update_one = std::move(rhs._update_one);
+            new (&_update_one) update_one(std::move(rhs._update_one));
             break;
         case write_type::k_update_many:
-            _update_many = std::move(rhs._update_many);
+            new (&_update_many) update_many(std::move(rhs._update_many));
             break;
         case write_type::k_delete_one:
-            _delete_one = std::move(rhs._delete_one);
+            new (&_delete_one) delete_one(std::move(rhs._delete_one));
             break;
         case write_type::k_delete_many:
-            _delete_many = std::move(rhs._delete_many);
+            new (&_delete_many) delete_many(std::move(rhs._delete_many));
             break;
         case write_type::k_replace_one:
-            _replace_one = std::move(rhs._replace_one);
-            break;
-        case write_type::k_uninitialized:
+            new (&_replace_one) replace_one(std::move(rhs._replace_one));
             break;
     }
 

src/mongocxx/model/write.hpp

@@ -59,7 +59,7 @@ class MONGOCXX_API write {
     const replace_one& get_replace_one() const;
 
    private:
-    MONGOCXX_PRIVATE void destroy_member();
+    MONGOCXX_PRIVATE void destroy_member() noexcept;
 
     write_type _type;
 

src/mongocxx/write_type.hpp

@@ -26,7 +26,6 @@ enum class write_type {
     k_update_one,
     k_update_many,
     k_replace_one,
-    k_uninitialized,
 };
 
 MONGOCXX_INLINE_NAMESPACE_END