Add const qualifier to constructor port parameter

[ric-plt/xapp-frame-cpp.git] / src / messaging / messenger.cpp

diff --git a/src/messaging/messenger.cpp b/src/messaging/messenger.cpp
index d4033c3..4e5a278 100644 (file)
--- a/src/messaging/messenger.cpp
+++ b/src/messaging/messenger.cpp
@@ -60,13 +60,15 @@ const int Messenger::DEFAULT_CALLBACK = -1;
 
        If port is nil, then the default port is used (4560).
 */
-Messenger::Messenger( char* port, bool wait4table ) {
-       if( port == NULL ) {
-               port = (char *) "4560";
+Messenger::Messenger( const char* uport, bool wait4table ) {
+
+       if( uport == NULL ) {
+               listen_port = strdup( "4560" );
+       } else {
+               listen_port = strdup( uport );
        }
 
        gate = new std::mutex();
-       listen_port = strdup( port );
        mrc = rmr_init( listen_port, Messenger::MAX_PAYLOAD, 0 );
 
        if( wait4table ) {
@@ -78,6 +80,52 @@ Messenger::Messenger( char* port, bool wait4table ) {
        ok_2_run = true;
 }
 
+/*
+       Move support. We DO allow the instance to be moved as only one copy
+       remains following the move.
+       Given a source object instance (soi) we move the information to
+       the new object, and then DELETE what was moved so that when the
+       user frees the soi, it doesn't destroy what we snarfed.
+*/
+Messenger::Messenger( Messenger&& soi ) {
+       mrc = soi.mrc;
+       listen_port = soi.listen_port;
+       ok_2_run = soi.ok_2_run;
+       gate = soi.gate;
+               cb_hash = soi.cb_hash;                          // this seems dodgy
+
+       soi.gate = NULL;
+       soi.listen_port = NULL;
+       soi.mrc = NULL;
+}
+
+/*
+       Move operator. Given a source object instance, movee it's contents
+       to this insance.  We must first clean up this instance.
+*/
+Messenger& Messenger::operator=( Messenger&& soi ) {
+       if( this != &soi ) {                            // cannot move onto ourself
+               if( mrc != NULL ) {
+                       rmr_close( mrc );
+               }
+               if( listen_port != NULL ) {
+                       free( listen_port );
+               }
+
+               mrc = soi.mrc;
+               listen_port = soi.listen_port;
+               ok_2_run = soi.ok_2_run;
+               gate = soi.gate;
+                       cb_hash = soi.cb_hash;                          // this seems dodgy
+
+               soi.gate = NULL;
+               soi.listen_port = NULL;
+               soi.mrc = NULL;
+       }
+
+       return *this;
+}
+
 /*
        Destroyer.
 */
@@ -86,7 +134,9 @@ Messenger::~Messenger() {
                rmr_close( mrc );
        }
 
-       free( listen_port );
+       if( listen_port != NULL ) {
+               free( listen_port );
+       }
 }
 
 /*
@@ -148,8 +198,8 @@ void Messenger::Listen( ) {
                                        sel_cb = mi->second;                                                            // override with user callback
                                }
                                if( sel_cb != NULL ) {
-                                       sel_cb->Drive_cb( *this, *m );                                          // drive the selected one
-                                       mbuf = NULL;                                                                            // not safe to use after given to cb
+                                       sel_cb->Drive_cb( *m );                                                 // drive the selected one
+                                       mbuf = NULL;                                                                    // not safe to use after given to cb
                                }
                        } else {
                                if( mbuf->state != RMR_ERR_TIMEOUT ) {
@@ -165,18 +215,16 @@ void Messenger::Listen( ) {
 */
 std::unique_ptr<Message>  Messenger::Receive( int timeout ) {
        rmr_mbuf_t*     mbuf = NULL;
-       //std::unique_ptr<Message> m;
-
-       if( mrc == NULL ) {
-               return NULL;
-       }
+       std::unique_ptr<Message> m = NULL;
 
-       mbuf = rmr_torcv_msg( mrc, mbuf, timeout );             // future: do we want to reuse the mbuf here?
-       if( mbuf != NULL ) {
-               return std::unique_ptr<Message>( new Message( mbuf, mrc ) );
+       if( mrc != NULL ) {
+               mbuf = rmr_torcv_msg( mrc, mbuf, timeout );             // future: do we want to reuse the mbuf here?
+               if( mbuf != NULL ) {
+                       m = std::unique_ptr<Message>( new Message( mbuf, mrc ) );
+               }
        }
 
-       return NULL;
+       return m;
 }
 
 /*
@@ -190,10 +238,10 @@ void Messenger::Stop( ) {
        RMR messages must be released by RMR as there might be transport
        buffers that have to be dealt with. Every callback is expected to
        call this function when finished with the message.
-*/
 void Messenger::Release_mbuf( void* vmbuf ) {
        rmr_free_msg( (rmr_mbuf_t *)  vmbuf );
 }
+*/
 
 /*
        Wait for clear to send.
@@ -216,16 +264,18 @@ void Messenger::Release_mbuf( void* vmbuf ) {
 */
 bool Messenger::Wait_for_cts( int max_wait ) {
        bool block_4ever;
+       bool    state = false;
 
        block_4ever = max_wait == 0;
        while( block_4ever || max_wait > 0 ) {
                if( rmr_ready( mrc ) ) {
-                       return true;
+                       state = true;
+                       break;
                }
 
                sleep( 1 );
                max_wait--;
        }
 
-       return false;
+       return state;
 }