Use a mutex to protect Lazy

Author: lrineau

Filtered_kernel/include/CGAL/Lazy.h

@@ -47,6 +47,14 @@
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
 
+#ifdef CGAL_HAS_THREADS
+#  define CGAL_LAZY_USE_MUTEX 1
+#endif
+
+#ifdef CGAL_LAZY_USE_MUTEX
+#  include <CGAL/mutex.h>
+#endif
+
 namespace CGAL {
 
 template <typename AT, typename ET, typename EFT, typename E2A> class Lazy;
@@ -62,16 +70,6 @@ approx(const Lazy<AT,ET, EFT, E2A>& l)
   return l.approx();
 }
 
-// Where is this one (non-const) needed ?  Is it ?
-template <typename AT, typename ET, typename EFT, typename E2A>
-inline
-AT&
-approx(Lazy<AT,ET, EFT, E2A>& l)
-{
-  return l.approx();
-}
-
-
 template <typename AT, typename ET, typename EFT, typename E2A>
 inline
 const ET&
@@ -231,6 +229,9 @@ class Lazy_rep : public Rep, public Depth_base
 
   mutable AT at;
   mutable ET *et;
+#ifdef CGAL_LAZY_USE_MUTEX
+  mutable CGAL_MUTEX update_exact_mutex;
+#endif
 
   Lazy_rep ()
     : at(), et(NULL){}
@@ -243,25 +244,24 @@ class Lazy_rep : public Rep, public Depth_base
 
   const AT& approx() const
   {
-      return at;
-  }
-
-  AT& approx()
-  {
+#ifdef CGAL_LAZY_USE_MUTEX
+      CGAL_SCOPED_LOCK(update_exact_mutex);
+#endif
       return at;
   }
 
   const ET & exact() const
   {
+#ifdef CGAL_LAZY_USE_MUTEX
     if (et==NULL)
-      update_exact();
-    return *et;
-  }
-
-  ET & exact()
-  {
+    {
+      CGAL_SCOPED_LOCK(update_exact_mutex);
+      if(et==NULL) update_exact();
+    }
+#else // not CGAL_LAZY_USE_MUTEX
     if (et==NULL)
       update_exact();
+#endif // not CGAL_LAZY_USE_MUTEX
     return *et;
   }
 
@@ -762,12 +762,6 @@ public :
   const ET& exact() const
   { return ptr()->exact(); }
 
-  AT& approx()
-  { return ptr()->approx(); }
-
-  ET& exact()
-  { return ptr()->exact(); }
-
   unsigned depth() const
   {
     return ptr()->depth();