comparison DEPENDENCIES/generic/include/boost/asio/detail/win_event.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 //
 // detail/win_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 

 public:
   // Constructor.
   BOOST_ASIO_DECL win_event();
 
   // Destructor.
-  ~win_event()
-  {
-    ::CloseHandle(event_);
-  }
+  BOOST_ASIO_DECL ~win_event();
 
-  // Signal the event.
+  // Signal the event. (Retained for backward compatibility.)
   template <typename Lock>
   void signal(Lock& lock)
   {
+    this->signal_all(lock);
+  }
+
+  // Signal all waiters.
+  template <typename Lock>
+  void signal_all(Lock& lock)
+  {
     BOOST_ASIO_ASSERT(lock.locked());
     (void)lock;
-    ::SetEvent(event_);
+    state_ |= 1;
+    ::SetEvent(events_[0]);
   }
 
-  // Signal the event and unlock the mutex.
+  // Unlock the mutex and signal one waiter.
   template <typename Lock>
-  void signal_and_unlock(Lock& lock)
+  void unlock_and_signal_one(Lock& lock)
   {
     BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    bool have_waiters = (state_ > 1);
     lock.unlock();
-    ::SetEvent(event_);
+    if (have_waiters)
+      ::SetEvent(events_[1]);
+  }
+
+  // If there's a waiter, unlock the mutex and signal it.
+  template <typename Lock>
+  bool maybe_unlock_and_signal_one(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    if (state_ > 1)
+    {
+      lock.unlock();
+      ::SetEvent(events_[1]);
+      return true;
+    }
+    return false;
   }
 
   // Reset the event.
   template <typename Lock>
   void clear(Lock& lock)
   {
     BOOST_ASIO_ASSERT(lock.locked());
     (void)lock;
-    ::ResetEvent(event_);
+    ::ResetEvent(events_[0]);
+    state_ &= ~std::size_t(1);
   }
 
   // Wait for the event to become signalled.
   template <typename Lock>
   void wait(Lock& lock)
   {
     BOOST_ASIO_ASSERT(lock.locked());
-    lock.unlock();
-    ::WaitForSingleObject(event_, INFINITE);
-    lock.lock();
+    while ((state_ & 1) == 0)
+    {
+      state_ += 2;
+      lock.unlock();
+      ::WaitForMultipleObjects(2, events_, false, INFINITE);
+      lock.lock();
+      state_ -= 2;
+    }
   }
 
 private:
-  HANDLE event_;
+  HANDLE events_[2];
+  std::size_t state_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost