For classes that depend on scarab::cancelable, delete copy constructo…

…rs and assignment operators, default move constructors, and explicitly define assignment operators.
driplineorg · Aug 26, 2024 · fcadf4c · fcadf4c
1 parent 0a758a1
commit fcadf4c
Show file tree

Hide file tree

Showing 13 changed files with 98 additions and 100 deletions.
diff --git a/library/heartbeater.cc b/library/heartbeater.cc
@@ -27,26 +27,17 @@ namespace dripline
             f_heartbeat_interval_s( 60 ),
             f_check_timeout_ms( 1000 ),
             f_service( a_service ),
+//            f_stop( false ),
             f_heartbeat_thread()
     {}
 
-    heartbeater::heartbeater( heartbeater&& a_orig ) :
-            cancelable( std::move(a_orig) ),
-            f_heartbeat_interval_s( a_orig.f_heartbeat_interval_s ),
-            f_check_timeout_ms( a_orig.f_check_timeout_ms ),
-            f_service( std::move(a_orig.f_service) ),
-            f_heartbeat_thread( std::move(a_orig.f_heartbeat_thread) )
-    {}
-
-    heartbeater::~heartbeater()
-    {}
-
     heartbeater& heartbeater::operator=( heartbeater&& a_orig )
     {
-        f_heartbeat_interval_s = std::move(a_orig.f_heartbeat_interval_s);
-        f_check_timeout_ms = std::move(a_orig.f_check_timeout_ms);
-        f_service = std::move(a_orig.f_service);
-        f_heartbeat_thread = std::move(a_orig.f_heartbeat_thread);
+        cancelable::operator=( std::move(a_orig) );
+        f_heartbeat_interval_s = a_orig.f_heartbeat_interval_s;
+        f_check_timeout_ms = a_orig.f_check_timeout_ms;
+        f_service = std::move( a_orig.f_service );
+        f_heartbeat_thread = std::move( a_orig.f_heartbeat_thread );
         return *this;
     }
 

diff --git a/library/heartbeater.hh b/library/heartbeater.hh
@@ -55,11 +55,11 @@ namespace dripline
             ///Primary constructor.  A service pointer is required to be able to send messages.
             heartbeater( service_ptr_t a_service = service_ptr_t() );
             heartbeater( const heartbeater& ) = delete;
-            heartbeater( heartbeater&& a_orig );
-            virtual ~heartbeater();
+            heartbeater( heartbeater&& a_orig ) = default;
+            virtual ~heartbeater() = default;
 
             heartbeater& operator=( const heartbeater& ) = delete;
-            heartbeater& operator=( heartbeater&& a_orig );
+            heartbeater& operator=( heartbeater&& a_orig ); // we have to explicitly define this because of the virtual inheritance of scarab::cancelable
 
             /*!
              Starts the heartbeat process.  Heartbeat alerts are emitted every `heartbeat_interval_s` seconds.
@@ -77,7 +77,7 @@ namespace dripline
 
             mv_referrable( service_ptr_t, service );
 
-            mv_atomic( bool, stop );
+            //mv_atomic( bool, stop );
 
         protected:
             std::thread f_heartbeat_thread;

diff --git a/library/hub.cc b/library/hub.cc
@@ -26,11 +26,19 @@ namespace dripline
             f_get_handlers(),
             f_set_handlers(),
             f_cmd_handlers()
-    {
-    }
+    {}
 
-    hub::~hub()
+    hub& hub::operator=( hub&& a_orig )
     {
+        cancelable::operator=( std::move(a_orig) );
+        service::operator=( std::move(a_orig) );
+
+        f_run_handler = std::move( a_orig.f_run_handler );
+        f_get_handlers = std::move( a_orig.f_get_handlers );
+        f_set_handlers = std::move( a_orig.f_set_handlers );
+        f_cmd_handlers = std::move( a_orig.f_cmd_handlers );
+
+        return *this;
     }
 
     void hub::set_run_handler( const handler_func_t& a_func )

diff --git a/library/hub.hh b/library/hub.hh
@@ -98,7 +98,12 @@ namespace dripline
                @param a_make_connection Flag for whether or not to contact a broker; if true, this object operates in "dry-run" mode
              */
             hub( const scarab::param_node& a_config, const scarab::authentication& a_auth, const bool a_make_connection = true );
-            virtual ~hub();
+            hub( const hub& ) = delete;
+            hub( hub&& ) = default;
+            virtual ~hub() = default;
+
+            hub& operator=( const hub& ) = delete;
+            hub& operator=( hub&& );
 
             /// Sets the run request handler function
             void set_run_handler( const handler_func_t& a_func );

diff --git a/library/listener.cc b/library/listener.cc
@@ -28,24 +28,13 @@ namespace dripline
             f_listener_thread()
     {}
 
-    listener::listener( listener&& a_orig ) :
-            cancelable( std::move(a_orig) ),
-            f_channel( std::move(a_orig.f_channel) ),
-            f_consumer_tag( std::move(a_orig.f_consumer_tag) ),
-            f_listen_timeout_ms( std::move(a_orig.f_listen_timeout_ms) ),
-            f_listener_thread( std::move(a_orig.f_listener_thread) )
-    {}
-
-    listener::~listener()
-    {}
-
     listener& listener::operator=( listener&& a_orig )
     {
         cancelable::operator=( std::move(a_orig) );
-        f_channel = std::move(a_orig.f_channel);
-        f_consumer_tag = std::move(a_orig.f_consumer_tag);
-        f_consumer_tag = std::move(a_orig.f_listen_timeout_ms);
-        f_listener_thread = std::move(a_orig.f_listener_thread);
+        f_channel = std::move( a_orig.f_channel );
+        f_consumer_tag = std::move( a_orig.f_consumer_tag );
+        f_listen_timeout_ms = a_orig.f_listen_timeout_ms;
+        f_listener_thread = std::move( a_orig.f_listener_thread );
         return *this;
     }
 

diff --git a/library/listener.hh b/library/listener.hh
@@ -49,8 +49,8 @@ namespace dripline
         public:
             listener();
             listener( const listener& ) = delete;
-            listener( listener&& a_orig );
-            virtual ~listener();
+            listener( listener&& a_orig ) = default;
+            virtual ~listener() = default;
 
             listener& operator=( const listener& ) = delete;
             listener& operator=( listener&& a_orig );

diff --git a/library/receiver.cc b/library/receiver.cc
@@ -50,23 +50,12 @@ namespace dripline
             f_reply_listen_timeout_ms( 1000 )
     {}
 
-    receiver::receiver( receiver&& a_orig ) :
-            scarab::cancelable( std::move(a_orig) ),
-            f_incoming_messages( std::move(a_orig.f_incoming_messages) ),
-            f_single_message_wait_ms( a_orig.f_single_message_wait_ms )
-    {
-        a_orig.f_single_message_wait_ms = 1000;
-    }
-
-    receiver::~receiver()
-    {}
-
     receiver& receiver::operator=( receiver&& a_orig )
     {
-        scarab::cancelable::operator=( std::move(a_orig) );
+        cancelable::operator=( std::move(a_orig) );
         f_incoming_messages = std::move(a_orig.f_incoming_messages);
         f_single_message_wait_ms = a_orig.f_single_message_wait_ms;
-        a_orig.f_single_message_wait_ms = 1000;
+        f_reply_listen_timeout_ms = a_orig.f_reply_listen_timeout_ms;
         return *this;
     }
 

diff --git a/library/receiver.hh b/library/receiver.hh
@@ -79,8 +79,8 @@ namespace dripline
         public:
             receiver();
             receiver( const receiver& a_orig ) = delete;
-            receiver( receiver&& a_orig );
-            virtual ~receiver();
+            receiver( receiver&& a_orig ) = default;
+            virtual ~receiver() = default;
 
             receiver& operator=( const receiver& a_orig ) = delete;
             receiver& operator=( receiver&& a_orig );

diff --git a/library/relayer.cc b/library/relayer.cc
@@ -18,11 +18,17 @@ namespace dripline
             scarab::cancelable(),
             f_queue(),
             f_msg_receiver()
-    {
-    }
+    {}
 
-    relayer::~relayer()
+    relayer& relayer::operator=( relayer&& a_orig )
     {
+        core::operator=( std::move(a_orig) );
+        cancelable::operator=( std::move(a_orig) );
+
+        f_queue = std::move( a_orig.f_queue );
+        f_msg_receiver = std::move( a_orig.f_msg_receiver );
+
+        return *this;
     }
 
     void relayer::execute_relayer()

diff --git a/library/relayer.hh b/library/relayer.hh
@@ -38,7 +38,12 @@ namespace dripline
     {
         public:
             relayer( const scarab::param_node& a_config, const scarab::authentication& a_auth );
-            virtual ~relayer();
+            relayer( const relayer& ) = delete;
+            relayer( relayer&& ) = default;
+            virtual ~relayer() = default;
+
+            relayer& operator=( const relayer& ) = delete;
+            relayer& operator=( relayer&& );
 
         public:
             //*****************

diff --git a/library/scheduler.hh b/library/scheduler.hh
@@ -38,7 +38,12 @@ namespace dripline
     */
     struct DRIPLINE_API base_executor
     {
-        virtual ~base_executor() {}
+        base_executor() {}
+        base_executor( const base_executor& ) = default;
+        base_executor( base_executor&& ) = default;
+        virtual ~base_executor() = default;
+        base_executor& operator=( const base_executor& ) = default;
+        base_executor& operator=( base_executor&& ) = default;
         virtual void operator()( std::function< void() > ) = 0;
     };
 
@@ -50,7 +55,12 @@ namespace dripline
     */
     struct DRIPLINE_API simple_executor : base_executor
     {
-        virtual ~simple_executor() {}
+        simple_executor() : base_executor() {}
+        simple_executor( const simple_executor& ) = default;
+        simple_executor( simple_executor&& ) = default;
+        virtual ~simple_executor() = default;
+        simple_executor& operator=( const simple_executor& ) = default;
+        simple_executor& operator=( simple_executor&& ) = default;
         virtual void operator()( std::function< void() > an_executable )
         {
             LDEBUG( dlog_sh, "executing" );
@@ -112,10 +122,10 @@ namespace dripline
             scheduler();
             scheduler( const scheduler& ) = delete;
             scheduler( scheduler&& );
-            virtual ~scheduler();
+            virtual ~scheduler() = default;
 
             scheduler& operator=( const scheduler& ) = delete;
-            scheduler& operator=( scheduler&& );
+            scheduler& operator=( scheduler&& a_orig );
 
             /*!
              Schedule a one-off event
@@ -171,6 +181,7 @@ namespace dripline
 
     template< typename executor, typename clock >
     scheduler< executor, clock >::scheduler() :
+            cancelable(),
             f_exe_buffer( std::chrono::milliseconds(50) ),
             f_cycle_time( std::chrono::milliseconds(500) ),
             f_the_executor(),
@@ -182,27 +193,34 @@ namespace dripline
     {}
 
     template< typename executor, typename clock >
-    scheduler< executor, clock>::scheduler( scheduler< executor, clock >&& a_orig ) :
-        f_exe_buffer( std::move(a_orig.f_exe_buffer) ),
-        f_cycle_time( std::move(a_orig.f_cycle_time) ),
-        f_the_executor(),
-        f_events( std::move(a_orig.f_events) ),
-        f_scheduler_mutex(),
-        f_executor_mutex(),
-        f_cv(),
-        f_scheduler_thread( std::move(a_orig.f_scheduler_thread) )
-    {}
+    scheduler< executor, clock >::scheduler( scheduler< executor, clock >&& a_orig ) :
+            cancelable(),
+            f_exe_buffer(),
+            f_cycle_time(),
+            f_the_executor(),
+            f_events(),
+            f_scheduler_mutex(),
+            f_executor_mutex(),
+            f_cv(),
+            f_scheduler_thread()
+    {
+        std::unique_lock< std::recursive_mutex >t_this_lock( f_scheduler_mutex );
+        std::unique_lock< std::recursive_mutex >t_orig_lock( a_orig.f_scheduler_mutex );
 
-    template< typename executor, typename clock >
-    scheduler< executor, clock >::~scheduler()
-    {}
+        cancelable::operator=( std::move(a_orig) );
+        f_exe_buffer = std::move(a_orig.f_exe_buffer);
+        f_cycle_time = std::move(a_orig.f_cycle_time);
+        f_events = std::move(a_orig.f_events);
+        f_scheduler_thread = std::move(a_orig.f_scheduler_thread);
+    }
 
     template< typename executor, typename clock >
     scheduler< executor, clock>& scheduler< executor, clock >::operator=( scheduler< executor, clock >&& a_orig )
     {
         std::unique_lock< std::recursive_mutex >t_this_lock( f_scheduler_mutex );
         std::unique_lock< std::recursive_mutex >t_orig_lock( a_orig.f_scheduler_mutex );
 
+        cancelable::operator=( std::move(a_orig) );
         f_exe_buffer = std::move(a_orig.f_exe_buffer);
         f_cycle_time = std::move(a_orig.f_cycle_time);
         f_events = std::move(a_orig.f_events);

diff --git a/library/service.cc b/library/service.cc
@@ -68,22 +68,6 @@ namespace dripline
     {
     }
 */
-    service::service( service&& a_orig ) :
-            scarab::cancelable(),
-            core( std::move(a_orig) ),
-            endpoint( std::move(a_orig) ),
-            listener_receiver( std::move(a_orig) ),
-            heartbeater( std::move(a_orig) ),
-            scheduler<>( std::move(a_orig) ),
-            std::enable_shared_from_this< service >(),
-            f_status( std::move(a_orig.f_status) ),
-            f_enable_scheduling( std::move(a_orig.f_enable_scheduling) ),
-            f_id( std::move(a_orig.f_id) ),
-            f_sync_children( std::move(a_orig.f_sync_children) ),
-            f_async_children( std::move(a_orig.f_async_children) ),
-            f_broadcast_key( std::move(a_orig.f_broadcast_key) )
-    {
-    }
 
     service::~service()
     {
@@ -97,17 +81,20 @@ namespace dripline
 
     service& service::operator=( service&& a_orig )
     {
+        cancelable::operator=( std::move(a_orig) );
         core::operator=( std::move(a_orig) );
-        endpoint::operator=( std::move(a_orig) );
+        endpoint::operator=( std::move(a_orig));
         listener_receiver::operator=( std::move(a_orig) );
         heartbeater::operator=( std::move(a_orig) );
         scheduler<>::operator=( std::move(a_orig) );
-        f_status = std::move(a_orig.f_status) ;
-        f_enable_scheduling = std::move(a_orig.f_enable_scheduling);
-        f_id = std::move(a_orig.f_id);
-        f_sync_children = std::move(a_orig.f_sync_children);
-        f_async_children = std::move(a_orig.f_async_children);
-        f_broadcast_key = std::move(a_orig.f_broadcast_key);
+
+        f_status = std::move( a_orig.f_status );
+        f_enable_scheduling = a_orig.f_enable_scheduling;
+        f_id = std::move( a_orig.f_id );
+        f_sync_children = std::move( a_orig.f_sync_children );
+        f_async_children = std::move( a_orig.f_async_children );
+        f_broadcast_key = std::move( a_orig.f_broadcast_key );
+
         return *this;
     }
 

diff --git a/library/service.hh b/library/service.hh
@@ -125,7 +125,7 @@ namespace dripline
             service( const scarab::param_node& a_config, const scarab::authentication& a_auth, const bool a_make_connection = true );
 //            service( const bool a_make_connection, const scarab::param_node& a_config = scarab::param_node(), const scarab::authentication& a_auth = scarab::authentication() );
             service( const service& ) = delete;
-            service( service&& a_orig );
+            service( service&& a_orig ) = default;
             virtual ~service();
 
             service& operator=( const service& ) = delete;