text: #ifndef BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
  #define BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
  
  //  basic_timed_mutex_win32.hpp
  //
  //  (C) Copyright 2006-8 Anthony Williams
  //  (C) Copyright 2011-2012 Vicente J. Botet Escriba
  //
  //  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)
  
  #include <boost/assert.hpp>
  #include <boost/thread/win32/thread_primitives.hpp>
  #include <boost/thread/win32/interlocked_read.hpp>
  #include <boost/thread/thread_time.hpp>
  #if defined BOOST_THREAD_USES_DATETIME
  #include <boost/thread/xtime.hpp>
  #endif
  #include <boost/detail/interlocked.hpp>
  #ifdef BOOST_THREAD_USES_CHRONO
  #include <boost/chrono/system_clocks.hpp>
  #include <boost/chrono/ceil.hpp>
  #endif
  #include <boost/config/abi_prefix.hpp>
  
  namespace boost
  {
      namespace detail
      {
          struct basic_timed_mutex
          {
              BOOST_STATIC_CONSTANT(unsigned char,lock_flag_bit=31);
              BOOST_STATIC_CONSTANT(unsigned char,event_set_flag_bit=30);
              BOOST_STATIC_CONSTANT(long,lock_flag_value=1<<lock_flag_bit);
              BOOST_STATIC_CONSTANT(long,event_set_flag_value=1<<event_set_flag_bit);
              long active_count;
              void* event;
  
              void initialize()
              {
                  active_count=0;
                  event=0;
              }
  
              void destroy()
              {
  #ifdef BOOST_MSVC
  #pragma warning(push)
  #pragma warning(disable:4312)
  #endif
                  void* const old_event=BOOST_INTERLOCKED_EXCHANGE_POINTER(&event,0);
  #ifdef BOOST_MSVC
  #pragma warning(pop)
  #endif
                  if(old_event)
                  {
                      win32::CloseHandle(old_event);
                  }
              }
  
  
              bool try_lock() BOOST_NOEXCEPT
              {
                  return !win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit);
              }
  
              void lock()
              {
                  if(try_lock())
                  {
                      return;
                  }
                  long old_count=active_count;
                  mark_waiting_and_try_lock(old_count);
  
                  if(old_count&lock_flag_value)
                  {
                      bool lock_acquired=false;
                      void* const sem=get_event();
  
                      do
                      {
                          unsigned const retval(win32::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
                          BOOST_VERIFY(0 == retval || ::boost::detail::win32::wait_abandoned == retval);
  //                        BOOST_VERIFY(win32::WaitForSingleObject(
  //                                         sem,::boost::detail::win32::infinite)==0);
                          clear_waiting_and_try_lock(old_count);
                          lock_acquired=!(old_count&lock_flag_value);
                      }
                      while(!lock_acquired);
                  }
              }
              void mark_waiting_and_try_lock(long& old_count)
              {
                  for(;;)
                  {
                      bool const was_locked=(old_count&lock_flag_value) ? true : false;
                      long const new_count=was_locked?(old_count+1):(old_count|lock_flag_value);
                      long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
                      if(current==old_count)
                      {
                          if(was_locked)
                              old_count=new_count;
                          break;
                      }
                      old_count=current;
                  }
              }
  
              void clear_waiting_and_try_lock(long& old_count)
              {
                  old_count&=~lock_flag_value;
                  old_count|=event_set_flag_value;
                  for(;;)
                  {
                      long const new_count=((old_count&lock_flag_value)?old_count:((old_count-1)|lock_flag_value))&~event_set_flag_value;
                      long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
                      if(current==old_count)
                      {
                          break;
                      }
                      old_count=current;
                  }
              }
  
  
  #if defined BOOST_THREAD_USES_DATETIME
              bool timed_lock(::boost::system_time const& wait_until)
              {
                  if(try_lock())
                  {
                      return true;
                  }
                  long old_count=active_count;
                  mark_waiting_and_try_lock(old_count);
  
                  if(old_count&lock_flag_value)
                  {
                      bool lock_acquired=false;
                      void* const sem=get_event();
  
                      do
                      {
                          if(win32::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
                          {
                              BOOST_INTERLOCKED_DECREMENT(&active_count);
                              return false;
                          }
                          clear_waiting_and_try_lock(old_count);
                          lock_acquired=!(old_count&lock_flag_value);
                      }
                      while(!lock_acquired);
                  }
                  return true;
              }
  
              template<typename Duration>
              bool timed_lock(Duration const& timeout)
              {
                  return timed_lock(get_system_time()+timeout);
              }
  
              bool timed_lock(boost::xtime const& timeout)
              {
                  return timed_lock(system_time(timeout));
              }
  #endif
  #ifdef BOOST_THREAD_USES_CHRONO
              template <class Rep, class Period>
              bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
              {
                return try_lock_until(chrono::steady_clock::now() + rel_time);
              }
              template <class Clock, class Duration>
              bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
              {
                using namespace chrono;
                system_clock::time_point     s_now = system_clock::now();
                typename Clock::time_point  c_now = Clock::now();
                return try_lock_until(s_now + ceil<system_clock::duration>(t - c_now));
              }
              template <class Duration>
              bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
              {
                using namespace chrono;
                typedef time_point<chrono::system_clock, chrono::system_clock::duration> sys_tmpt;
                return try_lock_until(sys_tmpt(chrono::ceil<chrono::system_clock::duration>(t.time_since_epoch())));
              }
              bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::system_clock::duration>& tp)
              {
                if(try_lock())
                {
                    return true;
                }
                long old_count=active_count;
                mark_waiting_and_try_lock(old_count);
  
                if(old_count&lock_flag_value)
                {
                    bool lock_acquired=false;
                    void* const sem=get_event();
  
                    do
                    {
                        chrono::time_point<chrono::system_clock, chrono::system_clock::duration> now = chrono::system_clock::now();
                        if (tp<=now) {
                          BOOST_INTERLOCKED_DECREMENT(&active_count);
                          return false;
                        }
                        chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-now);
  
                        if(win32::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
                        {
                            BOOST_INTERLOCKED_DECREMENT(&active_count);
                            return false;
                        }
                        clear_waiting_and_try_lock(old_count);
                        lock_acquired=!(old_count&lock_flag_value);
                    }
                    while(!lock_acquired);
                }
                return true;
              }
  #endif
  
              void unlock()
              {
                  long const offset=lock_flag_value;
                  long const old_count=BOOST_INTERLOCKED_EXCHANGE_ADD(&active_count,lock_flag_value);
                  if(!(old_count&event_set_flag_value) && (old_count>offset))
                  {
                      if(!win32::interlocked_bit_test_and_set(&active_count,event_set_flag_bit))
                      {
                          win32::SetEvent(get_event());
                      }
                  }
              }
  
          private:
              void* get_event()
              {
                  void* current_event=::boost::detail::interlocked_read_acquire(&event);
  
                  if(!current_event)
                  {
                      void* const new_event=win32::create_anonymous_event(win32::auto_reset_event,win32::event_initially_reset);
  #ifdef BOOST_MSVC
  #pragma warning(push)
  #pragma warning(disable:4311)
  #pragma warning(disable:4312)
  #endif
                      void* const old_event=BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&event,new_event,0);
  #ifdef BOOST_MSVC
  #pragma warning(pop)
  #endif
                      if(old_event!=0)
                      {
                          win32::CloseHandle(new_event);
                          return old_event;
                      }
                      else
                      {
                          return new_event;
                      }
                  }
                  return current_event;
              }
  
          };
  
      }
  }
  
  #define BOOST_BASIC_TIMED_MUTEX_INITIALIZER {0}
  
  #include <boost/config/abi_suffix.hpp>
  
  #endif
  