[Boost-commit] svn:boost r51283 - sandbox/synchro/libs/synchro/doc/reference

Subject: [Boost-commit] svn:boost r51283 - sandbox/synchro/libs/synchro/doc/reference
From: vicente.botet_at_[hidden]
Date: 2009-02-16 19:03:01

Author: viboes
Date: 2009-02-16 19:03:00 EST (Mon, 16 Feb 2009)
New Revision: 51283
URL: http://svn.boost.org/trac/boost/changeset/51283

Log:
Boost.Synchro V0.0.0
More documentation
Added:
   sandbox/synchro/libs/synchro/doc/reference/process_lockable_scope_traits.qbk   (contents, props changed)
   sandbox/synchro/libs/synchro/doc/reference/thread_lockable_scope_traits.qbk   (contents, props changed)
   sandbox/synchro/libs/synchro/doc/reference/thread_locks.qbk   (contents, props changed)
   sandbox/synchro/libs/synchro/doc/reference/thread_mutex.qbk   (contents, props changed)
   sandbox/synchro/libs/synchro/doc/reference/thread_recursive_mutex.qbk   (contents, props changed)
   sandbox/synchro/libs/synchro/doc/reference/thread_shared_mutex.qbk   (contents, props changed)

Added: sandbox/synchro/libs/synchro/doc/reference/process_lockable_scope_traits.qbk
==============================================================================
--- (empty file)
+++ sandbox/synchro/libs/synchro/doc/reference/process_lockable_scope_traits.qbk	2009-02-16 19:03:00 EST (Mon, 16 Feb 2009)
@@ -0,0 +1,56 @@
+[/
+ / Copyright (c) 2008-2009 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)
+ /]
+
+
+[/==========================================================================================]
+[section:thread_lockable_scope_traits_hpp Header `<boost/synchro/thread/lockable_scope_traits.hpp>`]
+[/==========================================================================================]
+
+    namespace boost { namespace synchro {
+        template<> struct scope_traits<multi_process_tag>
+        template<typename Lockable>
+        struct lockable_scope_traits<multi_process_tag, Lockable>;
+    }}
+    
+[section Template Class Specialization `scope_traits<multi_process_tag>`]
+
+
+    template<>
+    struct scope_traits<multi_process_tag> {
+        typedef boost::interprocess::lock_exception lock_error;
+        
+        template <typename T>
+        struct moved_object : boost::interprocess::detail::moved_object<T> {
+            moved_object(T& t_): boost::interprocess::detail::moved_object<T>(t_) {}
+        };
+
+        typedef boost::interprocess::defer_lock_type defer_lock_t;
+        typedef boost::interprocess::accept_ownership_type adopt_lock_t;
+        typedef boost::interprocess::try_to_lock_type try_to_lock_t;
+
+        static const defer_lock_t& defer_lock()    {return boost::interprocess::defer_lock;}
+        static const adopt_lock_t& adopt_lock() {return boost::interprocess::accept_ownership;}
+        static const try_to_lock_t& try_to_lock()    {return boost::interprocess::try_to_lock;}
+    };
+    
+[endsect]
+[section Template Class Specialization `lockable_scope_traits<multi_process_tag, Lockable>`]
+
+    template<typename Lockable>
+    struct lockable_scope_traits<multi_process_tag, Lockable> : scope_traits<multi_process_tag> {
+        typedef Lockable                                             lockable_type;
+        typedef boost::interprocess::scoped_lock<lockable_type>     scoped_lock;
+        typedef boost::interprocess::scoped_lock<lockable_type>     unique_lock;
+        typedef boost::interprocess::sharable_lock<lockable_type>   shared_lock;
+        typedef boost::interprocess::upgradable_lock<lockable_type> upgrade_lock;
+
+    };
+    
+[endsect]
+
+[endsect]

Added: sandbox/synchro/libs/synchro/doc/reference/thread_lockable_scope_traits.qbk
==============================================================================
--- (empty file)
+++ sandbox/synchro/libs/synchro/doc/reference/thread_lockable_scope_traits.qbk	2009-02-16 19:03:00 EST (Mon, 16 Feb 2009)
@@ -0,0 +1,55 @@
+[/
+ / Copyright (c) 2008-2009 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)
+ /]
+
+
+[/==========================================================================================]
+[section:thread_lockable_scope_traits_hpp Header `<boost/synchro/thread/lockable_scope_traits.hpp>`]
+[/==========================================================================================]
+
+    namespace boost { namespace synchro {
+        template<> struct scope_traits<multi_threaded_tag>;
+        template<typename Lockable>
+        struct lockable_scope_traits<multi_threaded_tag, Lockable>;
+    }}
+    
+[section Template Class Specialization `scope_traits<multi_threaded_tag>`]
+
+[*Synopsis]
+
+    template<> struct scope_traits<multi_threaded_tag> {
+        typedef boost::lock_error lock_error;
+        
+        template <typename T>
+        struct moved_object : boost::detail::thread_move_t<T> {
+            moved_object(T& t_): boost::detail::thread_move_t<T>(t_) {}
+        };
+        
+        typedef boost::defer_lock_t defer_lock_t;
+        typedef boost::adopt_lock_t adopt_lock_t;
+        typedef boost::try_to_lock_t try_to_lock_t;
+
+        static const defer_lock_t& defer_lock() {return boost::defer_lock;}
+        static const adopt_lock_t& adopt_lock() {return boost::adopt_lock;}
+        static const try_to_lock_t& try_to_lock() {return boost::try_to_lock;}
+    };
+
+[endsect]
+
+[section Template Class Specialization `lockable_scope_traits<multi_threaded_tag, Lockable>`]
+
+    template<typename Lockable>
+    struct lockable_scope_traits<multi_threaded_tag, Lockable> : scope_traits<multi_threaded_tag> {
+        typedef Lockable                            lockable_type;
+        typedef boost::unique_lock<lockable_type>   scoped_lock;
+        typedef boost::unique_lock<lockable_type>   unique_lock;
+        typedef boost::shared_lock<lockable_type>   shared_lock;
+        typedef boost::upgrade_lock<lockable_type>  upgrade_lock;
+    };
+
+[endsect]
+[endsect]

Added: sandbox/synchro/libs/synchro/doc/reference/thread_locks.qbk
==============================================================================
--- (empty file)
+++ sandbox/synchro/libs/synchro/doc/reference/thread_locks.qbk	2009-02-16 19:03:00 EST (Mon, 16 Feb 2009)
@@ -0,0 +1,283 @@
+[/
+ / Copyright (c) 2008-2009 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)
+ /]
+
+
+[/==========================================================================================]
+[section:thread_locks_hpp Header `<boost/synchro/thread/locks.hpp>`]
+[/==========================================================================================]
+
+    namespace boost { namespace synchro {
+        class thread_recursive_mutex;
+       
+        class thread_timed_mutex;
+    }}
+    
+[section Template Class `unique_locker<>`]
+
+    template <typename T>
+    struct lockable_type<boost::unique_lock<T> > {
+        typedef T type;
+    };
+    template <typename T>
+    struct lockable_type<boost::shared_lock<T> > {
+        typedef T type;
+    };
+    template <typename T>
+    struct lockable_type<boost::upgrade_lock<T> > {
+        typedef T type;
+    };
+
+    template <typename T>
+    struct lockable_type<boost::upgrade_to_unique_lock<T> > {
+        typedef T type;
+    };
+
+    template<typename Mutex>
+    class unique_locker<Mutex,multi_threaded_tag>:  public unique_lock_type<Mutex>::type {
+        //typename scope_tag<Mutex>::type == multi_threaded_tag
+    private:
+        typedef Mutex lockable_type;
+        typedef multi_threaded_tag scope_tag_type;
+        typedef typename unique_lock_type<Mutex>::type base_type;
+    
+    public:
+        BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(unique_locker) /*< disable copy construction >*/
+        BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(unique_locker) /*< disable copy asignement >*/
+        unique_locker();
+
+        explicit unique_locker(Mutex& m_);
+        unique_locker(Mutex& m_,adopt_lock_t);
+        unique_locker(Mutex& m_,defer_lock_t);
+        unique_locker(Mutex& m_,try_to_lock_t);
+        template<typename TimeDuration>
+        unique_locker(Mutex& m_,TimeDuration const& target_time);
+        unique_locker(Mutex& m_,system_time const& target_time);
+        template<typename TimeDuration>
+        unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t);
+        unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t);
+        template<typename TimeDuration>
+        unique_locker(TimeDuration const& target_time, Mutex& m_);
+        unique_locker(system_time const& target_time, Mutex& m_);
+
+    #ifdef BOOST_HAS_RVALUE_REFS
+        unique_locker(unique_locker&& other);
+        explicit unique_locker(upgrade_locker<Mutex,scope_tag_type>&& other);
+
+        unique_locker<Mutex, scope_tag_type>&& move();
+
+
+        unique_locker& operator=(unique_locker<Mutex, scope_tag_type>&& other);
+        unique_locker& operator=(upgrade_locker<Mutex, multi_threaded_tag>&& other);
+        
+        void swap(unique_locker&& other);
+    #else
+        unique_locker(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other);
+        unique_locker(detail::thread_move_t<upgrade_locker<Mutex,scope_tag_type> > other);
+
+        operator detail::thread_move_t<unique_locker<Mutex, scope_tag_type> >();
+        detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > move();
+
+        unique_locker& operator=(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other);
+        unique_locker& operator=(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other);
+        void swap(unique_locker& other);
+        void swap(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other);
+    #endif
+
+        ~unique_locker() {}
+
+        Mutex* mutex() const;
+        bool is_locking(lockable_type* l) const;
+
+        template<typename TimeDuration>
+        bool try_lock_for(TimeDuration const& relative_time);
+        bool try_lock_until(::boost::system_time const& absolute_time);
+
+        template<typename TimeDuration>
+        void lock_for(TimeDuration const& relative_time);
+        void lock_until(::boost::system_time const& absolute_time);
+    };
+    
+[endsect]
+[section Template Class `try_unique_locker<>`]
+
+    template<typename Mutex>
+    class try_unique_locker<Mutex,multi_threaded_tag>:  public unique_locker<Mutex,multi_threaded_tag> {
+        //typename scope_tag<Mutex>::type == multi_threaded_tag
+    private:
+        typedef Mutex lockable_type;
+        typedef multi_threaded_tag scope_tag_type;
+        typedef unique_locker<Mutex,multi_threaded_tag> base_type;
+    public:
+        try_unique_locker();
+
+        explicit try_unique_locker(Mutex& m_);
+        try_unique_locker(Mutex& m_,force_lock_t);
+        try_unique_locker(Mutex& m_,adopt_lock_t);
+        try_unique_locker(Mutex& m_,defer_lock_t);
+        try_unique_locker(Mutex& m_,try_to_lock_t);
+        template<typename TimeDuration>
+        try_unique_locker(Mutex& m_,TimeDuration const& target_time);
+        try_unique_locker(Mutex& m_,system_time const& target_time);
+        template<typename TimeDuration>
+        try_unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t);
+        try_unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t);
+        template<typename TimeDuration>
+        try_unique_locker(TimeDuration const& target_time, Mutex& m_);
+        try_unique_locker(system_time const& target_time, Mutex& m_);
+        
+    #ifdef BOOST_HAS_RVALUE_REFS
+        try_unique_locker(try_unique_locker&& other);
+        explicit try_unique_locker(upgrade_locker<Mutex,scope_tag_type>&& other);
+
+        try_unique_locker<Mutex, scope_tag_type>&& move();
+        try_unique_locker& operator=(try_unique_locker<Mutex, scope_tag_type>&& other);
+        try_unique_locker& operator=(upgrade_locker<Mutex, multi_threaded_tag>&& other);
+        void swap(try_unique_locker&& other);
+    #else
+        try_unique_locker(detail::thread_move_t<try_unique_locker<Mutex, scope_tag_type> > other);
+        try_unique_locker(detail::thread_move_t<upgrade_locker<Mutex,scope_tag_type> > other);
+
+        operator detail::thread_move_t<try_unique_locker<Mutex, scope_tag_type> >();
+        detail::thread_move_t<try_unique_locker<Mutex, scope_tag_type> > move();
+
+        try_unique_locker& operator=(detail::thread_move_t<try_unique_locker<Mutex, scope_tag_type> > other);
+        try_unique_locker& operator=(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other);
+        
+        void swap(try_unique_locker& other);
+        void swap(detail::thread_move_t<try_unique_locker<Mutex, scope_tag_type> > other);
+    #endif
+
+        ~try_unique_locker() {}
+    };
+
+[endsect]
+[section Template Class `shared_locker<>`]
+
+    template<typename Mutex>
+    class shared_locker<Mutex,multi_threaded_tag>:  public shared_lock_type<Mutex>::type {
+        //typename scope_tag<Mutex>::type == multi_threaded_tag
+    public:
+        typedef Mutex lockable_type;
+        typedef multi_threaded_tag scope_tag_type;
+        typedef typename shared_lock_type<Mutex>::type base_type;
+        
+        shared_locker();
+        BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(shared_locker) /*< disable copy construction >*/
+        BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(shared_locker) /*< disable copy asignement >*/
+
+        explicit shared_locker(Mutex& m_)
+        shared_locker(Mutex& m_,adopt_lock_t);
+        shared_locker(Mutex& m_,defer_lock_t);
+        shared_locker(Mutex& m_,try_to_lock_t);
+        shared_locker(Mutex& m_,system_time const& target_time);
+        template<typename TimeDuration>
+        shared_locker(Mutex& m_,TimeDuration const& target_time);
+        shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t);
+        template<typename TimeDuration>
+        shared_locker(Mutex& m_,TimeDuration const& target_time,throw_lock_t);
+        shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t);
+        template<typename TimeDuration>
+        shared_locker(TimeDuration const& target_time, Mutex& m_);
+        shared_locker(system_time const& target_time, Mutex& m_);
+
+        shared_locker(detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > other);
+        shared_locker(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other);
+        shared_locker(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other);
+
+        operator detail::thread_move_t<shared_locker<Mutex,scope_tag_type> >();
+        detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > move();
+
+        shared_locker& operator=(detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > other);
+        shared_locker& operator=(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other);
+        shared_locker& operator=(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other);
+
+    #ifdef BOOST_HAS_RVALUE_REFS
+        void swap(shared_locker&& other);
+    #else
+        void swap(shared_locker& other);
+        void swap(boost::detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > other);
+    #endif
+
+        Mutex* mutex() const;
+        bool is_locking(lockable_type* l) const;
+        
+        bool try_lock_until(boost::system_time const& absolute_time);
+        template<typename Duration>
+        bool try_lock_for(Duration const& relative_time);
+
+        template<typename TimeDuration>
+        void lock_for(TimeDuration const& relative_time);
+        void lock_until(::boost::system_time const& absolute_time);
+    };
+
+[endsect]
+[section Template Class `upgrade_locker<>`]
+
+    template<typename Mutex>
+    class upgrade_locker<Mutex,multi_threaded_tag>:  public upgrade_lock_type<Mutex>::type {
+        //typename scope_tag<Mutex>::type == multi_threaded_tag
+    public:
+        typedef Mutex lockable_type;
+        typedef multi_threaded_tag scope_tag_type;
+        typedef typename upgrade_lock_type<Mutex>::type base_type;
+
+        upgrade_locker();
+        BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(upgrade_locker) /*< disable copy construction >*/
+        BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(upgrade_locker) /*< disable copy asignement >*/
+
+        explicit upgrade_locker(Mutex& m_);
+        upgrade_locker(Mutex& m_,adopt_lock_t);
+        upgrade_locker(Mutex& m_,defer_lock_t);
+        upgrade_locker(Mutex& m_,try_to_lock_t);
+
+        upgrade_locker(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other);
+        upgrade_locker(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other);
+
+        operator detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> >();
+        detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > move();
+
+        upgrade_locker& operator=(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other);
+        upgrade_locker& operator=(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other);
+
+        void swap(upgrade_locker& other);
+
+        ~upgrade_locker();
+        Mutex* mutex() const;
+
+        bool is_locking(lockable_type* l) const;
+    };
+
+[endsect]
+[section Template Class `upgrade_to_unique_locker<>`]
+
+    template<typename Mutex>
+    class upgrade_to_unique_locker<Mutex,multi_threaded_tag>:  public upgrade_to_unique_locker_type<Mutex>::type {
+        //typename scope_tag<Mutex>::type == multi_threaded_tag
+    public:
+        typedef Mutex lockable_type;
+        typedef multi_threaded_tag scope_tag_type;
+        typedef typename upgrade_to_unique_locker_type<Mutex>::type base_type;
+    public:
+        BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(upgrade_locker) /*< disable copy construction >*/
+        BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(upgrade_locker) /*< disable copy asignement >*/
+        
+        explicit upgrade_to_unique_locker(upgrade_locker<Mutex,multi_threaded_tag>& m_);
+        ~upgrade_to_unique_locker();
+
+        upgrade_to_unique_locker(detail::thread_move_t<upgrade_to_unique_locker<Mutex, scope_tag_type> > other);
+
+        upgrade_to_unique_locker& operator=(detail::thread_move_t<upgrade_to_unique_locker<Mutex, scope_tag_type> > other);
+        void swap(upgrade_to_unique_locker& other);
+
+        Mutex* mutex() const;
+        bool is_locking(lockable_type* l) const;
+    };
+
+
+[endsect]
+[endsect]

Added: sandbox/synchro/libs/synchro/doc/reference/thread_mutex.qbk
==============================================================================
--- (empty file)
+++ sandbox/synchro/libs/synchro/doc/reference/thread_mutex.qbk	2009-02-16 19:03:00 EST (Mon, 16 Feb 2009)
@@ -0,0 +1,110 @@
+[/
+ / Copyright (c) 2008-2009 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)
+ /]
+
+
+[/==========================================================================================]
+[section:thread_mutex_hpp Header `<boost/synchro/thread/mutex.hpp>`]
+[/==========================================================================================]
+
+    namespace boost { namespace synchro {
+        class thread_mutex;
+        template <> struct unique_lock_type<thread_mutex>;
+        template <> struct shared_lock_type<thread_mutex>;
+        template <> struct upgrade_lock_type<thread_mutex>;
+        template <> struct upgrade_to_unique_locker_type<thread_mutex>;
+        template <> struct lock_error_type<boost::mutex>;
+        
+        class thread_timed_mutex;
+    }}
+    
+[section Class `thread_mutex`]
+
+[*Synopsis]
+
+    class thread_mutex : public lock_traits_base<
+            multi_threaded_tag,
+            exclusive_lock_tag,
+            non_recursive_tag,
+            hasnt_timed_interface_tag,
+            process_lifetime_tag,
+            anonymous_tag,
+            mutex
+        > {
+    public:
+        // public types
+        typedef boost::condition_variable  best_condition_type;
+        typedef boost::condition_variable_any  best_condition_any_type;
+
+        //Non-copyable
+        BOOST_COPY_CONSTRUCTOR_DELETE(thread_mutex) /*< disable copy construction >*/
+        BOOST_COPY_ASSIGNEMENT_DELETE(thread_mutex) /*< disable copy asignement >*/
+
+        thread_mutex() {}
+    };
+
+    template <>
+    struct unique_lock_type<thread_mutex> {
+        typedef boost::unique_lock<boost::mutex> type;
+    };
+
+    template <>
+    struct shared_lock_type<thread_mutex> {
+        typedef boost::shared_lock<boost::mutex> type;
+    };
+
+    template <>
+    struct upgrade_lock_type<thread_mutex> {
+        typedef boost::upgrade_lock<boost::mutex> type;
+    };
+
+    template <>
+    struct upgrade_to_unique_locker_type<thread_mutex> {
+        typedef boost::upgrade_to_unique_lock<boost::mutex> type;
+    };
+
+    template <>
+    struct lock_error_type<boost::mutex> {
+        typedef boost::lock_error type;
+    };
+
+
+
+
+[endsect]
+
+[section Class `thread_timed_mutex`]
+
+    class thread_timed_mutex : public lock_traits_base<
+            multi_threaded_tag,
+            exclusive_lock_tag,
+            non_recursive_tag,
+            has_timed_interface_tag,
+            process_lifetime_tag,
+            anonymous_tag,
+            timed_mutex
+        > {
+    public:
+        typedef boost::condition_variable_any  best_condition_type;
+        typedef boost::condition_variable_any  best_condition_any_type;
+
+        //Non-copyable
+        BOOST_COPY_CONSTRUCTOR_DELETE(thread_timed_mutex) /*< disable copy construction >*/
+        BOOST_COPY_ASSIGNEMENT_DELETE(thread_timed_mutex) /*< disable copy asignement >*/
+        thread_timed_mutex ();
+            
+        bool try_lock_until(system_time const & abs_time);
+        template<typename TimeDuration>
+        bool try_lock_for(TimeDuration const & relative_time);
+
+        void lock_until(system_time const & abs_time);
+        template<typename TimeDuration>
+        void lock_for(TimeDuration const & relative_time);
+    };    
+
+[endsect]
+[endsect]

Added: sandbox/synchro/libs/synchro/doc/reference/thread_recursive_mutex.qbk
==============================================================================
--- (empty file)
+++ sandbox/synchro/libs/synchro/doc/reference/thread_recursive_mutex.qbk	2009-02-16 19:03:00 EST (Mon, 16 Feb 2009)
@@ -0,0 +1,73 @@
+[/
+ / Copyright (c) 2008-2009 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)
+ /]
+
+
+[/==========================================================================================]
+[section:thread_recursive_mutex_hpp Header `<boost/synchro/thread_recursive_mutex.hpp>`]
+[/==========================================================================================]
+
+    namespace boost { namespace synchro {
+        class thread_recursive_mutex;
+       
+        class thread_timed_mutex;
+    }}
+    
+[section Class `thread_recursive_mutex`]
+
+    class thread_recursive_mutex : public lock_traits_base<
+            multi_threaded_tag,
+            exclusive_lock_tag,
+            recursive_tag,
+            hasnt_timed_interface_tag,
+            process_lifetime_tag,
+            anonymous_tag,
+            recursive_mutex
+        > {
+    public:
+        typedef boost::condition_variable_any  best_condition_type;
+        typedef boost::condition_variable_any  best_condition_any_type;
+
+        //Non-copyable
+        BOOST_COPY_CONSTRUCTOR_DELETE(thread_recursive_mutex) /*< disable copy construction >*/
+        BOOST_COPY_ASSIGNEMENT_DELETE(thread_recursive_mutex) /*< disable copy asignement >*/
+        thread_recursive_mutex() {}
+    };    
+
+[endsect]
+[section Class `thread_recursive_timed_mutex`]
+
+    class thread_recursive_timed_mutex : public lock_traits_base<
+            multi_threaded_tag,
+            exclusive_lock_tag,
+            recursive_tag,
+            has_timed_interface_tag,
+            process_lifetime_tag,
+            anonymous_tag,
+            recursive_timed_mutex
+        > {
+    public:
+        typedef boost::condition_variable_any  best_condition_type;
+        typedef boost::condition_variable_any  best_condition_any_type;
+
+        //Non-copyable
+        BOOST_COPY_CONSTRUCTOR_DELETE(thread_recursive_timed_mutex) /*< disable copy construction >*/
+        BOOST_COPY_ASSIGNEMENT_DELETE(thread_recursive_timed_mutex) /*< disable copy asignement >*/
+        thread_recursive_timed_mutex();
+
+        bool try_lock_until(system_time const & abs_time);
+        template<typename TimeDuration>
+        bool try_lock_for(TimeDuration const & relative_time);
+
+        void lock_until(system_time const & abs_time);
+        template<typename TimeDuration>
+        void lock_for(TimeDuration const & relative_time);
+        
+    };    
+
+[endsect]
+[endsect]

Added: sandbox/synchro/libs/synchro/doc/reference/thread_shared_mutex.qbk
==============================================================================
--- (empty file)
+++ sandbox/synchro/libs/synchro/doc/reference/thread_shared_mutex.qbk	2009-02-16 19:03:00 EST (Mon, 16 Feb 2009)
@@ -0,0 +1,65 @@
+[/
+ / Copyright (c) 2008-2009 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)
+ /]
+
+
+[/==========================================================================================]
+[section:thread_shared_mutex_hpp Header `<boost/synchro/thread/shared_mutex.hpp>`]
+[/==========================================================================================]
+
+    namespace boost { namespace synchro {
+        class thread_recursive_mutex;
+       
+        class thread_timed_mutex;
+    }}
+    
+[section Class `thread_shared_mutex`]
+
+[*Synopsis]
+
+    class thread_shared_mutex : public lock_traits_base<
+            multi_threaded_tag,
+            upgradable_lock_tag,
+            non_recursive_tag,
+            has_timed_interface_tag,
+            process_lifetime_tag,
+            anonymous_tag,
+            shared_mutex
+        > {
+    public:
+        typedef boost::condition_variable_any  best_condition_type;
+        typedef boost::condition_variable_any  best_condition_any_type;
+
+        //Non-copyable
+        BOOST_COPY_CONSTRUCTOR_DELETE(thread_shared_mutex) /*< disable copy construction >*/
+        BOOST_COPY_ASSIGNEMENT_DELETE(thread_shared_mutex) /*< disable copy asignement >*/
+        thread_shared_mutex();
+
+        bool try_lock_until(system_time const & abs_time);
+        template<typename TimeDuration>
+        bool try_lock_for(TimeDuration const & relative_time);
+
+        void lock_until(system_time const & abs_time);
+        template<typename TimeDuration>
+        void lock_for(TimeDuration const & relative_time);
+        
+        bool try_lock_shared_until(system_time const& abs_time);
+        template<typename TimeDuration>
+        bool try_lock_shared_for(TimeDuration const& rel_time);
+
+        void lock_shared_until(system_time const& abs_time);
+        template<typename TimeDuration>
+        void lock_shared_for(TimeDuration const& abs_time);
+        
+    };    
+
+
+
+
+[endsect]
+
+[endsect]