use boost::mutex on apple platforms

Author: IMOlbrody

Release/include/pplx/pplxlinux.h

@@ -35,22 +35,29 @@
 #ifndef _MS_WINDOWS
 
 #include <signal.h>
-#include <mutex>
-#include <condition_variable>
 #include "pthread.h"
 
 #if defined(__APPLE__)
 #include "compat/apple_compat.h"
 #include <dispatch/dispatch.h>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
 #else
 #include "compat/linux_compat.h"
+#include <mutex>   
+#include <condition_variable>  
 #endif
 
 #include "pplx/pplxinterface.h"
 
 
 namespace pplx
 {
+#if defined(__APPLE__)
+    namespace cpprest_synchronization = ::boost;
+#else
+    namespace cpprest_synchronization = ::std;
+#endif
 namespace details
 {
 namespace platform
@@ -80,8 +87,8 @@ namespace platform
     class event_impl
      {
     private:
-        std::mutex _lock;
-        std::condition_variable _condition;
+        cpprest_synchronization::mutex _lock;
+        cpprest_synchronization::condition_variable _condition;
         bool _signaled;
     public:
 
@@ -94,28 +101,28 @@ namespace platform
 
         void set()
         {
-            std::lock_guard<std::mutex> lock(_lock);
+            cpprest_synchronization::lock_guard<cpprest_synchronization::mutex> lock(_lock);
             _signaled = true;
             _condition.notify_all();
         }
 
         void reset()
         {
-            std::lock_guard<std::mutex> lock(_lock);
+            cpprest_synchronization::lock_guard<cpprest_synchronization::mutex> lock(_lock);
             _signaled = false;
         }
 
         unsigned int wait(unsigned int timeout)
         {
-            std::unique_lock<std::mutex> lock(_lock);
+            cpprest_synchronization::unique_lock<cpprest_synchronization::mutex> lock(_lock);
             if (timeout == event_impl::timeout_infinite)
             {
                 _condition.wait(lock, [this]() -> bool { return _signaled; });
                 return 0;
             }
             else
             {
-                std::chrono::milliseconds period(timeout);
+                cpprest_synchronization::chrono::milliseconds period(timeout);
                 auto status = _condition.wait_for(lock, period, [this]() -> bool { return _signaled; });
                 _ASSERTE(status == _signaled);
                 // Return 0 if the wait completed as a result of signaling the event. Otherwise, return timeout_infinite
@@ -235,7 +242,7 @@ namespace platform
         }
 
     private:
-        ::std::mutex _M_cs;
+        cpprest_synchronization::mutex _M_cs;
         long _M_recursionCount;
         volatile long _M_owner;
     };
@@ -257,8 +264,8 @@ namespace platform
 } // namespace details
 
 /// <summary>
-///  A generic RAII wrapper for locks that implement the critical_section interface
-///  std::lock_guard
+///  A generic RAII wrapper for locks that implements the critical_section interface
+///  cpprest_synchronization::lock_guard
 /// </summary>
 template<class _Lock>
 class scoped_lock
@@ -286,7 +293,7 @@ namespace extensibility
 {
     typedef ::pplx::details::event_impl event_t;
 
-    typedef ::std::mutex critical_section_t;
+    typedef cpprest_synchronization::mutex critical_section_t;
     typedef scoped_lock<critical_section_t> scoped_critical_section_t;
 
     typedef ::pplx::details::reader_writer_lock_impl reader_writer_lock_t;