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

// (C) Copyright 2007 Anthony Williams

#ifndef BOOST_THREAD_LOCKS_HPP

#define BOOST_THREAD_LOCKS_HPP

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

#include <boost/thread/exceptions.hpp>

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

#include <algorithm>

#include <iterator>

#include <boost/thread/thread_time.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/config/abi_prefix.hpp>

namespace boost

{

    struct xtime;

#if defined(BOOST_NO_SFINAE) ||                           \

    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \

    BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))

#define BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES

#endif

#ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES

    namespace detail

    {

        template<typename T>

        struct has_member_lock

        {

            typedef char true_type;

            struct false_type

            {

                true_type dummy[2];

            };

            template<typename U>

            static true_type has_member(U*,void (U::*dummy)()=&U::lock);

            static false_type has_member(void*);

            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_lock<T>::has_member((T*)NULL))==sizeof(true_type));

        };

        template<typename T>

        struct has_member_unlock

        {

            typedef char true_type;

            struct false_type

            {

                true_type dummy[2];

            };

            template<typename U>

            static true_type has_member(U*,void (U::*dummy)()=&U::unlock);

            static false_type has_member(void*);

            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_unlock<T>::has_member((T*)NULL))==sizeof(true_type));

        };

        template<typename T>

        struct has_member_try_lock

        {

            typedef char true_type;

            struct false_type

            {

                true_type dummy[2];

            };

            template<typename U>

            static true_type has_member(U*,bool (U::*dummy)()=&U::try_lock);

            static false_type has_member(void*);

            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_try_lock<T>::has_member((T*)NULL))==sizeof(true_type));

        };

    }

    template<typename T>

    struct is_mutex_type

    {

        BOOST_STATIC_CONSTANT(bool, value = detail::has_member_lock<T>::value &&

                              detail::has_member_unlock<T>::value &&

                              detail::has_member_try_lock<T>::value);

    };

#else

    template<typename T>

    struct is_mutex_type

    {

        BOOST_STATIC_CONSTANT(bool, value = false);

    };

#endif    

    struct defer_lock_t

    {};

    struct try_to_lock_t

    {};

    struct adopt_lock_t

    {};

    const defer_lock_t defer_lock={};

    const try_to_lock_t try_to_lock={};

    const adopt_lock_t adopt_lock={};

    template<typename Mutex>

    class shared_lock;

    template<typename Mutex>

    class upgrade_lock;

    template<typename Mutex>

    class unique_lock;

    namespace detail

    {

        template<typename Mutex>

        class try_lock_wrapper;

    }

#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES

    template<typename T>

    struct is_mutex_type<unique_lock<T> >

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    template<typename T>

    struct is_mutex_type<shared_lock<T> >

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    template<typename T>

    struct is_mutex_type<upgrade_lock<T> >

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    template<typename T>

    struct is_mutex_type<detail::try_lock_wrapper<T> >

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    class mutex;

    class timed_mutex;

    class recursive_mutex;

    class recursive_timed_mutex;

    class shared_mutex;

    template<>

    struct is_mutex_type<mutex>

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    template<>

    struct is_mutex_type<timed_mutex>

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    template<>

    struct is_mutex_type<recursive_mutex>

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    template<>

    struct is_mutex_type<recursive_timed_mutex>

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

    template<>

    struct is_mutex_type<shared_mutex>

    {

        BOOST_STATIC_CONSTANT(bool, value = true);

    };

#endif

    template<typename Mutex>

    class lock_guard

    {

    private:

        Mutex& m;

        explicit lock_guard(lock_guard&);

        lock_guard& operator=(lock_guard&);

    public:

        explicit lock_guard(Mutex& m_):

            m(m_)

        {

            m.lock();

        }

        lock_guard(Mutex& m_,adopt_lock_t):

            m(m_)

        {}

        ~lock_guard()

        {

            m.unlock();

        }

    };

    template<typename Mutex>

    class unique_lock

    {

    private:

        Mutex* m;

        bool is_locked;

        unique_lock(unique_lock&);

        explicit unique_lock(upgrade_lock<Mutex>&);

        unique_lock& operator=(unique_lock&);

        unique_lock& operator=(upgrade_lock<Mutex>& other);

    public:

        unique_lock():

            m(0),is_locked(false)

        {}

        explicit unique_lock(Mutex& m_):

            m(&m_),is_locked(false)

        {

            lock();

        }

        unique_lock(Mutex& m_,adopt_lock_t):

            m(&m_),is_locked(true)

        {}

        unique_lock(Mutex& m_,defer_lock_t):

            m(&m_),is_locked(false)

        {}

        unique_lock(Mutex& m_,try_to_lock_t):

            m(&m_),is_locked(false)

        {

            try_lock();

        }

        template<typename TimeDuration>

        unique_lock(Mutex& m_,TimeDuration const& target_time):

            m(&m_),is_locked(false)

        {

            timed_lock(target_time);

        }

        unique_lock(Mutex& m_,system_time const& target_time):

            m(&m_),is_locked(false)

        {

            timed_lock(target_time);

        }

#ifdef BOOST_HAS_RVALUE_REFS

        unique_lock(unique_lock&& other):

            m(other.m),is_locked(other.is_locked)

        {

            other.is_locked=false;

            other.m=0;

        }

        explicit unique_lock(upgrade_lock<Mutex>&& other);

        unique_lock<Mutex>&& move()

        {

            return static_cast<unique_lock<Mutex>&&>(*this);

        }

        unique_lock& operator=(unique_lock<Mutex>&& other)

        {

            unique_lock temp(other);

            swap(temp);

            return *this;

        }

        unique_lock& operator=(upgrade_lock<Mutex>&& other)

        {

            unique_lock temp(other);

            swap(temp);

            return *this;

        }

        void swap(unique_lock&& other)

        {

            std::swap(m,other.m);

            std::swap(is_locked,other.is_locked);

        }

#else

        unique_lock(detail::thread_move_t<unique_lock<Mutex> > other):

            m(other->m),is_locked(other->is_locked)

        {

            other->is_locked=false;

            other->m=0;

        }

        unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other);

        operator detail::thread_move_t<unique_lock<Mutex> >()

        {

            return move();

        }

        detail::thread_move_t<unique_lock<Mutex> > move()

        {

            return detail::thread_move_t<unique_lock<Mutex> >(*this);

        }

        unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)

        {

            unique_lock temp(other);

            swap(temp);

            return *this;

        }

        unique_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)

        {

            unique_lock temp(other);

            swap(temp);

            return *this;

        }

        void swap(unique_lock& other)

        {

            std::swap(m,other.m);

            std::swap(is_locked,other.is_locked);

        }

        void swap(detail::thread_move_t<unique_lock<Mutex> > other)

        {

            std::swap(m,other->m);

            std::swap(is_locked,other->is_locked);

        }

#endif

        ~unique_lock()

        {

            if(owns_lock())

            {

                m->unlock();

            }

        }

        void lock()

        {

            if(owns_lock())

            {

                throw boost::lock_error();

            }

            m->lock();

            is_locked=true;

        }

        bool try_lock()

        {

            if(owns_lock())

            {

                throw boost::lock_error();

            }

            is_locked=m->try_lock();

            return is_locked;

        }

        template<typename TimeDuration>

        bool timed_lock(TimeDuration const& relative_time)

        {

            is_locked=m->timed_lock(relative_time);

            return is_locked;

        }

        bool timed_lock(::boost::system_time const& absolute_time)

        {

            is_locked=m->timed_lock(absolute_time);

            return is_locked;

        }

        bool timed_lock(::boost::xtime const& absolute_time)

        {

            is_locked=m->timed_lock(absolute_time);

            return is_locked;

        }

        void unlock()

        {

            if(!owns_lock())

            {

                throw boost::lock_error();

            }

            m->unlock();

            is_locked=false;

        }

        typedef void (unique_lock::*bool_type)();

        operator bool_type() const

        {

            return is_locked?&unique_lock::lock:0;

        }

        bool operator!() const

        {

            return !owns_lock();

        }

        bool owns_lock() const

        {

            return is_locked;

        }

        Mutex* mutex() const

        {

            return m;

        }

        Mutex* release()

        {

            Mutex* const res=m;

            m=0;

            is_locked=false;

            return res;

        }

        friend class shared_lock<Mutex>;

        friend class upgrade_lock<Mutex>;

    };

#ifdef BOOST_HAS_RVALUE_REFS

    template<typename Mutex>

    void swap(unique_lock<Mutex>&& lhs,unique_lock<Mutex>&& rhs)

    {

        lhs.swap(rhs);

    }

#else

    template<typename Mutex>

    void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs)

    {

        lhs.swap(rhs);

    }

#endif

#ifdef BOOST_HAS_RVALUE_REFS

    template<typename Mutex>

    inline unique_lock<Mutex>&& move(unique_lock<Mutex>&& ul)

    {

        return ul;

    }

#endif

    template<typename Mutex>

    class shared_lock

    {

    protected:

        Mutex* m;

        bool is_locked;

    private:

        explicit shared_lock(shared_lock&);

        shared_lock& operator=(shared_lock&);

    public:

        shared_lock():

            m(0),is_locked(false)

        {}

        explicit shared_lock(Mutex& m_):

            m(&m_),is_locked(false)

        {

            lock();

        }

        shared_lock(Mutex& m_,adopt_lock_t):

            m(&m_),is_locked(true)

        {}

        shared_lock(Mutex& m_,defer_lock_t):

            m(&m_),is_locked(false)

        {}

        shared_lock(Mutex& m_,try_to_lock_t):

            m(&m_),is_locked(false)

        {

            try_lock();

        }

        shared_lock(Mutex& m_,system_time const& target_time):

            m(&m_),is_locked(false)

        {

            timed_lock(target_time);

        }

        shared_lock(detail::thread_move_t<shared_lock<Mutex> > other):

            m(other->m),is_locked(other->is_locked)

        {

            other->is_locked=false;

            other->m=0;

        }

        shared_lock(detail::thread_move_t<unique_lock<Mutex> > other):

            m(other->m),is_locked(other->is_locked)

        {

            if(is_locked)

            {

                m->unlock_and_lock_shared();

            }

            other->is_locked=false;

            other->m=0;

        }

        shared_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):

            m(other->m),is_locked(other->is_locked)

        {

            if(is_locked)

            {

                m->unlock_upgrade_and_lock_shared();

            }

            other->is_locked=false;

            other->m=0;

        }

        operator detail::thread_move_t<shared_lock<Mutex> >()

        {

            return move();

        }

        detail::thread_move_t<shared_lock<Mutex> > move()

        {

            return detail::thread_move_t<shared_lock<Mutex> >(*this);

        }

        shared_lock& operator=(detail::thread_move_t<shared_lock<Mutex> > other)

        {

            shared_lock temp(other);

            swap(temp);

            return *this;

        }

        shared_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)

        {

            shared_lock temp(other);

            swap(temp);

            return *this;

        }

        shared_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)

        {

            shared_lock temp(other);

            swap(temp);

            return *this;

        }

#ifdef BOOST_HAS_RVALUE_REFS

        void swap(shared_lock&& other)