// Copyright (C) 2001-2003

 // William E. Kempf

 //

 //  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)

 #ifndef BOOST_CONDITION_WEK070601_HPP

 #define BOOST_CONDITION_WEK070601_HPP

 #include <boost/thread/detail/config.hpp>

 #include <boost/thread/exceptions.hpp>

 #include <boost/utility.hpp>

 #include <boost/thread/detail/lock.hpp>

 #if defined(BOOST_HAS_PTHREADS)

 #   include <pthread.h>

 #elif defined(BOOST_HAS_MPTASKS)

 #   include "scoped_critical_region.hpp"

 #endif

 namespace boost {

 struct xtime;

 // disable warnings about non dll import

 // see: http://www.boost.org/more/separate_compilation.html#dlls

 #ifdef BOOST_MSVC

 #   pragma warning(push)

 #   pragma warning(disable: 4251 4231 4660 4275)

 #endif

 namespace detail {

 class BOOST_THREAD_DECL condition_impl : private noncopyable

 {

     friend class condition;

 public:

     condition_impl();

     ~condition_impl();

     void notify_one();

     void notify_all();

 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))

     void enter_wait();

     void do_wait();

     bool do_timed_wait(const xtime& xt);

 #elif defined(BOOST_HAS_PTHREADS)

     void do_wait(pthread_mutex_t* pmutex);

     bool do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex);

 #endif

 #if defined(BOOST_HAS_WINTHREADS)

     void* m_gate;

     void* m_queue;

     void* m_mutex;

     unsigned m_gone;  // # threads that timed out and never made it to m_queue

     unsigned long m_blocked; // # threads blocked on the condition

     unsigned m_waiting; // # threads no longer waiting for the condition but

                         // still waiting to be removed from m_queue

 #elif defined(BOOST_HAS_PTHREADS)

     pthread_cond_t m_condition;

 #elif defined(BOOST_HAS_MPTASKS)

     MPSemaphoreID m_gate;

     MPSemaphoreID m_queue;

     threads::mac::detail::scoped_critical_region m_mutex;

     threads::mac::detail::scoped_critical_region m_mutex_mutex;

     unsigned m_gone; // # threads that timed out and never made it to m_queue

     unsigned long m_blocked; // # threads blocked on the condition

     unsigned m_waiting; // # threads no longer waiting for the condition but

                         // still waiting to be removed from m_queue

 #endif

 };

 } // namespace detail

 class condition : private noncopyable

 {

 public:

     condition() { }

     ~condition() { }

     void notify_one() { m_impl.notify_one(); }

     void notify_all() { m_impl.notify_all(); }

     template <typename L>

     void wait(L& lock)

     {

         if (!lock)

             throw lock_error();

         do_wait(lock.m_mutex);

     }

     template <typename L, typename Pr>

     void wait(L& lock, Pr pred)

     {

         if (!lock)

             throw lock_error();

         while (!pred())

             do_wait(lock.m_mutex);

     }

     template <typename L>

     bool timed_wait(L& lock, const xtime& xt)

     {

         if (!lock)

             throw lock_error();

         return do_timed_wait(lock.m_mutex, xt);

     }

     template <typename L, typename Pr>

     bool timed_wait(L& lock, const xtime& xt, Pr pred)

     {

         if (!lock)

             throw lock_error();

         while (!pred())

         {

             if (!do_timed_wait(lock.m_mutex, xt))

                 return false;

         }

         return true;

     }

 private:

     detail::condition_impl m_impl;

     template <typename M>

     void do_wait(M& mutex)

     {

 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))

         m_impl.enter_wait();

 #endif

         typedef detail::thread::lock_ops<M>

 #if defined(__HP_aCC) && __HP_aCC <= 33900 && !defined(BOOST_STRICT_CONFIG)

 # define lock_ops lock_ops_  // HP confuses lock_ops witht the template

 #endif

             lock_ops;

         typename lock_ops::lock_state state;

         lock_ops::unlock(mutex, state);

 #if defined(BOOST_HAS_PTHREADS)

         m_impl.do_wait(state.pmutex);

 #elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))

         m_impl.do_wait();

 #endif

         lock_ops::lock(mutex, state);

 #undef lock_ops

     }

     template <typename M>

     bool do_timed_wait(M& mutex, const xtime& xt)

     {

 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))

         m_impl.enter_wait();

 #endif

         typedef detail::thread::lock_ops<M>

 #if defined(__HP_aCC) && __HP_aCC <= 33900 && !defined(BOOST_STRICT_CONFIG)

 # define lock_ops lock_ops_  // HP confuses lock_ops witht the template

 #endif

             lock_ops;

         typename lock_ops::lock_state state;

         lock_ops::unlock(mutex, state);

         bool ret = false;

 #if defined(BOOST_HAS_PTHREADS)

         ret = m_impl.do_timed_wait(xt, state.pmutex);

 #elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))

         ret = m_impl.do_timed_wait(xt);

 #endif

         lock_ops::lock(mutex, state);

 #undef lock_ops

         return ret;

     }

 };

 #ifdef BOOST_MSVC

 #   pragma warning(pop)

 #endif

 } // namespace boost

 // Change Log:

 //    8 Feb 01  WEKEMPF Initial version.

 //   22 May 01  WEKEMPF Modified to use xtime for time outs.

 //   23 May 01  WEKEMPF Removed "duration" timed_waits, as they are too

 //                      difficult to use with spurious wakeups.

 //    3 Jan 03  WEKEMPF Modified for DLL implementation.

 #endif // BOOST_CONDITION_WEK070601_HPP