Firebase cpp: Added noexcept to ensure STL will use move constructor for containers

PiperOrigin-RevId: 277341338

Author: markchandler

app/rest/controller_curl.cc

@@ -45,11 +45,11 @@ ControllerCurl::~ControllerCurl() {
 }
 
 #if defined(FIREBASE_USE_MOVE_OPERATORS) || defined(DOXYGEN)
-ControllerCurl::ControllerCurl(ControllerCurl&& other) {
+ControllerCurl::ControllerCurl(ControllerCurl&& other) noexcept {
   *this = std::move(other);
 }
 
-ControllerCurl& ControllerCurl::operator=(ControllerCurl&& other) {
+ControllerCurl& ControllerCurl::operator=(ControllerCurl&& other) noexcept {
   direction_ = other.direction_;
   transport_ = other.transport_;
   is_paused_ = other.is_paused_;

app/rest/controller_curl.h

@@ -54,9 +54,9 @@ class ControllerCurl : public Controller {
   ~ControllerCurl() override;
 
 #if defined(FIREBASE_USE_MOVE_OPERATORS) || defined(DOXYGEN)
-  ControllerCurl(ControllerCurl&& other);
+  ControllerCurl(ControllerCurl&& other) noexcept;
 
-  ControllerCurl& operator=(ControllerCurl&& other);
+  ControllerCurl& operator=(ControllerCurl&& other) noexcept;
 #endif  // defined(FIREBASE_USE_MOVE_OPERATORS) || defined(DOXYGEN)
 
   // Pauses whatever the handle is doing.

app/src/include/firebase/future.h

@@ -117,10 +117,10 @@ class FutureBase {
   /// Move constructor and operator.
   /// Move is more efficient than copy and delete because we don't touch the
   /// reference counting in the API.
-  FutureBase(FutureBase&& rhs);
+  FutureBase(FutureBase&& rhs) noexcept;
 
   /// Copy an untyped future.
-  FutureBase& operator=(FutureBase&& rhs);
+  FutureBase& operator=(FutureBase&& rhs) noexcept;
 #endif  // defined(FIREBASE_USE_MOVE_OPERATORS)
 
   /// Explicitly release the internal resources for a future.

app/src/include/firebase/internal/future_impl.h

@@ -231,15 +231,15 @@ inline FutureBase& FutureBase::operator=(const FutureBase& rhs) {
 }
 
 #if defined(FIREBASE_USE_MOVE_OPERATORS)
-inline FutureBase::FutureBase(FutureBase&& rhs)
+inline FutureBase::FutureBase(FutureBase&& rhs) noexcept
     : api_(NULL)  // NOLINT
 {
   detail::UnregisterForCleanup(rhs.api_, &rhs);
   *this = std::move(rhs);
   detail::RegisterForCleanup(api_, this);
 }
 
-inline FutureBase& FutureBase::operator=(FutureBase&& rhs) {
+inline FutureBase& FutureBase::operator=(FutureBase&& rhs) noexcept {
   Release();
   detail::UnregisterForCleanup(rhs.api_, &rhs);
   api_ = rhs.api_;

app/src/include/firebase/variant.h

@@ -240,15 +240,15 @@ class Variant {
   /// simply reassigning pointer ownership.
   ///
   /// @param[in] other Source Variant to move from.
-  Variant(Variant&& other) : type_(kInternalTypeNull) {
+  Variant(Variant&& other) noexcept : type_(kInternalTypeNull) {
     *this = std::move(other);
   }
 
   /// @brief Move assignment operator. Efficiently moves the more complex data
   /// types by simply reassigning pointer ownership.
   ///
   /// @param[in] other Source Variant to move from.
-  Variant& operator=(Variant&& other);
+  Variant& operator=(Variant&& other) noexcept;
 
 #endif  // defined(FIREBASE_USE_MOVE_OPERATORS) || defined(DOXYGEN)
 #endif  // SWIG

app/src/intrusive_list.h

@@ -251,9 +251,9 @@ class intrusive_list {
       : data_(&data_, &data_), node_offset_(offset_of_node(node_member)) {}
 
 #if defined(FIREBASE_USE_MOVE_OPERATORS)
-  intrusive_list(this_type&& other) { *this = std::move(other); }
+  intrusive_list(this_type&& other) noexcept { *this = std::move(other); }
 
-  intrusive_list& operator=(this_type&& other) {
+  intrusive_list& operator=(this_type&& other) noexcept {
     data_ = std::move(other.data_);
     node_offset_ = std::move(other.node_offset_);
     return *this;

app/src/jobject_reference.cc

@@ -39,7 +39,7 @@ JObjectReference::JObjectReference(const JObjectReference& reference) {
 }
 
 #ifdef FIREBASE_USE_MOVE_OPERATORS
-JObjectReference::JObjectReference(JObjectReference&& reference) {
+JObjectReference::JObjectReference(JObjectReference&& reference) noexcept {
   operator=(std::move(reference));
 }
 #endif  // FIREBASE_USE_MOVE_OPERATORS
@@ -53,7 +53,8 @@ JObjectReference& JObjectReference::operator=(
 }
 
 #ifdef FIREBASE_USE_MOVE_OPERATORS
-JObjectReference& JObjectReference::operator=(JObjectReference&& reference) {
+JObjectReference& JObjectReference::operator=(JObjectReference&& reference)
+    noexcept {
   java_vm_ = reference.java_vm_;
   object_ = reference.object_;
   reference.java_vm_ = nullptr;

app/src/jobject_reference.h

@@ -66,15 +66,15 @@ class JObjectReference {
   JObjectReference(const JObjectReference& reference);
   // Move
 #ifdef FIREBASE_USE_MOVE_OPERATORS
-  JObjectReference(JObjectReference&& reference);
+  JObjectReference(JObjectReference&& reference) noexcept;
 #endif  // FIREBASE_USE_MOVE_OPERATORS
   // Delete the reference to the java object.
   ~JObjectReference();
   // Copy this reference.
   JObjectReference& operator=(const JObjectReference& reference);
   // Move this reference.
 #ifdef FIREBASE_USE_MOVE_OPERATORS
-  JObjectReference& operator=(JObjectReference&& reference);
+  JObjectReference& operator=(JObjectReference&& reference) noexcept;
 #endif  // FIREBASE_USE_MOVE_OPERATORS
 
   // Add a global reference to the specified object, removing the reference

app/src/optional.h

@@ -69,7 +69,7 @@ class Optional {
 #if defined(FIREBASE_USE_MOVE_OPERATORS)
   // Move contructor. If the other Optional has a value, it is moved into this
   // Optional using its move constructor.
-  Optional(Optional&& other) : has_value_(other.has_value_) {
+  Optional(Optional&& other) noexcept : has_value_(other.has_value_) {
     if (has_value()) {
       new (aligned_buffer()) value_type(std::move(other.value()));
       other.reset();
@@ -78,7 +78,7 @@ class Optional {
 
   // Move assignment. If the other Optional has a value, it is move constructed
   // or move assigned into this Optional.
-  Optional& operator=(Optional&& other) {
+  Optional& operator=(Optional&& other) noexcept {
     if (other.has_value()) {
       *this = std::move(other.value());
     } else {

app/src/variant.cc

@@ -86,7 +86,7 @@ Variant& Variant::operator=(const Variant& other) {
 
 #if defined(FIREBASE_USE_MOVE_OPERATORS)
 
-Variant& Variant::operator=(Variant&& other) {
+Variant& Variant::operator=(Variant&& other) noexcept {
   if (this != &other) {
     Clear();
     type_ = other.type_;