[Boost-commit] svn:boost r40080 - in trunk/boost/thread: . detail

From: anthony_at_[hidden]
Date: 2007-10-16 07:08:18

Author: anthonyw
Date: 2007-10-16 07:08:17 EDT (Tue, 16 Oct 2007)
New Revision: 40080
URL: http://svn.boost.org/trac/boost/changeset/40080

Log:
removed lock_ops as no longer needed
Removed:
   trunk/boost/thread/detail/lock.hpp
   trunk/boost/thread/detail/read_write_lock.hpp
Text files modified: 
   trunk/boost/thread/condition.hpp |     1 -                                       
   1 files changed, 0 insertions(+), 1 deletions(-)

Modified: trunk/boost/thread/condition.hpp
==============================================================================
--- trunk/boost/thread/condition.hpp	(original)
+++ trunk/boost/thread/condition.hpp	2007-10-16 07:08:17 EDT (Tue, 16 Oct 2007)
@@ -12,7 +12,6 @@
 
 #include <boost/thread/exceptions.hpp>
 #include <boost/utility.hpp>
-#include <boost/thread/detail/lock.hpp>
 
 #if defined(BOOST_HAS_PTHREADS)
 #   include <pthread.h>

Deleted: trunk/boost/thread/detail/lock.hpp
==============================================================================
--- trunk/boost/thread/detail/lock.hpp	2007-10-16 07:08:17 EDT (Tue, 16 Oct 2007)
+++ (empty file)
@@ -1,209 +0,0 @@
-// 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_XLOCK_WEK070601_HPP
-#define BOOST_XLOCK_WEK070601_HPP
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/thread/exceptions.hpp>
-
-namespace boost {
-
-class condition;
-struct xtime;
-
-namespace detail { namespace thread {
-
-template <typename Mutex>
-class lock_ops : private noncopyable
-{
-private:
-    lock_ops() { }
-
-public:
-    typedef typename Mutex::cv_state lock_state;
-
-    static void lock(Mutex& m)
-    {
-        m.do_lock();
-    }
-    static bool trylock(Mutex& m)
-    {
-        return m.do_trylock();
-    }
-    static bool timedlock(Mutex& m, const xtime& xt)
-    {
-        return m.do_timedlock(xt);
-    }
-    static void unlock(Mutex& m)
-    {
-        m.do_unlock();
-    }
-    static void lock(Mutex& m, lock_state& state)
-    {
-        m.do_lock(state);
-    }
-    static void unlock(Mutex& m, lock_state& state)
-    {
-        m.do_unlock(state);
-    }
-};
-
-template <typename Mutex>
-class scoped_lock : private noncopyable
-{
-public:
-    typedef Mutex mutex_type;
-
-    explicit scoped_lock(Mutex& mx, bool initially_locked=true)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_lock()
-    {
-        if (m_locked) unlock();
-    }
-
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<Mutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<Mutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    Mutex& m_mutex;
-    bool m_locked;
-};
-
-template <typename TryMutex>
-class scoped_try_lock : private noncopyable
-{
-public:
-    typedef TryMutex mutex_type;
-
-    explicit scoped_try_lock(TryMutex& mx)
-        : m_mutex(mx), m_locked(false)
-    {
-        try_lock();
-    }
-    scoped_try_lock(TryMutex& mx, bool initially_locked)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_try_lock()
-    {
-        if (m_locked) unlock();
-    }
-
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<TryMutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    bool try_lock()
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TryMutex>::trylock(m_mutex));
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<TryMutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    TryMutex& m_mutex;
-    bool m_locked;
-};
-
-template <typename TimedMutex>
-class scoped_timed_lock : private noncopyable
-{
-public:
-    typedef TimedMutex mutex_type;
-
-    scoped_timed_lock(TimedMutex& mx, const xtime& xt)
-        : m_mutex(mx), m_locked(false)
-    {
-        timed_lock(xt);
-    }
-    scoped_timed_lock(TimedMutex& mx, bool initially_locked)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_timed_lock()
-    {
-        if (m_locked) unlock();
-    }
-
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<TimedMutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    bool try_lock()
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TimedMutex>::trylock(m_mutex));
-    }
-    bool timed_lock(const xtime& xt)
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TimedMutex>::timedlock(m_mutex, xt));
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<TimedMutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    TimedMutex& m_mutex;
-    bool m_locked;
-};
-
-} // namespace thread
-} // namespace detail
-} // namespace boost
-
-#endif // BOOST_XLOCK_WEK070601_HPP
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//   22 May 01  WEKEMPF Modified to use xtime for time outs.
-//   30 Jul 01  WEKEMPF Moved lock types into boost::detail::thread. Renamed
-//                      some types. Added locked() methods.

Deleted: trunk/boost/thread/detail/read_write_lock.hpp
==============================================================================
--- trunk/boost/thread/detail/read_write_lock.hpp	2007-10-16 07:08:17 EDT (Tue, 16 Oct 2007)
+++ (empty file)
@@ -1,1106 +0,0 @@
-// Copyright (C)  2002-2003
-// David Moore, Michael Glassford
-//
-// Original scoped_lock implementation
-// Copyright (C) 2001
-// 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_READ_WRITE_LOCK_JDM031002_HPP
-#define BOOST_READ_WRITE_LOCK_JDM031002_HPP
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/thread/detail/lock.hpp>
-
-namespace boost {
-
-struct xtime;
-
-namespace read_write_lock_state {
-    enum read_write_lock_state_enum
-    {
-        unlocked=0,
-        read_locked=1,
-        write_locked=2
-    };
-} //namespace read_write_lock_state
-
-namespace detail {
-namespace thread {
-
-template <typename Mutex>
-class read_write_lock_ops : private noncopyable
-{
-private:
-
-    read_write_lock_ops() { }
-    ~read_write_lock_ops() { }
-
-public:
-
-    typedef Mutex mutex_type;
-
-    static void write_lock(Mutex& m)
-    {
-        m.do_write_lock();
-    }
-    static void read_lock(Mutex& m)
-    {
-        m.do_read_lock();
-    }
-    static void write_unlock(Mutex& m)
-    {
-        m.do_write_unlock();
-    }
-    static void read_unlock(Mutex &m)
-    {
-        m.do_read_unlock();
-    }
-    static bool try_write_lock(Mutex &m)
-    {
-        return m.do_try_write_lock();
-    }
-    static bool try_read_lock(Mutex &m)
-    {
-        return m.do_try_read_lock();
-    }
-
-    static bool timed_write_lock(Mutex &m,const xtime &xt)
-    {
-        return m.do_timed_write_lock(xt);
-    }
-    static bool timed_read_lock(Mutex &m,const xtime &xt)
-    {
-        return m.do_timed_read_lock(xt);
-    }
-
-    static void demote(Mutex & m)
-    {
-        m.do_demote_to_read_lock();
-    }
-    static bool try_demote(Mutex & m)
-    {
-        return m.do_try_demote_to_read_lock();
-    }
-    static bool timed_demote(Mutex & m,const xtime &xt)
-    {
-        return m.do_timed_demote_to_read_lock(xt);
-    }
-
-    static void promote(Mutex & m)
-    {
-        m.do_promote_to_write_lock();
-    }
-    static bool try_promote(Mutex & m)
-    {
-        return m.do_try_promote_to_write_lock();
-    }
-    static bool timed_promote(Mutex & m,const xtime &xt)
-    {
-        return m.do_timed_promote_to_write_lock(xt);
-    }
-};
-
-template <typename ReadWriteMutex>
-class scoped_read_write_lock : private noncopyable
-{
-public:
-
-    typedef ReadWriteMutex mutex_type;
-
-    scoped_read_write_lock(
-        ReadWriteMutex& mx,
-        read_write_lock_state::read_write_lock_state_enum initial_state)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initial_state == read_write_lock_state::read_locked)
-            read_lock();
-        else if (initial_state == read_write_lock_state::write_locked)
-            write_lock();
-    }
-
-    ~scoped_read_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::read_lock(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    void write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::write_lock(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    void unlock()
-    {
-        if (m_state == read_write_lock_state::unlocked) throw lock_error();
-        if (m_state == read_write_lock_state::read_locked)
-            read_write_lock_ops<ReadWriteMutex>::read_unlock(m_mutex);
-        else //(m_state == read_write_lock_state::write_locked)
-            read_write_lock_ops<ReadWriteMutex>::write_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-
-    void demote(void)
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::demote(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    void promote(void)
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::promote(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    //If allow_unlock = true, set_lock always succeeds and
-    //the function result indicates whether an unlock was required.
-    //If allow_unlock = false, set_lock may fail;
-    //the function result indicates whether it succeeded.
-    bool set_lock(read_write_lock_state::read_write_lock_state_enum ls, bool allow_unlock = true)
-    {
-        bool result = !allow_unlock;
-
-        if (m_state != ls)
-        {
-            if (m_state == read_write_lock_state::unlocked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    read_lock();
-                else //(ls == read_write_lock_state::write_locked)
-                    write_lock();
-            }
-            else //(m_state == read_write_lock_state::read_locked || m_state == read_write_lock_state::write_locked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    demote();
-                else if (ls == read_write_lock_state::write_locked)
-                {
-                    if (allow_unlock)
-                    {
-                        result = true;
-                        unlock();
-                        write_lock();
-                    }
-                    else
-                        result = false;
-                }
-                else //(ls == read_write_lock_state::unlocked)
-                    unlock();
-            }
-        }
-
-        return result;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-  
-    bool read_locked() const
-    {
-        return m_state == read_write_lock_state::read_locked;
-    }
-  
-    bool write_locked() const
-    {
-        return m_state != read_write_lock_state::write_locked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-
-    read_write_lock_state::read_write_lock_state_enum state() const
-    {
-        return m_state;
-    }
-    
-private:
-
-    ReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename ReadWriteMutex>
-class scoped_read_lock : private noncopyable
-{
-public:
-
-    typedef ReadWriteMutex mutex_type;
-
-    explicit scoped_read_lock(
-        ReadWriteMutex& mx,
-        bool initially_locked = true)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initially_locked)
-            lock();
-    }
-
-    ~scoped_read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::read_lock(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    void unlock()
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::read_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-    
-private:
-
-    ReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename ReadWriteMutex>
-class scoped_write_lock : private noncopyable
-{
-public:
-
-    typedef ReadWriteMutex mutex_type;
-
-    explicit scoped_write_lock(
-        ReadWriteMutex& mx,
-        bool initially_locked = true)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initially_locked)
-            lock();
-    }
-
-    ~scoped_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::write_lock(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    void unlock()
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        read_write_lock_ops<ReadWriteMutex>::write_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-    
-private:
-
-    ReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename TryReadWriteMutex>
-class scoped_try_read_write_lock : private noncopyable
-{
-public:
-
-    typedef TryReadWriteMutex mutex_type;
-    
-    scoped_try_read_write_lock(
-        TryReadWriteMutex& mx,
-        read_write_lock_state::read_write_lock_state_enum initial_state)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initial_state == read_write_lock_state::read_locked)
-            read_lock();
-        else if (initial_state == read_write_lock_state::write_locked)
-            write_lock();
-    }
-
-    ~scoped_try_read_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::read_lock(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    bool try_read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TryReadWriteMutex>::try_read_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::read_locked;
-            return true;
-        }
-        return false;
-    }
-   
-    void write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::write_lock(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    bool try_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TryReadWriteMutex>::try_write_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::write_locked;
-            return true;
-        }
-        return false;
-    }
-
-    void unlock()
-    {
-        if (m_state == read_write_lock_state::unlocked) throw lock_error();
-        if (m_state == read_write_lock_state::read_locked)
-            read_write_lock_ops<TryReadWriteMutex>::read_unlock(m_mutex);
-        else //(m_state == read_write_lock_state::write_locked)
-            read_write_lock_ops<TryReadWriteMutex>::write_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-
-    void demote(void)
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::demote(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    bool try_demote(void)
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        return read_write_lock_ops<TryReadWriteMutex>::try_demote(m_mutex) ? (m_state = read_write_lock_state::read_locked, true) : false;
-    }
-
-    void promote(void)
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::promote(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    bool try_promote(void)
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        return read_write_lock_ops<TryReadWriteMutex>::try_promote(m_mutex) ? (m_state = read_write_lock_state::write_locked, true) : false;
-    }
-
-    //If allow_unlock = true, set_lock always succeeds and
-    //the function result indicates whether an unlock was required.
-    //If allow_unlock = false, set_lock may fail;
-    //the function result indicates whether it succeeded.
-    bool set_lock(read_write_lock_state::read_write_lock_state_enum ls, bool allow_unlock = true)
-    {
-        bool result = !allow_unlock;
-
-        if (m_state != ls)
-        {
-            if (m_state == read_write_lock_state::unlocked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    read_lock();
-                else //(ls == read_write_lock_state::write_locked)
-                    write_lock();
-            }
-            else //(m_state == read_write_lock_state::read_locked || m_state == read_write_lock_state::write_locked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    demote();
-                else if (ls == read_write_lock_state::write_locked)
-                {
-                    if (!try_promote())
-                    {
-                        if (allow_unlock)
-                        {
-                            result = true;
-                            unlock();
-                            write_lock();
-                        }
-                        else
-                            result = false;
-                    }
-                }
-                else //(ls == read_write_lock_state::unlocked)
-                    unlock();
-            }
-        }
-
-        return result;
-    }
-
-    bool try_set_lock(read_write_lock_state::read_write_lock_state_enum ls)
-    {
-        if (m_state != ls)
-        {
-            if (m_state == read_write_lock_state::unlocked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    return try_read_lock();
-                else // (ls == read_write_lock_state::write_locked)
-                    return try_write_lock();
-            }
-            else //(m_state == read_write_lock_state::read_locked || m_state == read_write_lock_state::write_locked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    return try_demote();
-                else if (ls == read_write_lock_state::write_locked)
-                    return try_promote();
-                else //(ls == read_write_lock_state::unlocked)
-                    return unlock(), true;
-            }
-        }
-        else //(m_state == ls) 
-            return true;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-  
-    bool read_locked() const
-    {
-        return m_state == read_write_lock_state::read_locked;
-    }
-  
-    bool write_locked() const
-    {
-        return m_state != read_write_lock_state::write_locked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-
-    read_write_lock_state::read_write_lock_state_enum state() const
-    {
-        return m_state;
-    }
-
-private:
-
-    TryReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename TryReadWriteMutex>
-class scoped_try_read_lock : private noncopyable
-{
-public:
-
-    typedef TryReadWriteMutex mutex_type;
-    
-    explicit scoped_try_read_lock(
-        TryReadWriteMutex& mx,
-        bool initially_locked = true)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initially_locked)
-            lock();
-    }
-
-    ~scoped_try_read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::read_lock(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    bool try_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TryReadWriteMutex>::try_read_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::read_locked;
-            return true;
-        }
-        return false;
-    }
-
-    void unlock()
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::read_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-
-private:
-
-    TryReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename TryReadWriteMutex>
-class scoped_try_write_lock : private noncopyable
-{
-public:
-
-    typedef TryReadWriteMutex mutex_type;
-    
-    explicit scoped_try_write_lock(
-        TryReadWriteMutex& mx,
-        bool initially_locked = true)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initially_locked)
-            lock();
-    }
-
-    ~scoped_try_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::write_lock(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    bool try_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TryReadWriteMutex>::try_write_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::write_locked;
-            return true;
-        }
-        return false;
-    }
-
-    void unlock()
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        read_write_lock_ops<TryReadWriteMutex>::write_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-
-private:
-
-    TryReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename TimedReadWriteMutex>
-class scoped_timed_read_write_lock : private noncopyable
-{
-public:
-
-    typedef TimedReadWriteMutex mutex_type;
-
-    scoped_timed_read_write_lock(
-        TimedReadWriteMutex& mx,
-        read_write_lock_state::read_write_lock_state_enum initial_state)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initial_state == read_write_lock_state::read_locked)
-            read_lock();
-        else if (initial_state == read_write_lock_state::write_locked)
-            write_lock();
-    }
-
-    ~scoped_timed_read_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::read_lock(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    bool try_read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::try_read_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::read_locked;
-            return true;
-        }
-        return false;
-    }
-
-    bool timed_read_lock(const xtime &xt)
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::timed_read_lock(m_mutex,xt))
-        {
-            m_state = read_write_lock_state::read_locked;
-            return true;
-        }
-        return false;
-    }
-
-    void write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::write_lock(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    bool try_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::try_write_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::write_locked;
-            return true;
-        }
-        return false;
-    }
-
-    bool timed_write_lock(const xtime &xt)
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::timed_write_lock(m_mutex,xt))
-        {
-            m_state = read_write_lock_state::write_locked;
-            return true;
-        }
-        return false;
-    }
-
-    void unlock()
-    {
-        if (m_state == read_write_lock_state::unlocked) throw lock_error();
-        if (m_state == read_write_lock_state::read_locked)
-            read_write_lock_ops<TimedReadWriteMutex>::read_unlock(m_mutex);
-        else //(m_state == read_write_lock_state::write_locked)
-            read_write_lock_ops<TimedReadWriteMutex>::write_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-
-    void demote(void)
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::demote(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    bool try_demote(void)
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        return read_write_lock_ops<TimedReadWriteMutex>::try_demote(m_mutex) ? (m_state = read_write_lock_state::read_locked, true) : false;
-    }
-
-    bool timed_demote(const xtime &xt)
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        return read_write_lock_ops<TimedReadWriteMutex>::timed_demote(m_mutex, xt) ? (m_state = read_write_lock_state::read_locked, true) : false;
-    }
-
-    void promote(void)
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::promote(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    bool try_promote(void)
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        return read_write_lock_ops<TimedReadWriteMutex>::try_promote(m_mutex) ? (m_state = read_write_lock_state::write_locked, true) : false;
-    }
-
-    bool timed_promote(const xtime &xt)
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        return read_write_lock_ops<TimedReadWriteMutex>::timed_promote(m_mutex, xt) ? (m_state = read_write_lock_state::write_locked, true) : false;
-    }
-
-    //If allow_unlock = true, set_lock always succeeds and
-    //the function result indicates whether an unlock was required.
-    //If allow_unlock = false, set_lock may fail;
-    //the function result indicates whether it succeeded.
-    bool set_lock(read_write_lock_state::read_write_lock_state_enum ls, bool allow_unlock = true)
-    {
-        bool result = !allow_unlock;
-
-        if (m_state != ls)
-        {
-            if (m_state == read_write_lock_state::unlocked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    read_lock();
-                else //(ls == read_write_lock_state::write_locked)
-                    write_lock();
-            }
-            else //(m_state == read_write_lock_state::read_locked || m_state == read_write_lock_state::write_locked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    demote();
-                else if (ls == read_write_lock_state::write_locked)
-                {
-                    if (!try_promote())
-                    {
-                        if (allow_unlock)
-                        {
-                            result = true;
-                            unlock();
-                            write_lock();
-                        }
-                        else
-                            result = false;
-                    }
-                }
-                else //(ls == read_write_lock_state::unlocked)
-                    unlock();
-            }
-        }
-
-        return result;
-    }
-
-    bool try_set_lock(read_write_lock_state::read_write_lock_state_enum ls)
-    {
-        if (m_state != ls)
-        {
-            if (m_state == read_write_lock_state::unlocked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    return try_read_lock();
-                else // (ls == read_write_lock_state::write_locked)
-                    return try_write_lock();
-            }
-            else //(m_state == read_write_lock_state::read_locked || m_state == read_write_lock_state::write_locked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    return try_demote();
-                else if (ls == read_write_lock_state::write_locked)
-                    return try_promote();
-                else //(ls == read_write_lock_state::unlocked)
-                    return unlock(), true;
-            }
-        }
-        else //(m_state == ls) 
-            return true;
-    }
-
-    bool timed_set_lock(read_write_lock_state::read_write_lock_state_enum ls, const xtime &xt)
-    {
-        if (m_state != ls)
-        {
-            if (m_state == read_write_lock_state::unlocked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    return timed_read_lock(xt);
-                else // (ls == read_write_lock_state::write_locked)
-                    return timed_write_lock(xt);
-            }
-            else //(m_state == read_write_lock_state::read_locked || m_state == read_write_lock_state::write_locked)
-            {
-                if (ls == read_write_lock_state::read_locked)
-                    return timed_demote(xt);
-                else if (ls == read_write_lock_state::write_locked)
-                    return timed_promote(xt);
-                else //(ls == read_write_lock_state::unlocked)
-                    return unlock(), true;
-            }
-        }
-        else //(m_state == ls)
-            return true;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-  
-    bool read_locked() const
-    {
-        return m_state == read_write_lock_state::read_locked;
-    }
-  
-    bool write_locked() const
-    {
-        return m_state != read_write_lock_state::write_locked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-
-    read_write_lock_state::read_write_lock_state_enum state() const
-    {
-        return m_state;
-    }
-
-private:
-
-    TimedReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename TimedReadWriteMutex>
-class scoped_timed_read_lock : private noncopyable
-{
-public:
-
-    typedef TimedReadWriteMutex mutex_type;
-
-    explicit scoped_timed_read_lock(
-        TimedReadWriteMutex& mx,
-        bool initially_locked = true)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initially_locked)
-            lock();
-    }
-
-    ~scoped_timed_read_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::read_lock(m_mutex);
-        m_state = read_write_lock_state::read_locked;
-    }
-
-    bool try_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::try_read_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::read_locked;
-            return true;
-        }
-        return false;
-    }
-
-    bool timed_lock(const xtime &xt)
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::timed_read_lock(m_mutex,xt))
-        {
-            m_state = read_write_lock_state::read_locked;
-            return true;
-        }
-        return false;
-    }
-
-    void unlock()
-    {
-        if (m_state != read_write_lock_state::read_locked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::read_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-
-    read_write_lock_state::read_write_lock_state_enum state() const
-    {
-        return m_state;
-    }
-
-private:
-
-    TimedReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-template <typename TimedReadWriteMutex>
-class scoped_timed_write_lock : private noncopyable
-{
-public:
-
-    typedef TimedReadWriteMutex mutex_type;
-
-    explicit scoped_timed_write_lock(
-        TimedReadWriteMutex& mx,
-        bool initially_locked = true)
-        : m_mutex(mx), m_state(read_write_lock_state::unlocked)
-    {
-        if (initially_locked)
-            lock();
-    }
-
-    ~scoped_timed_write_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked)
-            unlock();
-    }
-
-    void lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::write_lock(m_mutex);
-        m_state = read_write_lock_state::write_locked;
-    }
-
-    bool try_lock()
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::try_write_lock(m_mutex))
-        {
-            m_state = read_write_lock_state::write_locked;
-            return true;
-        }
-        return false;
-    }
-
-    bool timed_lock(const xtime &xt)
-    {
-        if (m_state != read_write_lock_state::unlocked) throw lock_error();
-        if(read_write_lock_ops<TimedReadWriteMutex>::timed_write_lock(m_mutex,xt))
-        {
-            m_state = read_write_lock_state::write_locked;
-            return true;
-        }
-        return false;
-    }
-
-    void unlock()
-    {
-        if (m_state != read_write_lock_state::write_locked) throw lock_error();
-        read_write_lock_ops<TimedReadWriteMutex>::write_unlock(m_mutex);
-
-        m_state = read_write_lock_state::unlocked;
-    }
-  
-    bool locked() const
-    {
-        return m_state != read_write_lock_state::unlocked;
-    }
-
-    operator const void*() const
-    {
-        return (m_state != read_write_lock_state::unlocked) ? this : 0; 
-    }
-
-    read_write_lock_state::read_write_lock_state_enum state() const
-    {
-        return m_state;
-    }
-
-private:
-
-    TimedReadWriteMutex& m_mutex;
-    read_write_lock_state::read_write_lock_state_enum m_state;
-};
-
-} // namespace thread
-} // namespace detail
-} // namespace boost
-
-#endif
-
-// Change Log:
-//  10 Mar 02 
-//      Original version.
-//   4 May 04 GlassfordM 
-//      Implement lock promotion and demotion (add member functions demote(),
-//         try_demote(), timed_demote(), try_promote(), timed_promote(); note 
-//         that there is intentionally no promote() member function).
-//      Add set_lock() member function.
-//      Change try lock & timed lock constructor parameters for consistency.
-//      Rename to improve consistency and eliminate abbreviations:
-//          Use "read" and "write" instead of "shared" and "exclusive".
-//          Change "rd" to "read", "wr" to "write", "rw" to "read_write".
-//      Add mutex_type typdef.