From 9e1ef4619d508afc634236b8347d9e65cf7c2e2c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9rgio=20Agostinho?= <sergio.r.agostinho@gmail.com>
Date: Sun, 5 May 2019 18:47:48 +0200
Subject: [PATCH] =?UTF-8?q?[common]=C2=A0Migrate=20mutex,=20lock=20and=20c?=
 =?UTF-8?q?vs=20to=20C++14.=20(#3063)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

[common] Migrate mutex, lock and cvs to C++14.
---
 common/include/pcl/common/boost.h        |  2 --
 common/include/pcl/common/synchronizer.h | 22 ++++++++++++----------
 common/include/pcl/common/time_trigger.h |  7 +++++--
 common/src/time_trigger.cpp              | 14 ++++++++------
 4 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/common/include/pcl/common/boost.h b/common/include/pcl/common/boost.h
index a0d83a1c049..3638c4f1c45 100644
--- a/common/include/pcl/common/boost.h
+++ b/common/include/pcl/common/boost.h
@@ -50,9 +50,7 @@
 #include <boost/mpl/size.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/function.hpp>
-//#include <boost/timer.hpp>
 #include <boost/thread.hpp>
-#include <boost/thread/condition.hpp>
 #include <boost/signals2.hpp>
 #include <boost/signals2/slot.hpp>
 #include <boost/algorithm/string.hpp>
diff --git a/common/include/pcl/common/synchronizer.h b/common/include/pcl/common/synchronizer.h
index 3859d65e385..8df15531881 100644
--- a/common/include/pcl/common/synchronizer.h
+++ b/common/include/pcl/common/synchronizer.h
@@ -35,6 +35,8 @@
 
 #pragma once
 
+#include <mutex>
+
 namespace pcl
 {
   /** /brief This template class synchronizes two data streams of different types.
@@ -50,9 +52,9 @@ namespace pcl
   {
     typedef std::pair<unsigned long, T1> T1Stamped;
     typedef std::pair<unsigned long, T2> T2Stamped;
-    boost::mutex mutex1_;
-    boost::mutex mutex2_;
-    boost::mutex publish_mutex_;
+    std::mutex mutex1_;
+    std::mutex mutex2_;
+    std::mutex publish_mutex_;
     std::deque<T1Stamped> queueT1;
     std::deque<T2Stamped> queueT2;
 
@@ -67,7 +69,7 @@ namespace pcl
     int
     addCallback (const CallbackFunction& callback)
     {
-      boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+      std::unique_lock<std::mutex> publish_lock (publish_mutex_);
       cb_[callback_counter] = callback;
       return callback_counter++;
     }
@@ -75,7 +77,7 @@ namespace pcl
     void
     removeCallback (int i)
     {
-      boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+      std::unique_lock<std::mutex> publish_lock (publish_mutex_);
       cb_.erase (i);
     }
 
@@ -102,8 +104,8 @@ namespace pcl
     void
     publishData ()
     {
-      boost::unique_lock<boost::mutex> lock1 (mutex1_);
-      boost::unique_lock<boost::mutex> lock2 (mutex2_);
+      std::unique_lock<std::mutex> lock1 (mutex1_);
+      std::unique_lock<std::mutex> lock2 (mutex2_);
 
       for (typename std::map<int, CallbackFunction>::iterator cb = cb_.begin (); cb != cb_.end (); ++cb)
       {
@@ -121,15 +123,15 @@ namespace pcl
     publish ()
     {
       // only one publish call at once allowed
-      boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+      std::unique_lock<std::mutex> publish_lock (publish_mutex_);
 
-      boost::unique_lock<boost::mutex> lock1 (mutex1_);
+      std::unique_lock<std::mutex> lock1 (mutex1_);
       if (queueT1.empty ())
         return;
       T1Stamped t1 = queueT1.front ();
       lock1.unlock ();
 
-      boost::unique_lock<boost::mutex> lock2 (mutex2_);
+      std::unique_lock<std::mutex> lock2 (mutex2_);
       if (queueT2.empty ())
         return;
       T2Stamped t2 = queueT2.front ();
diff --git a/common/include/pcl/common/time_trigger.h b/common/include/pcl/common/time_trigger.h
index cb8f50adfec..f7212a7168c 100644
--- a/common/include/pcl/common/time_trigger.h
+++ b/common/include/pcl/common/time_trigger.h
@@ -43,6 +43,9 @@
 #include <boost/function.hpp>
 #include <boost/thread.hpp>
 #include <boost/signals2.hpp>
+
+#include <condition_variable>
+#include <mutex>
 #endif
 
 namespace pcl
@@ -99,7 +102,7 @@ namespace pcl
       bool running_;
 
       boost::thread timer_thread_;
-      boost::condition_variable condition_;
-      boost::mutex condition_mutex_;
+      std::condition_variable condition_;
+      std::mutex condition_mutex_;
   };
 }
diff --git a/common/src/time_trigger.cpp b/common/src/time_trigger.cpp
index fb9624b3850..d01cc7361c7 100644
--- a/common/src/time_trigger.cpp
+++ b/common/src/time_trigger.cpp
@@ -69,7 +69,7 @@ pcl::TimeTrigger::TimeTrigger (double interval)
 //////////////////////////////////////////////////////////////////////////////////////////////
 pcl::TimeTrigger::~TimeTrigger ()
 {
-  boost::unique_lock<boost::mutex> lock (condition_mutex_);
+  std::unique_lock<std::mutex> lock (condition_mutex_);
   quit_ = true;
   condition_.notify_all (); // notify all threads about updated quit_
   lock.unlock (); // unlock, to join all threads (needs to be done after notify_all)
@@ -88,7 +88,7 @@ pcl::TimeTrigger::registerCallback (const callback_type& callback)
 void
 pcl::TimeTrigger::setInterval (double interval_seconds)
 {
-  boost::unique_lock<boost::mutex> lock (condition_mutex_);
+  std::unique_lock<std::mutex> lock (condition_mutex_);
   interval_ = interval_seconds;
   // notify, since we could switch from a large interval to a shorter one -> interrupt waiting for timeout!
   condition_.notify_all ();
@@ -98,7 +98,7 @@ pcl::TimeTrigger::setInterval (double interval_seconds)
 void
 pcl::TimeTrigger::start ()
 {
-  boost::unique_lock<boost::mutex> lock (condition_mutex_);
+  std::unique_lock<std::mutex> lock (condition_mutex_);
   if (!running_)
   {
     running_ = true;
@@ -110,7 +110,7 @@ pcl::TimeTrigger::start ()
 void
 pcl::TimeTrigger::stop ()
 {
-  boost::unique_lock<boost::mutex> lock (condition_mutex_);
+  std::unique_lock<std::mutex> lock (condition_mutex_);
   if (running_)
   {
     running_ = false;
@@ -125,16 +125,18 @@ pcl::TimeTrigger::thread_function ()
   while (true)
   {
     double time = getTime ();
-    boost::unique_lock<boost::mutex> lock (condition_mutex_);
+    std::unique_lock<std::mutex> lock (condition_mutex_);
     if(quit_)
       break;
     if (!running_)
       condition_.wait (lock); // wait util start is called or destructor is called
     else
     {
+      using namespace std::chrono_literals;
+
       callbacks_();
       double rest = interval_ + time - getTime ();
-      condition_.timed_wait (lock, boost::posix_time::microseconds (static_cast<int64_t> ((rest * 1000000))));
+      condition_.wait_for (lock, rest * 1s);
     }
   }
 }