Backport2/v5.12

CMakeLists.txt

@@ -16,7 +16,7 @@
 #
 # ========================= eCAL LICENSE =================================
 
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.15)
 
 include(CMakeDependentOption)
 

app/meas_cutter/CMakeLists.txt

@@ -24,7 +24,9 @@ find_package(yaml-cpp REQUIRED)
 
 #compatibility with yaml-cpp < 0.8.0
 if (NOT TARGET yaml-cpp::yaml-cpp AND TARGET yaml-cpp)
-  add_library(yaml-cpp::yaml-cpp ALIAS yaml-cpp)
+  # ALIASing a imported non-global library requires CMake 3.18 so we do this
+  add_library(yaml-cpp::yaml-cpp INTERFACE IMPORTED)
+  target_link_libraries(yaml-cpp::yaml-cpp INTERFACE yaml-cpp)
 endif()
 
 

app/mon/mon_plugins/signals_plotting/src/signal_tree_model.cpp

@@ -74,10 +74,16 @@ Qt::ItemFlags SignalTreeModel::flags(const QModelIndex& index) const
 QVariant SignalTreeModel::data(const QModelIndex& index, int role) const
 {
   QAbstractTreeItem* tree_item = item(index);
-  if (tree_item)
-    return (index.column() >= 0 ? tree_item->data(index.column(), (Qt::ItemDataRole)role) : QVariant());
-  else
-    return QVariant();
+  if (tree_item != nullptr)
+  {
+    int const item_column = mapColumnToItem(index.column(), tree_item->type());
+    if (item_column >= 0)
+    {
+      return tree_item->data(item_column, (Qt::ItemDataRole)role);
+    }
+  }
+
+  return QVariant();
 }
 
 void SignalTreeModel::setCheckedState(SignalTreeItem* item, int index_column)

ecal/core/include/ecal/ecal_timed_cb.h

@@ -97,7 +97,10 @@ namespace eCAL
     {
       if (!m_running) return(false);
       m_stop = true;
-      m_thread.join();
+      // Wait for the callback thread to finish
+      if (m_thread.joinable()) {
+        m_thread.join();
+      }
       m_running = false;
       return(true);
     }

ecal/core/include/ecal/msg/capnproto/subscriber.h

@@ -68,6 +68,14 @@ namespace eCAL
       {
       }
 
+      /**
+       * @brief  Destructor
+      **/
+      ~CBuilderSubscriber() override
+      {
+        this->Destroy();
+      }
+
       /**
       * @brief  Copy Constructor is not available.
       **/

ecal/core/include/ecal/msg/flatbuffers/subscriber.h

@@ -56,6 +56,14 @@ namespace eCAL
       {
       }
 
+      /**
+       * @brief  Destructor
+      **/
+      ~CSubscriber() override
+      {
+        this->Destroy();
+      }
+
       /**
       * @brief  Copy Constructor is not available.
       **/

ecal/core/include/ecal/msg/messagepack/subscriber.h

@@ -59,6 +59,14 @@ namespace eCAL
       {
       }
 
+      /**
+       * @brief  Destructor
+      **/
+      ~CSubscriber() override
+      {
+        this->Destroy();
+      }
+
       /**
       * @brief  Copy Constructor is not available.
       **/

ecal/core/include/ecal/msg/protobuf/subscriber.h

@@ -74,6 +74,14 @@ namespace eCAL
       {
       }
 
+      /**
+       * @brief  Destructor
+      **/
+      ~CSubscriber() override
+      {
+        this->Destroy();
+      }
+
       /**
       * @brief  Copy Constructor is not available.
       **/

ecal/core/include/ecal/msg/string/subscriber.h

@@ -62,6 +62,14 @@ namespace eCAL
       {
       }
 
+      /**
+       * @brief  Destructor
+      **/
+      ~CSubscriber() override
+      {
+        this->Destroy();
+      }
+
       /**
       * @brief  Copy Constructor is not available.
       **/

ecal/core/include/ecal/msg/subscriber.h

@@ -76,6 +76,8 @@ namespace eCAL
     {
     }
 
+    virtual ~CMsgSubscriber() = default;
+
     /**
     * @brief  Copy Constructor is not available.
     **/
@@ -125,8 +127,6 @@ namespace eCAL
       return *this;
     }
 
-    virtual ~CMsgSubscriber() {}
-
     /**
      * @brief Creates this object.
      *
@@ -207,7 +207,10 @@ namespace eCAL
       assert(IsCreated());
       RemReceiveCallback();
 
-      m_cb_callback = callback_;
+      {
+        std::lock_guard<std::mutex> callback_lock(m_cb_callback_mutex);
+        m_cb_callback = callback_;
+      }
       auto callback = std::bind(&CMsgSubscriber::ReceiveCallback, this, std::placeholders::_1, std::placeholders::_2);
       return(CSubscriber::AddReceiveCallback(callback));
     }
@@ -219,9 +222,12 @@ namespace eCAL
     **/
     bool RemReceiveCallback()
     {
+      bool ret = CSubscriber::RemReceiveCallback();
+
+      std::lock_guard<std::mutex> callback_lock(m_cb_callback_mutex);
       if (m_cb_callback == nullptr) return(false);
       m_cb_callback = nullptr;
-      return(CSubscriber::RemReceiveCallback());
+      return(ret);
     }
 
 protected:
@@ -245,7 +251,11 @@ namespace eCAL
   private:
     void ReceiveCallback(const char* topic_name_, const struct eCAL::SReceiveCallbackData* data_)
     {
-      MsgReceiveCallbackT fn_callback(m_cb_callback);
+      MsgReceiveCallbackT fn_callback = nullptr;
+      {
+        std::lock_guard<std::mutex> callback_lock(m_cb_callback_mutex);
+        fn_callback = m_cb_callback;
+      }
 
       if(fn_callback == nullptr) return;
 
@@ -256,6 +266,7 @@ namespace eCAL
       }
     }
 
+    std::mutex          m_cb_callback_mutex;
     MsgReceiveCallbackT m_cb_callback;
   };
 }

ecal/core/src/ecal_registration_receiver.cpp

@@ -202,7 +202,11 @@ namespace eCAL
     eCAL::pb::Sample modified_ttype_sample;
     ModifyIncomingSampleForBackwardsCompatibility(ecal_sample_, modified_ttype_sample);
 
-    m_callback_custom_apply_sample(modified_ttype_sample);
+    // forward all registration samples to outside "customer" (e.g. Monitoring)
+    {
+      const std::lock_guard<std::mutex> lock(m_callback_custom_apply_sample_mtx);
+      m_callback_custom_apply_sample(modified_ttype_sample);
+    }
 
     std::string reg_sample;
     if ( m_callback_pub
@@ -417,11 +421,13 @@ namespace eCAL
 
   void CRegistrationReceiver::SetCustomApplySampleCallback(const ApplySampleCallbackT& callback_)
   {
+    const std::lock_guard<std::mutex> lock(m_callback_custom_apply_sample_mtx);
     m_callback_custom_apply_sample = callback_;
   }
 
   void CRegistrationReceiver::RemCustomApplySampleCallback()
   {
+    const std::lock_guard<std::mutex> lock(m_callback_custom_apply_sample_mtx);
     m_callback_custom_apply_sample = [](const auto&){};
   }
 };

ecal/core/src/ecal_registration_receiver.h

@@ -78,6 +78,15 @@ namespace eCAL
     CRegistrationReceiver();
     ~CRegistrationReceiver();
 
+    // default copy constructor
+    CRegistrationReceiver(const CRegistrationReceiver& other) = delete;
+    // default copy assignment operator
+    CRegistrationReceiver& operator=(const CRegistrationReceiver& other) = delete;
+    // default move constructor
+    CRegistrationReceiver(CRegistrationReceiver&& other) noexcept = delete;
+    // default move assignment operator
+    CRegistrationReceiver& operator=(CRegistrationReceiver&& other) noexcept = delete;
+
     void Create();
     void Destroy();
 
@@ -121,6 +130,7 @@ namespace eCAL
     bool                             m_use_network_monitoring;
     bool                             m_use_shm_monitoring;
 
+    std::mutex                       m_callback_custom_apply_sample_mtx;
     ApplySampleCallbackT             m_callback_custom_apply_sample;
 
     std::string                      m_host_group_name;

ecal/core/src/ecal_thread.h

@@ -37,6 +37,11 @@ namespace eCAL
     CThread();
     virtual ~CThread();
 
+    CThread(const CThread&) = delete;
+    CThread& operator=(const CThread&) = delete;
+    CThread(CThread&& rhs) = delete;
+    CThread& operator=(CThread&& rhs) = delete;
+
     int Start(int period, std::function<int()> ext_caller_);
     int Stop();
     int Fire();

ecal/core/src/ecal_timer.cpp

@@ -38,6 +38,10 @@ namespace eCAL
     CTimerImpl(const int timeout_, TimerCallbackT callback_, const int delay_) : m_stop(false), m_running(false) { Start(timeout_, callback_, delay_); }
 
     virtual ~CTimerImpl() { Stop(); }
+    CTimerImpl(const CTimerImpl&) = delete;
+    CTimerImpl& operator=(const CTimerImpl&) = delete;
+    CTimerImpl(CTimerImpl&& rhs) = delete;
+    CTimerImpl& operator=(CTimerImpl&& rhs) = delete;
 
     bool Start(const int timeout_, TimerCallbackT callback_, const int delay_)
     {

ecal/core/src/io/ecal_memfile_pool.cpp

@@ -309,7 +309,10 @@ namespace eCAL
   {
   }
 
-  CMemFileThreadPool::~CMemFileThreadPool() = default;
+  CMemFileThreadPool::~CMemFileThreadPool()
+  {
+    Destroy();
+  }
 
   void CMemFileThreadPool::Create()
   {

ecal/core/src/io/ecal_memfile_pool.h

@@ -50,6 +50,11 @@ namespace eCAL
     CMemFileObserver();
     ~CMemFileObserver();
 
+    CMemFileObserver(const CMemFileObserver&) = delete;
+    CMemFileObserver& operator=(const CMemFileObserver&) = delete;
+    CMemFileObserver(CMemFileObserver&& rhs) = delete;
+    CMemFileObserver& operator=(CMemFileObserver&& rhs) = delete;
+
     bool Create(const std::string& memfile_name_, const std::string& memfile_event_);
     bool Destroy();
 

ecal/core/src/io/snd_sample.cpp

@@ -45,6 +45,7 @@ namespace eCAL
   {
     if (!m_udp_sender) return(0);
 
+    std::lock_guard<std::mutex> const send_lock(m_payload_mutex);
     // return value
     size_t sent_sum(0);
 

ecal/core/src/io/snd_sample.h

@@ -24,6 +24,7 @@
 #pragma once
 
 #include <memory>
+#include <mutex>
 
 #include "udp_sender.h"
 
@@ -47,6 +48,7 @@ namespace eCAL
     SSenderAttr                       m_attr;
 
     std::shared_ptr<eCAL::CUDPSender> m_udp_sender;
+    std::mutex                        m_payload_mutex;
     std::vector<char>                 m_payload;
   };
 }

ecal/core/src/io/udp_receiver.cpp

@@ -54,6 +54,11 @@ namespace eCAL
 #endif //ECAL_NPCAP_SUPPORT
   }
 
+  CUDPReceiver::~CUDPReceiver()
+  {
+    Destroy();
+  }
+
   bool CUDPReceiver::Create(const SReceiverAttr& attr_)
   {
     if (m_socket_impl) return false;

ecal/core/src/io/udp_receiver.h

@@ -35,6 +35,12 @@ namespace eCAL
   {
   public:
     CUDPReceiver();
+    ~CUDPReceiver();
+
+    CUDPReceiver(const CUDPReceiver&) = delete;
+    CUDPReceiver& operator=(const CUDPReceiver&) = delete;
+    CUDPReceiver(CUDPReceiver&& rhs) = delete;
+    CUDPReceiver& operator=(CUDPReceiver&& rhs) = delete;
 
     bool Create(const SReceiverAttr& attr_) override;
     bool Destroy() override;

ecal/core/src/pubsub/ecal_publisher.cpp

@@ -72,15 +72,13 @@ namespace eCAL
    * @brief CPublisher are move-enabled
   **/
   CPublisher::CPublisher(CPublisher&& rhs) noexcept :
-                m_datawriter(rhs.m_datawriter),
+                m_datawriter(std::move(rhs.m_datawriter)),
                 m_qos(rhs.m_qos),
+                m_tlayer(rhs.m_tlayer),
                 m_id(rhs.m_id),
                 m_created(rhs.m_created),
                 m_initialized(rhs.m_initialized)
   {
-    InitializeQOS();
-    InitializeTLayer();
-
     rhs.m_created     = false;
     rhs.m_initialized = false;
   }
@@ -90,15 +88,16 @@ namespace eCAL
   **/
   CPublisher& CPublisher::operator=(CPublisher&& rhs) noexcept
   {
-    m_datawriter = rhs.m_datawriter;
+    // Call destroy, to clean up the current state, then afterwards move all elements
+    Destroy();
 
+    m_datawriter      = std::move(rhs.m_datawriter);
     m_qos             = rhs.m_qos;
+    m_tlayer          = rhs.m_tlayer,
     m_id              = rhs.m_id;
     m_created         = rhs.m_created;
     m_initialized     = rhs.m_initialized;
 
-    InitializeQOS();
-    InitializeTLayer();
     rhs.m_created     = false;
     rhs.m_initialized = false;