#ifndef BOOST_THREAD_V2_SHARED_MUTEX_HPP
#define BOOST_THREAD_V2_SHARED_MUTEX_HPP

//  shared_mutex.hpp
//
// Copyright Howard Hinnant 2007-2010.
// Copyright Vicente J. Botet Escriba 2012.
//
//  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)

/*
<shared_mutex> synopsis

namespace boost
{
namespace thread_v2
{

class shared_mutex
{
public:

    shared_mutex();
    ~shared_mutex();

    shared_mutex(const shared_mutex&) = delete;
    shared_mutex& operator=(const shared_mutex&) = delete;

    // Exclusive ownership

    void lock();
    bool try_lock();
    template <class Rep, class Period>
        bool try_lock_for(const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_lock_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock();

    // Shared ownership

    void lock_shared();
    bool try_lock_shared();
    template <class Rep, class Period>
        bool
        try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_lock_shared_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock_shared();
};

class upgrade_mutex
{
public:

    upgrade_mutex();
    ~upgrade_mutex();

    upgrade_mutex(const upgrade_mutex&) = delete;
    upgrade_mutex& operator=(const upgrade_mutex&) = delete;

    // Exclusive ownership

    void lock();
    bool try_lock();
    template <class Rep, class Period>
        bool try_lock_for(const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_lock_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock();

    // Shared ownership

    void lock_shared();
    bool try_lock_shared();
    template <class Rep, class Period>
        bool
        try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_lock_shared_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock_shared();

    // Upgrade ownership

    void lock_upgrade();
    bool try_lock_upgrade();
    template <class Rep, class Period>
        bool
        try_lock_upgrade_for(
                            const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_lock_upgrade_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock_upgrade();

    // Shared <-> Exclusive

    bool try_unlock_shared_and_lock();
    template <class Rep, class Period>
        bool
        try_unlock_shared_and_lock_for(
                            const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_unlock_shared_and_lock_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock_and_lock_shared();

    // Shared <-> Upgrade

    bool try_unlock_shared_and_lock_upgrade();
    template <class Rep, class Period>
        bool
        try_unlock_shared_and_lock_upgrade_for(
                            const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_unlock_shared_and_lock_upgrade_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock_upgrade_and_lock_shared();

    // Upgrade <-> Exclusive

    void unlock_upgrade_and_lock();
    bool try_unlock_upgrade_and_lock();
    template <class Rep, class Period>
        bool
        try_unlock_upgrade_and_lock_for(
                            const boost::chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool
        try_unlock_upgrade_and_lock_until(
                      const boost::chrono::time_point<Clock, Duration>& abs_time);
    void unlock_and_lock_upgrade();
};

}  // thread_v2
}  // boost

 */

#include <b/thread/detail/config.hpp>
#include <b/thread/mutex.hpp>
#include <b/thread/condition_variable.hpp>
#include <b/thread/mutex.hpp>
#ifdef BOOST_THREAD_USES_CHRONO
#include <b/chrono.hpp>
#endif
#include <climits>
#include <b/system/system_error.hpp>
#include <b/bind/bind.hpp>

namespace boost {
  namespace thread_v2 {

    class shared_mutex
    {
      typedef boost::mutex              mutex_t;
      typedef boost::condition_variable cond_t;
      typedef unsigned                  count_t;

      mutex_t mut_;
      cond_t  gate1_;
      // the gate2_ condition variable is only used by functions that
      // have taken write_entered_ but are waiting for no_readers()
      cond_t  gate2_;
      count_t state_;

      static const count_t write_entered_ = 1U << (sizeof(count_t)*CHAR_BIT - 1);
      static const count_t n_readers_ = ~write_entered_;

      bool no_writer() const
      {
        return (state_ & write_entered_) == 0;
      }

      bool one_writer() const
      {
        return (state_ & write_entered_) != 0;
      }

      bool no_writer_no_readers() const
      {
        //return (state_ & write_entered_) == 0 &&
        //       (state_ & n_readers_) == 0;
        return state_ == 0;
      }

      bool no_writer_no_max_readers() const
      {
        return (state_ & write_entered_) == 0 &&
               (state_ & n_readers_) != n_readers_;
      }

      bool no_readers() const
      {
        return (state_ & n_readers_) == 0;
      }

      bool one_or_more_readers() const
      {
        return (state_ & n_readers_) > 0;
      }

      shared_mutex(shared_mutex const&);
      shared_mutex& operator=(shared_mutex const&);

    public:
      shared_mutex();
      ~shared_mutex();

      // Exclusive ownership

      void lock();
      bool try_lock();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_lock_for(const boost::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 boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
#if defined BOOST_THREAD_USES_DATETIME
      template<typename T>
      bool timed_lock(T const & abs_or_rel_time);
#endif
      void unlock();

      // Shared ownership

      void lock_shared();
      bool try_lock_shared();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time)
      {
        return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
      }
      template <class Clock, class Duration>
      bool try_lock_shared_until(
          const boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
#if defined BOOST_THREAD_USES_DATETIME
      template<typename T>
      bool timed_lock_shared(T const & abs_or_rel_time);
#endif
      void unlock_shared();
    };

    inline shared_mutex::shared_mutex()
    : state_(0)
    {
    }

    inline shared_mutex::~shared_mutex()
    {
      boost::lock_guard<mutex_t> _(mut_);
    }

    // Exclusive ownership

    inline void shared_mutex::lock()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      gate1_.wait(lk, boost::bind(&shared_mutex::no_writer, boost::ref(*this)));
      state_ |= write_entered_;
      gate2_.wait(lk, boost::bind(&shared_mutex::no_readers, boost::ref(*this)));
    }

    inline bool shared_mutex::try_lock()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!no_writer_no_readers())
      {
        return false;
      }
      state_ = write_entered_;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool shared_mutex::try_lock_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.wait_until(lk, abs_time, boost::bind(
            &shared_mutex::no_writer, boost::ref(*this))))
      {
        return false;
      }
      state_ |= write_entered_;
      if (!gate2_.wait_until(lk, abs_time, boost::bind(
            &shared_mutex::no_readers, boost::ref(*this))))
      {
        state_ &= ~write_entered_;
        return false;
      }
      return true;
    }
#endif

#if defined BOOST_THREAD_USES_DATETIME
    template<typename T>
    bool shared_mutex::timed_lock(T const & abs_or_rel_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
            &shared_mutex::no_writer, boost::ref(*this))))
      {
        return false;
      }
      state_ |= write_entered_;
      if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind(
            &shared_mutex::no_readers, boost::ref(*this))))
      {
        state_ &= ~write_entered_;
        return false;
      }
      return true;
    }
#endif

    inline void shared_mutex::unlock()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(one_writer());
      BOOST_ASSERT(no_readers());
      state_ = 0;
      // notify all since multiple *lock_shared*() calls may be able
      // to proceed in response to this notification
      gate1_.notify_all();
    }

    // Shared ownership

    inline void shared_mutex::lock_shared()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      gate1_.wait(lk, boost::bind(&shared_mutex::no_writer_no_max_readers, boost::ref(*this)));
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
    }

    inline bool shared_mutex::try_lock_shared()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!no_writer_no_max_readers())
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool shared_mutex::try_lock_shared_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.wait_until(lk, abs_time, boost::bind(
            &shared_mutex::no_writer_no_max_readers, boost::ref(*this))))
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      return true;
    }
#endif

#if defined BOOST_THREAD_USES_DATETIME
    template<typename T>
    bool shared_mutex::timed_lock_shared(T const & abs_or_rel_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
            &shared_mutex::no_writer_no_max_readers, boost::ref(*this))))
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      return true;
    }
#endif

    inline void shared_mutex::unlock_shared()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(one_or_more_readers());
      count_t num_readers = (state_ & n_readers_) - 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      if (no_writer())
      {
        if (num_readers == n_readers_ - 1)
          gate1_.notify_one();
      }
      else
      {
        if (num_readers == 0)
          gate2_.notify_one();
      }
    }

  }  // thread_v2
}  // boost

namespace boost {
  namespace thread_v2 {

    class upgrade_mutex
    {
      typedef boost::mutex              mutex_t;
      typedef boost::condition_variable cond_t;
      typedef unsigned                  count_t;

      mutex_t mut_;
      cond_t  gate1_;
      // the gate2_ condition variable is only used by functions that
      // have taken write_entered_ but are waiting for no_readers()
      cond_t  gate2_;
      count_t state_;

      static const unsigned write_entered_ = 1U << (sizeof(count_t)*CHAR_BIT - 1);
      static const unsigned upgradable_entered_ = write_entered_ >> 1;
      static const unsigned n_readers_ = ~(write_entered_ | upgradable_entered_);

      bool no_writer() const
      {
        return (state_ & write_entered_) == 0;
      }

      bool one_writer() const
      {
        return (state_ & write_entered_) != 0;
      }

      bool no_writer_no_max_readers() const
      {
        return (state_ & write_entered_) == 0 &&
               (state_ & n_readers_) != n_readers_;
      }

      bool no_writer_no_upgrader() const
      {
        return (state_ & (write_entered_ | upgradable_entered_)) == 0;
      }

      bool no_writer_no_upgrader_no_readers() const
      {
        //return (state_ & (write_entered_ | upgradable_entered_)) == 0 &&
        //       (state_ & n_readers_) == 0;
        return state_ == 0;
      }

      bool no_writer_no_upgrader_one_reader() const
      {
        //return (state_ & (write_entered_ | upgradable_entered_)) == 0 &&
        //       (state_ & n_readers_) == 1;
        return state_ == 1;
      }

      bool no_writer_no_upgrader_no_max_readers() const
      {
        return (state_ & (write_entered_ | upgradable_entered_)) == 0 &&
               (state_ & n_readers_) != n_readers_;
      }

      bool no_upgrader() const
      {
        return (state_ & upgradable_entered_) == 0;
      }

      bool one_upgrader() const
      {
        return (state_ & upgradable_entered_) != 0;
      }

      bool no_readers() const
      {
        return (state_ & n_readers_) == 0;
      }

      bool one_reader() const
      {
        return (state_ & n_readers_) == 1;
      }

      bool one_or_more_readers() const
      {
        return (state_ & n_readers_) > 0;
      }

      upgrade_mutex(const upgrade_mutex&);
      upgrade_mutex& operator=(const upgrade_mutex&);

    public:
      upgrade_mutex();
      ~upgrade_mutex();

      // Exclusive ownership

      void lock();
      bool try_lock();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_lock_for(const boost::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 boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
#if defined BOOST_THREAD_USES_DATETIME
      template<typename T>
      bool timed_lock(T const & abs_or_rel_time);
#endif
      void unlock();

      // Shared ownership

      void lock_shared();
      bool try_lock_shared();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time)
      {
        return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
      }
      template <class Clock, class Duration>
      bool try_lock_shared_until(
          const boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
#if defined BOOST_THREAD_USES_DATETIME
      template<typename T>
      bool timed_lock_shared(T const & abs_or_rel_time);
#endif
      void unlock_shared();

      // Upgrade ownership

      void lock_upgrade();
      bool try_lock_upgrade();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_lock_upgrade_for(
          const boost::chrono::duration<Rep, Period>& rel_time)
      {
        return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
      }
      template <class Clock, class Duration>
      bool try_lock_upgrade_until(
          const boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
#if defined BOOST_THREAD_USES_DATETIME
      template<typename T>
      bool timed_lock_upgrade(T const & abs_or_rel_time);
#endif
      void unlock_upgrade();

      // Shared <-> Exclusive

#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
      //bool unlock_shared_and_lock(); // can cause a deadlock if used
      bool try_unlock_shared_and_lock();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_unlock_shared_and_lock_for(
          const boost::chrono::duration<Rep, Period>& rel_time)
      {
        return try_unlock_shared_and_lock_until(chrono::steady_clock::now() + rel_time);
      }
      template <class Clock, class Duration>
      bool try_unlock_shared_and_lock_until(
          const boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
#endif
      void unlock_and_lock_shared();

      // Shared <-> Upgrade

#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
      //bool unlock_shared_and_lock_upgrade(); // can cause a deadlock if used
      bool try_unlock_shared_and_lock_upgrade();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_unlock_shared_and_lock_upgrade_for(
          const boost::chrono::duration<Rep, Period>& rel_time)
      {
        return try_unlock_shared_and_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
      }
      template <class Clock, class Duration>
      bool try_unlock_shared_and_lock_upgrade_until(
          const boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
#endif
      void unlock_upgrade_and_lock_shared();

      // Upgrade <-> Exclusive

      void unlock_upgrade_and_lock();
      bool try_unlock_upgrade_and_lock();
#ifdef BOOST_THREAD_USES_CHRONO
      template <class Rep, class Period>
      bool try_unlock_upgrade_and_lock_for(
          const boost::chrono::duration<Rep, Period>& rel_time)
      {
        return try_unlock_upgrade_and_lock_until(chrono::steady_clock::now() + rel_time);
      }
      template <class Clock, class Duration>
      bool try_unlock_upgrade_and_lock_until(
          const boost::chrono::time_point<Clock, Duration>& abs_time);
#endif
      void unlock_and_lock_upgrade();
    };

    inline upgrade_mutex::upgrade_mutex()
    : gate1_(),
      gate2_(),
      state_(0)
    {
    }

    inline upgrade_mutex::~upgrade_mutex()
    {
      boost::lock_guard<mutex_t> _(mut_);
    }

    // Exclusive ownership

    inline void upgrade_mutex::lock()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)));
      state_ |= write_entered_;
      gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this)));
    }

    inline bool upgrade_mutex::try_lock()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!no_writer_no_upgrader_no_readers())
      {
        return false;
      }
      state_ = write_entered_;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool upgrade_mutex::try_lock_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
      {
        return false;
      }
      state_ |= write_entered_;
      if (!gate2_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_readers, boost::ref(*this))))
      {
        state_ &= ~write_entered_;
        return false;
      }
      return true;
    }
#endif

#if defined BOOST_THREAD_USES_DATETIME
    template<typename T>
    bool upgrade_mutex::timed_lock(T const & abs_or_rel_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
      {
        return false;
      }
      state_ |= write_entered_;
      if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind(
            &upgrade_mutex::no_readers, boost::ref(*this))))
      {
        state_ &= ~write_entered_;
        return false;
      }
      return true;
    }
#endif

    inline void upgrade_mutex::unlock()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(one_writer());
      BOOST_ASSERT(no_upgrader());
      BOOST_ASSERT(no_readers());
      state_ = 0;
      // notify all since multiple *lock_shared*() calls and a *lock_upgrade*()
      // call may be able to proceed in response to this notification
      gate1_.notify_all();
    }

    // Shared ownership

    inline void upgrade_mutex::lock_shared()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_max_readers, boost::ref(*this)));
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
    }

    inline bool upgrade_mutex::try_lock_shared()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!no_writer_no_max_readers())
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool upgrade_mutex::try_lock_shared_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this))))
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      return true;
    }
#endif

#if defined BOOST_THREAD_USES_DATETIME
    template<typename T>
    bool upgrade_mutex::timed_lock_shared(T const & abs_or_rel_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
            &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this))))
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      return true;
    }
#endif

    inline void upgrade_mutex::unlock_shared()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(one_or_more_readers());
      count_t num_readers = (state_ & n_readers_) - 1;
      state_ &= ~n_readers_;
      state_ |= num_readers;
      if (no_writer())
      {
        if (num_readers == n_readers_ - 1)
          gate1_.notify_one();
      }
      else
      {
        if (num_readers == 0)
          gate2_.notify_one();
      }
    }

    // Upgrade ownership

    inline void upgrade_mutex::lock_upgrade()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this)));
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= upgradable_entered_ | num_readers;
    }

    inline bool upgrade_mutex::try_lock_upgrade()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!no_writer_no_upgrader_no_max_readers())
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= upgradable_entered_ | num_readers;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool upgrade_mutex::try_lock_upgrade_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this))))
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= upgradable_entered_ | num_readers;
      return true;
    }
#endif

#if defined BOOST_THREAD_USES_DATETIME
    template<typename T>
    bool upgrade_mutex::timed_lock_upgrade(T const & abs_or_rel_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
            &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this))))
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) + 1;
      state_ &= ~n_readers_;
      state_ |= upgradable_entered_ | num_readers;
      return true;
    }
#endif

    inline void upgrade_mutex::unlock_upgrade()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(no_writer());
      BOOST_ASSERT(one_upgrader());
      BOOST_ASSERT(one_or_more_readers());
      count_t num_readers = (state_ & n_readers_) - 1;
      state_ &= ~(upgradable_entered_ | n_readers_);
      state_ |= num_readers;
      // notify all since both a *lock*() and a *lock_shared*() call
      // may be able to proceed in response to this notification
      gate1_.notify_all();
    }

    // Shared <-> Exclusive

#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
    inline bool upgrade_mutex::try_unlock_shared_and_lock()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      BOOST_ASSERT(one_or_more_readers());
      if (!no_writer_no_upgrader_one_reader())
      {
        return false;
      }
      state_ = write_entered_;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool upgrade_mutex::try_unlock_shared_and_lock_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      BOOST_ASSERT(one_or_more_readers());
      if (!gate1_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
      {
        return false;
      }
      count_t num_readers = (state_ & n_readers_) - 1;
      state_ &= ~n_readers_;
      state_ |= (write_entered_ | num_readers);
      if (!gate2_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_readers, boost::ref(*this))))
      {
        ++num_readers;
        state_ &= ~(write_entered_ | n_readers_);
        state_ |= num_readers;
        return false;
      }
      return true;
    }
#endif
#endif

    inline void upgrade_mutex::unlock_and_lock_shared()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(one_writer());
      BOOST_ASSERT(no_upgrader());
      BOOST_ASSERT(no_readers());
      state_ = 1;
      // notify all since multiple *lock_shared*() calls and a *lock_upgrade*()
      // call may be able to proceed in response to this notification
      gate1_.notify_all();
    }

    // Shared <-> Upgrade

#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
    inline bool upgrade_mutex::try_unlock_shared_and_lock_upgrade()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      BOOST_ASSERT(one_or_more_readers());
      if (!no_writer_no_upgrader())
      {
        return false;
      }
      state_ |= upgradable_entered_;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool upgrade_mutex::try_unlock_shared_and_lock_upgrade_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      BOOST_ASSERT(one_or_more_readers());
      if (!gate1_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
      {
        return false;
      }
      state_ |= upgradable_entered_;
      return true;
    }
#endif
#endif

    inline void upgrade_mutex::unlock_upgrade_and_lock_shared()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(no_writer());
      BOOST_ASSERT(one_upgrader());
      BOOST_ASSERT(one_or_more_readers());
      state_ &= ~upgradable_entered_;
      // notify all since only one *lock*() or *lock_upgrade*() call can win and
      // proceed in response to this notification, but a *lock_shared*() call may
      // also be waiting and could steal the notification
      gate1_.notify_all();
    }

    // Upgrade <-> Exclusive

    inline void upgrade_mutex::unlock_upgrade_and_lock()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      BOOST_ASSERT(no_writer());
      BOOST_ASSERT(one_upgrader());
      BOOST_ASSERT(one_or_more_readers());
      count_t num_readers = (state_ & n_readers_) - 1;
      state_ &= ~(upgradable_entered_ | n_readers_);
      state_ |= write_entered_ | num_readers;
      gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this)));
    }

    inline bool upgrade_mutex::try_unlock_upgrade_and_lock()
    {
      boost::unique_lock<mutex_t> lk(mut_);
      BOOST_ASSERT(no_writer());
      BOOST_ASSERT(one_upgrader());
      BOOST_ASSERT(one_or_more_readers());
      if (!one_reader())
      {
        return false;
      }
      state_ = write_entered_;
      return true;
    }

#ifdef BOOST_THREAD_USES_CHRONO
    template <class Clock, class Duration>
    bool upgrade_mutex::try_unlock_upgrade_and_lock_until(
        const boost::chrono::time_point<Clock, Duration>& abs_time)
    {
      boost::unique_lock<mutex_t> lk(mut_);
      BOOST_ASSERT(no_writer());
      BOOST_ASSERT(one_upgrader());
      BOOST_ASSERT(one_or_more_readers());
      count_t num_readers = (state_ & n_readers_) - 1;
      state_ &= ~(upgradable_entered_ | n_readers_);
      state_ |= (write_entered_ | num_readers);
      if (!gate2_.wait_until(lk, abs_time, boost::bind(
            &upgrade_mutex::no_readers, boost::ref(*this))))
      {
        ++num_readers;
        state_ &= ~(write_entered_ | n_readers_);
        state_ |= (upgradable_entered_ | num_readers);
        return false;
      }
      return true;
    }
#endif

    inline void upgrade_mutex::unlock_and_lock_upgrade()
    {
      boost::lock_guard<mutex_t> _(mut_);
      BOOST_ASSERT(one_writer());
      BOOST_ASSERT(no_upgrader());
      BOOST_ASSERT(no_readers());
      state_ = upgradable_entered_ | 1;
      // notify all since multiple *lock_shared*() calls may be able
      // to proceed in response to this notification
      gate1_.notify_all();
    }

  }  // thread_v2
}  // boost

namespace boost {
  //using thread_v2::shared_mutex;
  using thread_v2::upgrade_mutex;
  typedef thread_v2::upgrade_mutex shared_mutex;
}

#endif
