Fix[mqbblp]: Fix build on Solaris

This patch fixes a build error on Solaris/C++03: the new `ElectorEventFunctor`
constructor takes a `bslmf::MovableRef<bmqp::Event>`, which in C++11 is an
alias for `bmqp::Event&&`.  In C++03, though, temporary objects are not
automatically converted into `MovableRef`s, resulting in an invocation of the
`createInplace` function template to fail instantiation.  We solve this by
explicitly calling `bslmf::MovableRefUtil::move` on this temporary, which is a
no-op in C++11 but a necessary call in C++03.

Signed-off-by: Patrick M. Niedzielski <[email protected]>

Author: pniedzielski

src/groups/bmq/bmqp/bmqp_event.h

@@ -52,6 +52,7 @@
 #include <bsl_string.h>
 #include <bslma_allocator.h>
 #include <bslma_usesbslmaallocator.h>
+#include <bslmf_movableref.h>
 #include <bslmf_nestedtraitdeclaration.h>
 #include <bsls_assert.h>
 #include <bsls_performancehint.h>
@@ -133,11 +134,21 @@ class Event {
     /// specified `allocator`.
     Event(const Event& src, bslma::Allocator* allocator = 0);
 
+    /// Create a new `bmqp::Event` instance having the same contents as the
+    /// specified `original` object, leaving `original` in a valid but
+    /// unspecified state.  Optionally specify an `allocator` used to supply
+    /// memory.  If `allocator` is 0, the default memory allocator is used.
+    Event(bslmf::MovableRef<Event> src, bslma::Allocator* allocator = 0);
+
     // MANIPULATORS
 
     /// Assignment operator of the specified `rhs`.
     Event& operator=(const Event& rhs);
 
+    /// Replace the contents of `*this` with those of `rhs`, leaving `rhs` in a
+    /// valid but unspecified state.  Return `*this`.
+    Event& operator=(bslmf::MovableRef<Event> rhs);
+
     /// Reset this Event to use the specified `blob`.  If the optionally
     /// specified `clone` is true, this object will clone the blob into its
     /// internal shared pointer.
@@ -390,6 +401,15 @@ inline Event::Event(const Event& src, bslma::Allocator* allocator)
     initialize(src.d_blob_p, false);
 }
 
+inline Event::Event(bslmf::MovableRef<Event> src, bslma::Allocator* allocator)
+: d_allocator_p(allocator)
+, d_clonedBlob_sp(0, allocator)
+, d_blob_p(0)
+{
+    d_clonedBlob_sp = bslmf::MovableRefUtil::access(src).d_clonedBlob_sp;
+    initialize(bslmf::MovableRefUtil::access(src).d_blob_p, false);
+}
+
 inline Event& Event::operator=(const Event& rhs)
 {
     if (this != &rhs) {
@@ -399,6 +419,15 @@ inline Event& Event::operator=(const Event& rhs)
     return *this;
 }
 
+inline Event& Event::operator=(bslmf::MovableRef<Event> rhs)
+{
+    if (this != &bslmf::MovableRefUtil::access(rhs)) {
+        d_clonedBlob_sp = bslmf::MovableRefUtil::access(rhs).d_clonedBlob_sp;
+        initialize(bslmf::MovableRefUtil::access(rhs).d_blob_p, false);
+    }
+    return *this;
+}
+
 inline void Event::reset(const bdlbb::Blob* blob, bool clone)
 {
     // PRECONDITIONS

src/groups/mqb/mqbblp/mqbblp_clusterorchestrator.cpp

@@ -44,6 +44,7 @@
 #include <bsl_string.h>
 #include <bsl_vector.h>
 #include <bsla_annotations.h>
+#include <bslmf_movableref.h>
 #include <bsls_assert.h>
 #include <bsls_timeinterval.h>
 
@@ -1272,10 +1273,11 @@ void ClusterOrchestrator::processElectorEvent(const bmqp::Event&   event,
 
     (*clusterEvent).setType(mqbi::DispatcherEventType::e_CALLBACK);
 
+    bmqp::Event clonedEvent = event.clone(d_allocator_p);
     clusterEvent->callback()
         .createInplace<ClusterOrchestrator::OnElectorEventFunctor>(
             this,
-            event.clone(d_allocator_p),
+            bslmf::MovableRefUtil::move(clonedEvent),
             source);
 
     dispatcher()->dispatchEvent(clusterEvent, d_cluster_p);