Move atomic variables into Parallel_callback

Point_set_processing_3/include/CGAL/compute_average_spacing.h

@@ -243,19 +243,15 @@ compute_average_spacing(
 #else
    if (boost::is_convertible<ConcurrencyTag,Parallel_tag>::value)
    {
-     // tbb::atomic only has default constructor, initialization done in two steps
-     tbb::atomic<std::size_t> advancement;
-     advancement = 0;
-     tbb::atomic<bool> interrupted;
-     interrupted = false;
-     
      internal::Point_set_processing_3::Parallel_callback
-       parallel_callback (callback, interrupted, advancement, kd_tree_points.size());
+       parallel_callback (callback, kd_tree_points.size());
      std::thread* callback_thread = (callback ? new std::thread (parallel_callback) : NULL);
      
      std::vector<FT> spacings (kd_tree_points.size (), -1);
      CGAL::internal::Compute_average_spacings<Kernel, Tree>
-       f (tree, k, kd_tree_points, spacings, advancement, interrupted);
+       f (tree, k, kd_tree_points, spacings,
+          parallel_callback.advancement(),
+          parallel_callback.interrupted());
      tbb::parallel_for(tbb::blocked_range<size_t>(0, kd_tree_points.size ()), f);
 
      for (unsigned int i = 0; i < spacings.size (); ++ i)

Point_set_processing_3/include/CGAL/internal/Parallel_callback.h

@@ -33,36 +33,70 @@ namespace Point_set_processing_3 {
   
 class Parallel_callback
 {
-  const cpp11::function<bool(double)>& callback;
-  tbb::atomic<std::size_t>& advancement;
-  tbb::atomic<bool>& interrupted;
-  std::size_t size;
-    
+  const cpp11::function<bool(double)>& m_callback;
+  tbb::atomic<std::size_t>* m_advancement;
+  tbb::atomic<bool>* m_interrupted;
+  std::size_t m_size;
+  bool m_creator;  
+
 public:
   Parallel_callback (const cpp11::function<bool(double)>& callback,
-                     tbb::atomic<bool>& interrupted,
-                     tbb::atomic<std::size_t>& advancement,
-                     std::size_t size)
-    : callback (callback)
-    , advancement (advancement)
-    , interrupted (interrupted)
-    , size (size)
-  { }
+                     std::size_t size,
+                     std::size_t advancement = 0,
+                     bool interrupted = false)
+    : m_callback (callback)
+    , m_advancement (new tbb::atomic<std::size_t>())
+    , m_interrupted (new tbb::atomic<bool>())
+    , m_size (size)
+    , m_creator (true)
+  {
+    // tbb::atomic only has default constructor, initialization done in two steps
+    *m_advancement = advancement;
+    *m_interrupted = interrupted;
+  }
+
+  Parallel_callback (const Parallel_callback& other)
+    : m_callback (other.m_callback)
+    , m_advancement (other.m_advancement)
+    , m_interrupted (other.m_interrupted)
+    , m_size (other.m_size)
+    , m_creator (false)
+  {
+
+  }
+
+  Parallel_callback& operator= (const Parallel_callback& other)
+  {
+    Parallel_callback out (other);
+    return out;
+  }
+
+  ~Parallel_callback ()
+  {
+    if (m_creator)
+    {
+      delete m_advancement;
+      delete m_interrupted;
+    }
+  }
+
+  tbb::atomic<std::size_t>& advancement() { return *m_advancement; }
+  tbb::atomic<bool>& interrupted() { return *m_interrupted; }
 
   void operator()()
   {
     tbb::tick_count::interval_t sleeping_time(0.00001);
 
-    while (advancement != size)
+    while (*m_advancement != m_size)
     {
-      if (!callback (advancement / double(size)))
+      if (!m_callback (*m_advancement / double(m_size)))
       {
-        interrupted = true;
+        *m_interrupted = true;
         return;
       }
       std::this_thread::sleep_for(sleeping_time);
     }
-    callback (1.);
+    m_callback (1.);
   }
 };