Creation of sm_nav2_unit_test_1

CLAUDE.md

@@ -37,7 +37,7 @@ SmaccSignal is a communication mechanism (template wrapper around boost::signals
   ### Signal Connection Lifetime Management
   Signal connections are managed through the state machine's
   createSignalConnection() which:
-  1. Creates boost::signals2 connections between signal sources and
+  1. Creates smacc2::SmaccSignalConnection connections between signal sources and
   callbacks
   2. Tracks connections by object pointer
   3. Automatically disconnects when objects are destroyed via

smacc2/include/smacc2/callback_counter_semaphore.hpp

@@ -19,11 +19,11 @@
  ******************************************************************************************************************/
 
 #pragma once
-#include <boost/signals2.hpp>
 #include <condition_variable>
 #include <iostream>
 #include <mutex>
 #include <rclcpp/rclcpp.hpp>
+#include <smacc2/smacc_signal.hpp>
 #include <thread>
 
 namespace smacc2
@@ -38,13 +38,13 @@ class CallbackCounterSemaphore
 
   void finalize();
 
-  void addConnection(boost::signals2::connection conn);
+  void addConnection(smacc2::SmaccSignalConnection conn);
 
 private:
   int count_;
   std::mutex mutex_;
   std::condition_variable cv_;
-  std::vector<boost::signals2::connection> connections_;
+  std::vector<smacc2::SmaccSignalConnection> connections_;
   bool finalized = false;
   std::string name_;
 };

smacc2/include/smacc2/client_bases/smacc_action_client_base.hpp

@@ -155,62 +155,62 @@ class SmaccActionClientBase : public ISmaccActionClient
   }
 
   template <typename T>
-  boost::signals2::connection onSucceeded(void (T::*callback)(WrappedResult &), T * object)
+  smacc2::SmaccSignalConnection onSucceeded(void (T::*callback)(WrappedResult &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onSucceeded_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onSucceeded(std::function<void(WrappedResult &)> callback)
+  smacc2::SmaccSignalConnection onSucceeded(std::function<void(WrappedResult &)> callback)
   {
     return this->getStateMachine()->createSignalConnection(onSucceeded_, callback);
   }
 
   template <typename T>
-  boost::signals2::connection onAborted(void (T::*callback)(WrappedResult &), T * object)
+  smacc2::SmaccSignalConnection onAborted(void (T::*callback)(WrappedResult &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onAborted_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onAborted(std::function<void(WrappedResult &)> callback)
+  smacc2::SmaccSignalConnection onAborted(std::function<void(WrappedResult &)> callback)
   {
     return this->getStateMachine()->createSignalConnection(onAborted_, callback);
   }
 
   template <typename T>
-  boost::signals2::connection onCancelled(void (T::*callback)(WrappedResult &), T * object)
+  smacc2::SmaccSignalConnection onCancelled(void (T::*callback)(WrappedResult &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onCancelled_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onCancelled(std::function<void(WrappedResult &)> callback)
+  smacc2::SmaccSignalConnection onCancelled(std::function<void(WrappedResult &)> callback)
   {
     return this->getStateMachine()->createSignalConnection(onCancelled_, callback);
   }
 
   /*
   template <typename T>
-  boost::signals2::connection onPreempted(void (T::*callback)(WrappedResult &), T *object)
+  smacc2::SmaccSignalConnection onPreempted(void (T::*callback)(WrappedResult &), T *object)
   {
       return this->getStateMachine()->createSignalConnection(onPreempted_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onPreempted(std::function<void(WrappedResult &)> callback)
+  smacc2::SmaccSignalConnection onPreempted(std::function<void(WrappedResult &)> callback)
   {
       return this->getStateMachine()->createSignalConnection(onPreempted_, callback);
   }
 
   template <typename T>
-  boost::signals2::connection onRejected(void (T::*callback)(WrappedResult &), T *object)
+  smacc2::SmaccSignalConnection onRejected(void (T::*callback)(WrappedResult &), T *object)
   {
       return this->getStateMachine()->createSignalConnection(onRejected_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onRejected(std::function<void(WrappedResult &)> callback)
+  smacc2::SmaccSignalConnection onRejected(std::function<void(WrappedResult &)> callback)
   {
       return this->getStateMachine()->createSignalConnection(onRejected_, callback);
   }

smacc2/include/smacc2/client_bases/smacc_service_server_client.hpp

@@ -51,7 +51,7 @@ class SmaccServiceServerClient : public smacc2::ISmaccClient
     onServiceRequestReceived_;
 
   template <typename T>
-  boost::signals2::connection onServiceRequestReceived(
+  smacc2::SmaccSignalConnection onServiceRequestReceived(
     void (T::*callback)(
       const std::shared_ptr<typename TService::Request>,
       std::shared_ptr<typename TService::Response>),

smacc2/include/smacc2/client_bases/smacc_subscriber_client.hpp

@@ -60,14 +60,14 @@ class SmaccSubscriberClient : public smacc2::ISmaccClient
   std::function<void(const MessageType &)> postInitialMessageEvent;
 
   template <typename T>
-  boost::signals2::connection onMessageReceived(
+  smacc2::SmaccSignalConnection onMessageReceived(
     void (T::*callback)(const MessageType &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onMessageReceived_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onFirstMessageReceived(
+  smacc2::SmaccSignalConnection onFirstMessageReceived(
     void (T::*callback)(const MessageType &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(

smacc2/include/smacc2/client_behaviors/cb_sequence.hpp

@@ -76,8 +76,8 @@ class CbSequence : public smacc2::SmaccAsyncClientBehavior
   void recursiveConsumeNext();
 
   std::list<std::function<std::shared_ptr<smacc2::SmaccAsyncClientBehavior>()>> sequenceNodes_;
-  boost::signals2::connection conn_;
-  boost::signals2::connection conn2_;
+  smacc2::SmaccSignalConnection conn_;
+  smacc2::SmaccSignalConnection conn2_;
 
   std::shared_ptr<smacc2::SmaccAsyncClientBehavior> bh_;
   std::atomic<int> consume_{0};

smacc2/include/smacc2/client_core_components/cp_action_client.hpp

@@ -199,25 +199,25 @@ class CpActionClient : public smacc2::ISmaccComponent
 
   // Signal connection methods
   template <typename T>
-  boost::signals2::connection onSucceeded(void (T::*callback)(const WrappedResult &), T * object)
+  smacc2::SmaccSignalConnection onSucceeded(void (T::*callback)(const WrappedResult &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onActionSucceeded_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onAborted(void (T::*callback)(const WrappedResult &), T * object)
+  smacc2::SmaccSignalConnection onAborted(void (T::*callback)(const WrappedResult &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onActionAborted_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onCancelled(void (T::*callback)(const WrappedResult &), T * object)
+  smacc2::SmaccSignalConnection onCancelled(void (T::*callback)(const WrappedResult &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onActionCancelled_, callback, object);
   }
 
   template <typename T>
-  boost::signals2::connection onFeedback(void (T::*callback)(const Feedback &), T * object)
+  smacc2::SmaccSignalConnection onFeedback(void (T::*callback)(const Feedback &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onActionFeedback_, callback, object);
   }

smacc2/include/smacc2/client_core_components/cp_ros2_timer.hpp

@@ -89,7 +89,7 @@ class CpRos2Timer : public smacc2::ISmaccComponent
   }
 
   template <typename T>
-  boost::signals2::connection onTimerTick(void (T::*callback)(), T * object)
+  smacc2::SmaccSignalConnection onTimerTick(void (T::*callback)(), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onTimerTick_, callback, object);
   }

smacc2/include/smacc2/client_core_components/cp_service_client.hpp

@@ -327,7 +327,7 @@ class CpServiceClient : public smacc2::ISmaccComponent
    * @return Signal connection handle
    */
   template <typename T>
-  boost::signals2::connection onResponse(void (T::*callback)(const SharedResponse &), T * object)
+  smacc2::SmaccSignalConnection onResponse(void (T::*callback)(const SharedResponse &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onServiceResponse_, callback, object);
   }
@@ -341,7 +341,7 @@ class CpServiceClient : public smacc2::ISmaccComponent
    * @return Signal connection handle
    */
   template <typename T>
-  boost::signals2::connection onRequestSent(void (T::*callback)(), T * object)
+  smacc2::SmaccSignalConnection onRequestSent(void (T::*callback)(), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onServiceRequestSent_, callback, object);
   }
@@ -355,7 +355,7 @@ class CpServiceClient : public smacc2::ISmaccComponent
    * @return Signal connection handle
    */
   template <typename T>
-  boost::signals2::connection onFailure(void (T::*callback)(), T * object)
+  smacc2::SmaccSignalConnection onFailure(void (T::*callback)(), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onServiceFailure_, callback, object);
   }

smacc2/include/smacc2/client_core_components/cp_topic_subscriber.hpp

@@ -52,15 +52,15 @@ class CpTopicSubscriber : public smacc2::ISmaccComponent
 
   // signal subscription method. This signal will be triggered when the first message is received
   template <typename T>
-  boost::signals2::connection onMessageReceived(
+  smacc2::SmaccSignalConnection onMessageReceived(
     void (T::*callback)(const MessageType &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(onMessageReceived_, callback, object);
   }
 
   // signal subscription method. This signal will be triggered when the first message is received
   template <typename T>
-  boost::signals2::connection onFirstMessageReceived(
+  smacc2::SmaccSignalConnection onFirstMessageReceived(
     void (T::*callback)(const MessageType &), T * object)
   {
     return this->getStateMachine()->createSignalConnection(

smacc2/include/smacc2/common.hpp

@@ -35,7 +35,6 @@
 #include <boost/function.hpp>
 #include <boost/intrusive_ptr.hpp>
 #include <boost/mpl/list.hpp>
-#include <boost/signals2.hpp>
 
 #include <mutex>
 #include <rclcpp/rclcpp.hpp>

smacc2/include/smacc2/impl/smacc_asynchronous_client_behavior_impl.hpp

@@ -60,21 +60,21 @@ void SmaccAsyncClientBehavior::onStateOrthogonalAllocation()
 }
 
 template <typename TCallbackMethod, typename T>
-boost::signals2::connection SmaccAsyncClientBehavior::onSuccess(
+smacc2::SmaccSignalConnection SmaccAsyncClientBehavior::onSuccess(
   TCallbackMethod callback, T * object)
 {
   return this->getStateMachine()->createSignalConnection(onSuccess_, callback, object);
 }
 
 template <typename TCallbackMethod, typename T>
-boost::signals2::connection SmaccAsyncClientBehavior::onFinished(
+smacc2::SmaccSignalConnection SmaccAsyncClientBehavior::onFinished(
   TCallbackMethod callback, T * object)
 {
   return this->getStateMachine()->createSignalConnection(onFinished_, callback, object);
 }
 
 template <typename TCallbackMethod, typename T>
-boost::signals2::connection SmaccAsyncClientBehavior::onFailure(
+smacc2::SmaccSignalConnection SmaccAsyncClientBehavior::onFailure(
   TCallbackMethod callback, T * object)
 {
   return this->getStateMachine()->createSignalConnection(onFailure_, callback, object);

smacc2/include/smacc2/impl/smacc_state_machine_impl.hpp

@@ -319,7 +319,7 @@ template <int arity>
 struct Bind
 {
   template <typename TSmaccSignal, typename TMemberFunctionPrototype, typename TSmaccObjectType>
-  boost::signals2::connection bindaux(
+  smacc2::SmaccSignalConnection bindaux(
     TSmaccSignal & signal, TMemberFunctionPrototype callback, TSmaccObjectType * object,
     std::shared_ptr<CallbackCounterSemaphore> callbackCounter);
 };
@@ -328,7 +328,7 @@ template <>
 struct Bind<1>
 {
   template <typename TSmaccSignal, typename TMemberFunctionPrototype, typename TSmaccObjectType>
-  boost::signals2::connection bindaux(
+  smacc2::SmaccSignalConnection bindaux(
     TSmaccSignal & signal, TMemberFunctionPrototype callback, TSmaccObjectType * object,
     std::shared_ptr<CallbackCounterSemaphore> callbackCounter)
   {
@@ -353,7 +353,7 @@ template <>
 struct Bind<2>
 {
   template <typename TSmaccSignal, typename TMemberFunctionPrototype, typename TSmaccObjectType>
-  boost::signals2::connection bindaux(
+  smacc2::SmaccSignalConnection bindaux(
     TSmaccSignal & signal, TMemberFunctionPrototype callback, TSmaccObjectType * object,
     std::shared_ptr<CallbackCounterSemaphore> callbackCounter)
   {
@@ -377,7 +377,7 @@ template <>
 struct Bind<3>
 {
   template <typename TSmaccSignal, typename TMemberFunctionPrototype, typename TSmaccObjectType>
-  boost::signals2::connection bindaux(
+  smacc2::SmaccSignalConnection bindaux(
     TSmaccSignal & signal, TMemberFunctionPrototype callback, TSmaccObjectType * object,
     std::shared_ptr<CallbackCounterSemaphore> callbackCounter)
   {
@@ -401,7 +401,7 @@ template <>
 struct Bind<4>
 {
   template <typename TSmaccSignal, typename TMemberFunctionPrototype, typename TSmaccObjectType>
-  boost::signals2::connection bindaux(
+  smacc2::SmaccSignalConnection bindaux(
     TSmaccSignal & signal, TMemberFunctionPrototype callback, TSmaccObjectType * object,
     std::shared_ptr<CallbackCounterSemaphore> callbackCounter)
   {
@@ -424,7 +424,7 @@ struct Bind<4>
 using namespace smacc2::utils;
 
 template <typename TSmaccSignal, typename TMemberFunctionPrototype, typename TSmaccObjectType>
-boost::signals2::connection ISmaccStateMachine::createSignalConnection(
+smacc2::SmaccSignalConnection ISmaccStateMachine::createSignalConnection(
   TSmaccSignal & signal, TMemberFunctionPrototype callback, TSmaccObjectType * object)
 {
   std::lock_guard<std::recursive_mutex> lock(m_mutex_);
@@ -439,7 +439,7 @@ boost::signals2::connection ISmaccStateMachine::createSignalConnection(
 
   typedef decltype(callback) ft;
   Bind<boost::function_types::function_arity<ft>::value> binder;
-  boost::signals2::connection connection;
+  smacc2::SmaccSignalConnection connection;
 
   // long life-time objects
   if (

smacc2/include/smacc2/smacc_asynchronous_client_behavior.hpp

@@ -61,13 +61,13 @@ class SmaccAsyncClientBehavior : public ISmaccClientBehavior
   virtual ~SmaccAsyncClientBehavior();
 
   template <typename TCallback, typename T>
-  boost::signals2::connection onSuccess(TCallback callback, T * object);
+  smacc2::SmaccSignalConnection onSuccess(TCallback callback, T * object);
 
   template <typename TCallback, typename T>
-  boost::signals2::connection onFinished(TCallback callback, T * object);
+  smacc2::SmaccSignalConnection onFinished(TCallback callback, T * object);
 
   template <typename TCallback, typename T>
-  boost::signals2::connection onFailure(TCallback callback, T * object);
+  smacc2::SmaccSignalConnection onFailure(TCallback callback, T * object);
 
   void requestForceFinish();
 

smacc2/include/smacc2/smacc_signal.hpp

@@ -21,6 +21,7 @@
 #pragma once
 
 #include <boost/any.hpp>
+#include <boost/signals2/connection.hpp>
 #include <boost/signals2/signal.hpp>
 
 namespace smacc2
@@ -29,6 +30,8 @@ using namespace boost;
 using namespace boost::signals2;
 using namespace boost::signals2::detail;
 
+typedef boost::signals2::connection SmaccSignalConnection;
+
 template <
   typename Signature,
   typename Combiner = optional_last_value<typename boost::function_traits<Signature>::result_type>,

smacc2/include/smacc2/smacc_state_machine.hpp

@@ -128,7 +128,7 @@ class ISmaccStateMachine
     std::shared_ptr<smacc2_msgs::srv::SmaccGetTransitionHistory::Response> res);
 
   template <typename TSmaccSignal, typename TMemberFunctionPrototype, typename TSmaccObjectType>
-  boost::signals2::connection createSignalConnection(
+  smacc2::SmaccSignalConnection createSignalConnection(
     TSmaccSignal & signal, TMemberFunctionPrototype callback, TSmaccObjectType * object);
 
   void disconnectSmaccSignalObject(void * object);
@@ -199,8 +199,6 @@ class ISmaccStateMachine
   // orthogonals
   std::map<std::string, std::shared_ptr<smacc2::ISmaccOrthogonal>> orthogonals_;
 
-  std::vector<boost::signals2::scoped_connection> longLivedSignalConnections_;
-
 protected:
   std::shared_ptr<SmaccStateMachineInfo> stateMachineInfo_;
 

smacc2/src/smacc2/callback_counter_semaphore.cpp

@@ -17,7 +17,6 @@
  * 	 Authors: Pablo Inigo Blasco, Brett Aldrich
  *
  *****************************************************************************************************************/
-#include <boost/signals2.hpp>
 #include <condition_variable>
 #include <iostream>
 #include <mutex>
@@ -88,7 +87,7 @@ void CallbackCounterSemaphore::finalize()
     name_.c_str(), (long)this);
 }
 
-void CallbackCounterSemaphore::addConnection(boost::signals2::connection conn)
+void CallbackCounterSemaphore::addConnection(smacc2::SmaccSignalConnection conn)
 {
   std::unique_lock<std::mutex> lock(mutex_);