Subject: [Boost-commit] svn:boost r51255 - in sandbox/synchro/boost/synchro: . lockers process queues thread
From: vicente.botet_at_[hidden]
Date: 2009-02-14 14:58:27
Author: viboes
Date: 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
New Revision: 51255
URL: http://svn.boost.org/trac/boost/changeset/51255
Log:
Boost.Synchro V0.0.0
Adding unique_locker family
Added:
sandbox/synchro/boost/synchro/lockers.hpp (contents, props changed)
Text files modified:
sandbox/synchro/boost/synchro/lockable_traits.hpp | 7
sandbox/synchro/boost/synchro/lockers/condition_locker.hpp | 33 +
sandbox/synchro/boost/synchro/monitor.hpp | 36 +-
sandbox/synchro/boost/synchro/process/locks.hpp | 490 +++++++++++++++++++++++++++++++++++++++
sandbox/synchro/boost/synchro/process/mutex.hpp | 22 +
sandbox/synchro/boost/synchro/process_synchronization_family.hpp | 1
sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp | 4
sandbox/synchro/boost/synchro/thread/locks.hpp | 464 ++++++++++++++++++++++++++++++++++++
sandbox/synchro/boost/synchro/thread/mutex.hpp | 16 +
sandbox/synchro/boost/synchro/thread_synchronization_family.hpp | 1
10 files changed, 1022 insertions(+), 52 deletions(-)
Modified: sandbox/synchro/boost/synchro/lockable_traits.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockable_traits.hpp (original)
+++ sandbox/synchro/boost/synchro/lockable_traits.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -305,6 +305,13 @@
typedef typename lockable_scope_traits<
typename scope_tag<Lockable>::type, Lockable>::upgrade_lock type;
};
+
+template <typename Lockable>
+struct upgrade_to_unique_locker_type {
+ typedef typename lockable_scope_traits<
+ typename scope_tag<Lockable>::type, Lockable>::upgrade_to_unique_locker type;
+};
+
//]
//[lock_exception_traits
Added: sandbox/synchro/boost/synchro/lockers.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/lockers.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009. 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)
+//
+// See http://www.boost.org/libs/synchro for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHRO_LOCKERS__HPP
+#define BOOST_SYNCHRO_LOCKERS__HPP
+
+
+#include <boost/thread/locks.hpp>
+#include <boost/synchro/lockable_traits.hpp>
+
+namespace boost { namespace synchro {
+
+ struct defer_lock_t
+ {};
+ struct try_to_lock_t
+ {};
+ struct adopt_lock_t
+ {};
+ struct throw_lock_t
+ {};
+
+
+ const defer_lock_t defer_lock={};
+ const try_to_lock_t try_to_lock={};
+ const adopt_lock_t adopt_lock={};
+ const throw_lock_t throw_lock={};
+
+ template<typename Mutex, typename ScopeTag=typename scope_tag<Mutex>::type>
+ class unique_locker;
+
+ template<typename Mutex, typename ScopeTag=typename scope_tag<Mutex>::type>
+ class shared_locker;
+
+ template<typename Mutex, typename ScopeTag=typename scope_tag<Mutex>::type>
+ class upgrade_locker;
+
+ template<typename Mutex, typename ScopeTag=typename scope_tag<Mutex>::type>
+ class upgrade_to_unique_locker;
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ void swap(unique_locker<Mutex, ScopeTag>&& lhs, unique_locker<Mutex, ScopeTag>&& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#else
+ template<typename Mutex, typename ScopeTag>
+ void swap(unique_locker<Mutex, ScopeTag>& lhs, unique_locker<Mutex, ScopeTag>& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#endif
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ inline unique_locker<Mutex, ScopeTag>&& move(unique_locker<Mutex, ScopeTag>&& ul)
+ {
+ return ul;
+ }
+#endif
+
+ #ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ void swap(shared_locker<Mutex, ScopeTag>&& lhs,shared_locker<Mutex, ScopeTag>&& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#else
+ template<typename Mutex, typename ScopeTag>
+ void swap(shared_locker<Mutex, ScopeTag>& lhs,shared_locker<Mutex, ScopeTag>& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#endif
+
+
+}}
+
+#endif
Modified: sandbox/synchro/boost/synchro/lockers/condition_locker.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers/condition_locker.hpp (original)
+++ sandbox/synchro/boost/synchro/lockers/condition_locker.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -12,10 +12,11 @@
#define BOOST_SYNCHRO_CONDITION_LOCKER__HPP
#include <boost/synchro/lockable_concepts.hpp>
-#include <boost/thread/condition.hpp>
-#include <boost/synchro/thread/mutex.hpp>
+//#include <boost/thread/condition.hpp>
+//#include <boost/synchro/thread/mutex.hpp>
#include <boost/synchro/condition_backdoor.hpp>
#include <boost/synchro/condition_safe.hpp>
+#include <boost/synchro/lockers.hpp>
namespace boost { namespace synchro {
@@ -24,12 +25,13 @@
template <
typename Lockable,
class Condition=condition_safe<typename best_condition<Lockable>::type >
+ , typename ScopeTag=typename scope_tag<Lockable>::type
>
class condition_unique_locker
- : protected unique_lock_type<Lockable>::type
+ : protected unique_locker<Lockable,ScopeTag>
{
BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
- typedef typename unique_lock_type<Lockable>::type super_type;
+ typedef unique_locker<Lockable, ScopeTag> super_type;
public:
typedef Lockable lockable_type;
typedef Condition condition;
@@ -68,13 +70,16 @@
template <
typename Lockable,
class Condition=condition_safe<typename best_condition<Lockable>::type >
+ , typename ScopeTag=typename scope_tag<Lockable>::type
//, class ConditionBoosted=condition_safe_boosted<typename best_condition<Lockable>::type >
>
class condition_unique_locker
- : protected unique_lock_type<Lockable>::type
+ : protected unique_locker<Lockable, ScopeTag>
+// : protected unique_lock_type<Lockable>::type
{
BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
- typedef typename unique_lock_type<Lockable>::type super_type;
+ typedef unique_locker<Lockable, ScopeTag> super_type;
+ //typedef typename unique_lock_type<Lockable>::type super_type;
public:
typedef Lockable lockable_type;
typedef Condition condition;
@@ -85,7 +90,8 @@
condition_unique_locker(lockable_type& obj, condition &cond)
: super_type(obj) {
- typename condition::backdoor(cond).wait(*static_cast<typename unique_lock_type<Lockable>::type*>(this)); /*< relock on condition >*/
+ typename condition::backdoor(cond).wait(*static_cast<super_type*>(this)); /*< relock on condition >*/
+ //typename condition::backdoor(cond).wait(*this); /*< relock on condition >*/
}
//condition_unique_locker(lockable_type& obj, condition_boosted &cond)
// : super_type(obj) {
@@ -95,7 +101,8 @@
template <typename Predicate>
condition_unique_locker(lockable_type& obj, condition &cond, Predicate pred)
: super_type(obj) {
- typename condition::backdoor(cond).wait_when(*static_cast<typename unique_lock_type<Lockable>::type*>(this), pred); /*< relock condition when predicate satisfaied>*/
+ typename condition::backdoor(cond).wait_when(*static_cast<super_type*>(this), pred); /*< relock condition when predicate satisfaied>*/
+ //typename condition::backdoor(cond).wait_when(*this, pred); /*< relock condition when predicate satisfaied>*/
}
//template <typename Predicate>
//condition_unique_locker(lockable_type& obj, condition_boosted &cond, Predicate pred)
@@ -188,12 +195,14 @@
template <
typename Lockable,
class Condition=condition_safe<typename best_condition_any<Lockable>::type >
+ , typename ScopeTag=typename scope_tag<Lockable>::type
//, class ConditionBoosted=condition_safe_boosted<typename best_condition_any<Lockable>::type >
>
class condition_shared_locker
- : protected shared_lock<Lockable> {
+ : protected shared_locker<Lockable, ScopeTag> {
+// : protected shared_lock<Lockable> {
BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
- typedef shared_lock<Lockable> super_type;
+ typedef shared_locker<Lockable,ScopeTag> super_type;
public:
typedef Lockable lockable_type;
typedef Condition condition;
@@ -294,7 +303,7 @@
//]
-
+#if 0
//[condition_lockable
template <
typename Lockable,
@@ -359,7 +368,7 @@
friend class boost::condition_variable_any;
};
//]
-
+#endif
}
}
#endif
Modified: sandbox/synchro/boost/synchro/monitor.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/monitor.hpp (original)
+++ sandbox/synchro/boost/synchro/monitor.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -16,6 +16,7 @@
#include <boost/synchro/lockable_adapter.hpp>
#include <boost/synchro/thread/mutex.hpp>
#include <boost/synchro/thread/shared_mutex.hpp>
+#include <boost/synchro/thread/locks.hpp>
namespace boost { namespace synchro {
@@ -38,12 +39,13 @@
template <
typename Lockable=thread_mutex,
class Condition=typename best_condition<Lockable>::type
+ , typename ScopeTag=typename scope_tag<Lockable>::type
>
class exclusive_monitor : protected lockable_adapter<Lockable> {
BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
protected:
typedef Condition condition;
- typedef condition_unique_locker<Lockable, Condition> synchronizer;
+ typedef condition_unique_locker<Lockable, Condition, ScopeTag> synchronizer;
};
//]
@@ -51,13 +53,14 @@
template <
typename Lockable=thread_shared_mutex,
class Condition=condition_safe<typename best_condition_any<Lockable>::type >,
+ , typename ScopeTag=typename scope_tag<Lockable>::type
>
class shared_monitor : protected lockable_adapter<Lockable> {
BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
protected:
typedef Condition condition;
- typedef condition_unique_locker<Lockable, Condition> synchronizer;
- typedef condition_shared_locker<Lockable, Condition> shared_synchronizer;
+ typedef condition_unique_locker<Lockable, Condition, ScopeTag> synchronizer;
+ typedef condition_shared_locker<Lockable, Condition, ScopeTag> shared_synchronizer;
};
//]
@@ -66,6 +69,7 @@
template <
typename Lockable=thread_mutex,
class Condition=condition_safe<typename best_condition<Lockable>::type >
+ , typename ScopeTag=typename scope_tag<Lockable>::type
//, class ConditionBoosted=condition_safe_boosted<typename best_condition<Lockable>::type >
>
class exclusive_monitor : protected lockable_adapter<Lockable> {
@@ -73,7 +77,7 @@
protected:
typedef Condition condition;
//typedef ConditionBoosted condition_boosted;
- typedef condition_unique_locker<Lockable, Condition
+ typedef condition_unique_locker<Lockable, Condition, ScopeTag
// , ConditionBoosted
> synchronizer;
};
@@ -81,6 +85,7 @@
template <
typename Lockable=thread_shared_mutex,
class Condition=condition_safe<typename best_condition_any<Lockable>::type >
+ , typename ScopeTag=typename scope_tag<Lockable>::type
//, class ConditionBoosted=condition_safe_boosted<typename best_condition_any<Lockable>::type >
>
class shared_monitor : protected lockable_adapter<Lockable> {
@@ -88,10 +93,10 @@
protected:
typedef Condition condition;
//typedef ConditionBoosted condition_boosted;
- typedef condition_unique_locker<Lockable, Condition
+ typedef condition_unique_locker<Lockable, Condition, ScopeTag
//, ConditionBoosted
> synchronizer;
- typedef condition_shared_locker<Lockable, Condition
+ typedef condition_shared_locker<Lockable, Condition, ScopeTag
//, ConditionBoosted
> shared_synchronizer;
};
@@ -115,21 +120,22 @@
template <
typename Lockable=thread_mutex
, typename lock_tag=typename category_tag<Lockable>::type
+ , typename ScopeTag=typename scope_tag<Lockable>::type
> struct monitor;
-template <typename Lockable>
-struct monitor<Lockable, exclusive_lock_tag>
- : protected exclusive_monitor<Lockable>
+template <typename Lockable, typename ScopeTag>
+struct monitor<Lockable, exclusive_lock_tag, ScopeTag>
+ : protected exclusive_monitor<Lockable, ScopeTag>
{};
-template <typename Lockable>
-struct monitor<Lockable, sharable_lock_tag>
- : protected shared_monitor<Lockable>
+template <typename Lockable, typename ScopeTag>
+struct monitor<Lockable, sharable_lock_tag, ScopeTag>
+ : protected shared_monitor<Lockable, ScopeTag>
{};
-template <typename Lockable>
-struct monitor<Lockable, upgradable_lock_tag>
- : protected shared_monitor<Lockable>
+template <typename Lockable, typename ScopeTag>
+struct monitor<Lockable, upgradable_lock_tag, ScopeTag>
+ : protected shared_monitor<Lockable, ScopeTag>
{};
//]
}
Modified: sandbox/synchro/boost/synchro/process/locks.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/locks.hpp (original)
+++ sandbox/synchro/boost/synchro/process/locks.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -19,18 +19,484 @@
namespace boost { namespace synchro {
-template <typename T>
-struct lockable_type<boost::interprocess::scoped_lock<T> > {
- typedef T type;
-};
-template <typename T>
-struct lockable_type<boost::interprocess::sharable_lock<T> > {
- typedef T type;
-};
-template <typename T>
-struct lockable_type<boost::interprocess::upgradable_lock<T> > {
- typedef T type;
-};
+ template <typename T>
+ struct lockable_type<boost::interprocess::scoped_lock<T> > {
+ typedef T type;
+ };
+ template <typename T>
+ struct lockable_type<boost::interprocess::sharable_lock<T> > {
+ typedef T type;
+ };
+ template <typename T>
+ struct lockable_type<boost::interprocess::upgradable_lock<T> > {
+ typedef T type;
+ };
+
+ template<typename Mutex>
+ class unique_locker<Mutex,multi_process_tag>: public unique_lock_type<Mutex>::type {
+ //typename scope_tag<Mutex>::type == multi_process_tag
+ private:
+ typedef Mutex lockable_type;
+ typedef multi_process_tag scope_tag_type;
+ typedef typename unique_lock_type<Mutex>::type base_type;
+ unique_locker(unique_locker&);
+ explicit unique_locker(unique_locker<Mutex, scope_tag_type>&);
+ unique_locker& operator=(unique_locker&);
+ unique_locker& operator=(unique_locker<Mutex, scope_tag_type>& other);
+ public:
+ unique_locker(): base_type()
+ {}
+
+ explicit unique_locker(Mutex& m_): base_type(m_)
+ {}
+ unique_locker(Mutex& m_,adopt_lock_t): base_type(m_, boost::interprocess::accept_ownership)
+ {}
+ unique_locker(Mutex& m_,defer_lock_t): base_type(m_, boost::interprocess::defer_lock)
+ {}
+ unique_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::interprocess::try_to_lock)
+ {}
+ template<typename TimeDuration>
+ unique_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, target_time)
+ {}
+ unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+ {}
+ template<typename TimeDuration>
+ unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t)
+ : base_type(m_, defer_lock)
+ {
+ lock_for(target_time);
+ }
+ unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t)
+ : base_type(m_, defer_lock)
+ {
+ lock_until(target_time);
+ }
+#ifdef BOOST_HAS_RVALUE_REFS
+ unique_locker(unique_locker&& other): base_type(other)
+ {}
+ explicit unique_locker(upgrade_locker<Mutex,scope_tag_type>&& other) : base_type(other)
+ {}
+
+ unique_locker<Mutex, scope_tag_type>&& move()
+ {
+ return static_cast<unique_locker<Mutex, scope_tag_type>&&>(*this);
+ }
+
+
+ unique_locker& operator=(unique_locker<Mutex, scope_tag_type>&& other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ unique_locker& operator=(upgrade_locker<Mutex>&& other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+ void swap(unique_locker&& other)
+ {
+ this->base_type.swap(other);
+ }
+#else
+ unique_locker(interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<base_type>(other.get()))
+ {}
+ unique_locker(interprocess::detail::moved_object<upgrade_locker<Mutex,scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<upgrade_locker<Mutex,scope_tag_type> >(other.get()))
+ {}
+ // interprocess specific
+ unique_locker(interprocess::detail::moved_object<upgrade_locker<Mutex,scope_tag_type> > other
+ , try_to_lock_t)
+ : base_type(interprocess::detail::moved_object<upgrade_locker<Mutex,scope_tag_type> >(other.get())
+ , boost::interprocess::try_to_lock)
+ {}
+
+ // interprocess specific
+ unique_locker(interprocess::detail::moved_object<upgrade_locker<Mutex,scope_tag_type> > other
+ , system_time const& target_time)
+ : base_type(interprocess::detail::moved_object<upgrade_locker<Mutex,scope_tag_type> >(other.get())
+ , target_time)
+ {}
+
+ operator interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> >()
+ {
+ return move();
+ }
+
+ interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > move()
+ {
+ return interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> >(*this);
+ }
+
+ unique_locker& operator=(interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ unique_locker& operator=(interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> > other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+ void swap(unique_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+ void swap(interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ this->base_type.swap(interprocess::detail::moved_object<base_type>(other.get()));
+ }
+#endif
+
+ ~unique_locker() {}
+
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+
+ bool owns_lock() const {
+ return this->owns();
+ }
+
+ template<typename TimeDuration>
+ bool try_lock_for(TimeDuration const& relative_time)
+ {
+ return this->timed_lock(relative_time);
+ }
+
+ bool try_lock_until(::boost::system_time const& absolute_time)
+ {
+ return this->timed_lock(absolute_time);
+ }
+
+ template<typename TimeDuration>
+ void lock_for(TimeDuration const& relative_time)
+ {
+ if(!try_lock_for(relative_time)) throw timeout_exception();
+ }
+
+ void lock_until(::boost::system_time const& absolute_time)
+ {
+ if(!try_lock_until(absolute_time)) throw timeout_exception();
+ }
+
+ friend class shared_locker<Mutex,scope_tag_type>;
+ friend class upgrade_locker<Mutex,scope_tag_type>;
+ };
+#if 0
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ void swap(unique_locker<Mutex, ScopeTag>&& lhs, unique_locker<Mutex, ScopeTag>&& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#else
+ template<typename Mutex, typename ScopeTag>
+ void swap(unique_locker<Mutex, ScopeTag>& lhs, unique_locker<Mutex, ScopeTag>& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#endif
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ inline unique_locker<Mutex, ScopeTag>&& move(unique_locker<Mutex, ScopeTag>&& ul)
+ {
+ return ul;
+ }
+#endif
+#endif
+ template<typename Mutex>
+ class shared_locker<Mutex,multi_process_tag>: public shared_lock_type<Mutex>::type {
+ //typename scope_tag<Mutex>::type == multi_process_tag
+ public:
+ typedef Mutex lockable_type;
+ typedef multi_process_tag scope_tag_type;
+ typedef typename shared_lock_type<Mutex>::type base_type;
+
+ private:
+ explicit shared_locker(shared_locker&);
+ shared_locker& operator=(shared_locker&);
+ public:
+ shared_locker(): base_type()
+ {}
+
+ explicit shared_locker(Mutex& m_): base_type(m_)
+ {}
+ shared_locker(Mutex& m_,adopt_lock_t): base_type(m_, boost::interprocess::accept_ownership)
+ {}
+ shared_locker(Mutex& m_,defer_lock_t): base_type(m_, boost::interprocess::defer_lock)
+ {}
+ shared_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::interprocess::try_to_lock)
+ {}
+ shared_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+ {}
+ template<typename TimeDuration>
+ shared_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, boost::get_system_time()+target_time)
+ {}
+ shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
+ : base_type(m_, boost::interprocess::defer_lock)
+ {
+ lock_until(target_time);
+ }
+ template<typename TimeDuration>
+ shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
+ : base_type(m_, boost::interprocess::defer_lock)
+ {
+ lock_for(target_time);
+ }
+
+
+ shared_locker(interprocess::detail::moved_object<shared_locker<Mutex, scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<base_type>(other.get()))
+ {}
+
+ shared_locker(interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<typename unique_lock_type<Mutex>::type>(other.get()))
+ {}
+
+ shared_locker(interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<typename upgrade_lock_type<Mutex>::type>(other.get()))
+ {}
+
+ operator interprocess::detail::moved_object<shared_locker<Mutex,scope_tag_type> >()
+ {
+ return move();
+ }
+
+ interprocess::detail::moved_object<shared_locker<Mutex, scope_tag_type> > move()
+ {
+ return interprocess::detail::moved_object<shared_locker<Mutex, scope_tag_type> >(*this);
+ }
+
+
+ shared_locker& operator=(interprocess::detail::moved_object<shared_locker<Mutex, scope_tag_type> > other)
+ {
+ shared_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ shared_locker& operator=(interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ shared_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ shared_locker& operator=(interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> > other)
+ {
+ shared_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ void swap(shared_locker&& other)
+ {
+ this->base_type.swap(other);
+ }
+#else
+ void swap(shared_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+ void swap(boost::interprocess::detail::moved_object<shared_locker<Mutex, scope_tag_type> > other)
+ {
+ this->base_type.swap(interprocess::detail::moved_object<base_type>(other.get()));
+ }
+#endif
+
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+
+ bool owns_lock() const {
+ return this->owns();
+ }
+
+ bool try_lock_until(boost::system_time const& absolute_time)
+ {
+ return this->timed_lock(absolute_time);
+ }
+ template<typename Duration>
+ bool try_lock_for(Duration const& relative_time)
+ {
+ return this->timed_lock(relative_time);
+ }
+
+ template<typename TimeDuration>
+ void lock_for(TimeDuration const& relative_time)
+ {
+ if(!try_lock_for(relative_time)) throw timeout_exception();
+ }
+
+ void lock_until(::boost::system_time const& absolute_time)
+ {
+ if(!try_lock_until(absolute_time)) throw timeout_exception();
+ }
+
+ };
+
+#if 0
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ void swap(shared_locker<Mutex, ScopeTag>&& lhs,shared_locker<Mutex, ScopeTag>&& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#else
+ template<typename Mutex, typename ScopeTag>
+ void swap(shared_locker<Mutex, ScopeTag>& lhs,shared_locker<Mutex, ScopeTag>& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#endif
+#endif
+
+ template<typename Mutex>
+ class upgrade_locker<Mutex,multi_process_tag>: public upgrade_lock_type<Mutex>::type {
+ //typename scope_tag<Mutex>::type == multi_process_tag
+ public:
+ typedef Mutex lockable_type;
+ typedef multi_process_tag scope_tag_type;
+ typedef typename upgrade_lock_type<Mutex>::type base_type;
+ private:
+ explicit upgrade_locker(upgrade_locker&);
+ upgrade_locker& operator=(upgrade_locker&);
+ public:
+ upgrade_locker(): base_type()
+ {}
+
+ explicit upgrade_locker(Mutex& m_): base_type(m_)
+ {
+ }
+ upgrade_locker(Mutex& m_,adopt_lock_t): base_type(m_, boost::interprocess::accept_ownership)
+ {}
+ upgrade_locker(Mutex& m_,defer_lock_t): base_type(m_, boost::interprocess::defer_lock)
+ {}
+ upgrade_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::interprocess::try_to_lock)
+ {}
+
+ upgrade_locker(interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<base_type>(other.get()))
+ {}
+
+ upgrade_locker(interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<typename unique_lock_type<Mutex>::type>(other.get()))
+ {}
+
+ operator interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> >()
+ {
+ return move();
+ }
+
+ interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> > move()
+ {
+ return interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> >(*this);
+ }
+
+ upgrade_locker& operator=(interprocess::detail::moved_object<upgrade_locker<Mutex, scope_tag_type> > other)
+ {
+ upgrade_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ upgrade_locker& operator=(interprocess::detail::moved_object<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ upgrade_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ void swap(upgrade_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+
+ ~upgrade_locker()
+ {}
+
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+
+ bool owns_lock() const {
+ return this->owns();
+ }
+
+ friend class shared_locker<Mutex, scope_tag_type>;
+ friend class unique_locker<Mutex, scope_tag_type>;
+ };
+
+
+ template<typename Mutex>
+ class upgrade_to_unique_locker<Mutex,multi_process_tag>: public upgrade_to_unique_locker_type<Mutex>::type {
+ //typename scope_tag<Mutex>::type == multi_process_tag
+ public:
+ typedef Mutex lockable_type;
+ typedef multi_process_tag scope_tag_type;
+ typedef typename upgrade_to_unique_locker_type<Mutex>::type base_type;
+ private:
+ explicit upgrade_to_unique_locker(upgrade_to_unique_locker&);
+ upgrade_to_unique_locker& operator=(upgrade_to_unique_locker&);
+ public:
+ explicit upgrade_to_unique_locker(upgrade_locker<Mutex>& m_): base_type(m_)
+ {}
+ ~upgrade_to_unique_locker()
+ {}
+
+ upgrade_to_unique_locker(interprocess::detail::moved_object<upgrade_to_unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(interprocess::detail::moved_object<base_type>(other.get()))
+ {}
+
+ upgrade_to_unique_locker& operator=(interprocess::detail::moved_object<upgrade_to_unique_locker<Mutex, scope_tag_type> > other)
+ {
+ upgrade_to_unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+ void swap(upgrade_to_unique_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+
+ bool owns_lock() const {
+ return this->owns();
+ }
+
+ };
}
}
Modified: sandbox/synchro/boost/synchro/process/mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/mutex.hpp (original)
+++ sandbox/synchro/boost/synchro/process/mutex.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -56,6 +56,28 @@
//{return timed_lock_shared(abs_time);}
};
+
+
+template <>
+struct unique_lock_type<interprocess_mutex> {
+ typedef boost::interprocess::scoped_lock<boost::interprocess::interprocess_mutex> type;
+};
+
+template <>
+struct shared_lock_type<interprocess_mutex> {
+ typedef boost::interprocess::sharable_lock<boost::interprocess::interprocess_mutex> type;
+};
+
+template <>
+struct upgrade_lock_type<interprocess_mutex> {
+ typedef boost::interprocess::upgradable_lock<boost::interprocess::interprocess_mutex> type;
+};
+#if 0
+template <>
+struct upgrade_to_unique_locker_type<interprocess_mutex> {
+ typedef boost::interprocess::upgrade_to_unique_lock<boost::interprocess::interprocess_mutex> type;
+};
+#endif
#if 0
typedef boost::interprocess::interprocess_mutex interprocess_mutex;
Modified: sandbox/synchro/boost/synchro/process_synchronization_family.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process_synchronization_family.hpp (original)
+++ sandbox/synchro/boost/synchro/process_synchronization_family.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -14,6 +14,7 @@
#include <boost/synchro/process/mutex.hpp>
#include <boost/synchro/process/recursive_mutex.hpp>
#include <boost/synchro/process/upgradable_mutex.hpp>
+#include <boost/synchro/process/locks.hpp>
#include <boost/interprocess/sync/interprocess_condition.hpp>
namespace boost {
Modified: sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp (original)
+++ sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -15,6 +15,7 @@
//#include <boost/thread/mutex.hpp>
//#include <boost/thread/condition_variable.hpp>
#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/lockers.hpp>
namespace boost { namespace synchro {
#if 0
@@ -70,7 +71,8 @@
{
typedef typename Sync::mutex_type mutex_type;
typedef typename Sync::condition_type condition_type;
- typedef typename unique_lock_type<mutex_type>::type unique_lock_type;
+ //typedef typename unique_lock_type<mutex_type>::type unique_lock_type;
+ typedef unique_locker<mutex_type> unique_lock_type;
mutex_type mtx_;
condition_type not_full_;
condition_type not_empty_;
Modified: sandbox/synchro/boost/synchro/thread/locks.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/locks.hpp (original)
+++ sandbox/synchro/boost/synchro/thread/locks.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -14,22 +14,462 @@
#include <boost/thread/locks.hpp>
#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/lockers.hpp>
+
namespace boost { namespace synchro {
-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::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;
+ //unique_locker(unique_locker&);
+ explicit unique_locker(unique_locker<Mutex, scope_tag_type>&);
+ //unique_locker& operator=(unique_locker&);
+ unique_locker& operator=(unique_locker<Mutex, scope_tag_type>& other);
+ public:
+ unique_locker(): base_type()
+ {}
+
+ explicit unique_locker(Mutex& m_): base_type(m_)
+ {}
+ unique_locker(Mutex& m_,adopt_lock_t): base_type(m_, boost::adopt_lock)
+ {}
+ unique_locker(Mutex& m_,defer_lock_t): base_type(m_, boost::defer_lock)
+ {}
+ unique_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::try_to_lock)
+ {}
+ template<typename TimeDuration>
+ unique_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, target_time)
+ {}
+ unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+ {}
+ template<typename TimeDuration>
+ unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t)
+ : base_type(m_, defer_lock)
+ {
+ lock_for(target_time);
+ }
+ unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t)
+ : base_type(m_, defer_lock)
+ {
+ lock_until(target_time);
+ }
+#ifdef BOOST_HAS_RVALUE_REFS
+ unique_locker(unique_locker&& other): base_type(other)
+ {}
+ explicit unique_locker(upgrade_locker<Mutex,scope_tag_type>&& other) : base_type(other)
+ {}
+
+ unique_locker<Mutex, scope_tag_type>&& move()
+ {
+ return static_cast<unique_locker<Mutex, scope_tag_type>&&>(*this);
+ }
+
+
+ unique_locker& operator=(unique_locker<Mutex, scope_tag_type>&& other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ unique_locker& operator=(upgrade_locker<Mutex>&& other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+ void swap(unique_locker&& other)
+ {
+ this->base_type.swap(other);
+ }
+#else
+ unique_locker(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(detail::thread_move_t<base_type>(other.t))
+ {}
+ unique_locker(detail::thread_move_t<upgrade_locker<Mutex,scope_tag_type> > other)
+ : base_type(detail::thread_move_t<upgrade_locker<Mutex,scope_tag_type> >(other.t))
+ {}
+
+ operator detail::thread_move_t<unique_locker<Mutex, scope_tag_type> >()
+ {
+ return move();
+ }
+
+ detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > move()
+ {
+ return detail::thread_move_t<unique_locker<Mutex, scope_tag_type> >(*this);
+ }
+
+ unique_locker& operator=(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ unique_locker& operator=(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other)
+ {
+ unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+ void swap(unique_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+ void swap(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ this->base_type.swap(detail::thread_move_t<base_type>(other.t));
+ }
+#endif
+
+ ~unique_locker() {}
+
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+
+ template<typename TimeDuration>
+ bool try_lock_for(TimeDuration const& relative_time)
+ {
+ return this->timed_lock(relative_time);
+ }
+
+ bool try_lock_until(::boost::system_time const& absolute_time)
+ {
+ return this->timed_lock(absolute_time);
+ }
+
+ template<typename TimeDuration>
+ void lock_for(TimeDuration const& relative_time)
+ {
+ if(!try_lock_for(relative_time)) throw timeout_exception();
+ }
+
+ void lock_until(::boost::system_time const& absolute_time)
+ {
+ if(!try_lock_until(absolute_time)) throw timeout_exception();
+ }
+
+ friend class shared_locker<Mutex,scope_tag_type>;
+ friend class upgrade_locker<Mutex,scope_tag_type>;
+ };
+#if 0
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ void swap(unique_locker<Mutex, ScopeTag>&& lhs, unique_locker<Mutex, ScopeTag>&& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#else
+ template<typename Mutex, typename ScopeTag>
+ void swap(unique_locker<Mutex, ScopeTag>& lhs, unique_locker<Mutex, ScopeTag>& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#endif
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ inline unique_locker<Mutex, ScopeTag>&& move(unique_locker<Mutex, ScopeTag>&& ul)
+ {
+ return ul;
+ }
+#endif
+#endif
+ 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;
+
+ private:
+ explicit shared_locker(shared_locker&);
+ shared_locker& operator=(shared_locker&);
+ public:
+ shared_locker(): base_type()
+ {}
+
+ explicit shared_locker(Mutex& m_): base_type(m_)
+ {}
+ shared_locker(Mutex& m_,adopt_lock_t): base_type(m_, boost::adopt_lock)
+ {}
+ shared_locker(Mutex& m_,defer_lock_t): base_type(m_, boost::defer_lock)
+ {}
+ shared_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::try_to_lock)
+ {}
+ shared_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+ {}
+ template<typename TimeDuration>
+ shared_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, boost::get_system_time()+target_time)
+ {}
+ shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
+ : base_type(m_, boost::defer_lock)
+ {
+ lock_until(target_time);
+ }
+ template<typename TimeDuration>
+ shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
+ : base_type(m_, boost::defer_lock)
+ {
+ lock_for(target_time);
+ }
+
+
+ shared_locker(detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > other)
+ : base_type(detail::thread_move_t<base_type>(other.t))
+ {}
+
+ shared_locker(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(detail::thread_move_t<typename unique_lock_type<Mutex>::type>(other.t))
+ {}
+
+ shared_locker(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other)
+ : base_type(detail::thread_move_t<typename upgrade_lock_type<Mutex>::type>(other.t))
+ {}
+
+ operator detail::thread_move_t<shared_locker<Mutex,scope_tag_type> >()
+ {
+ return move();
+ }
+
+ detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > move()
+ {
+ return detail::thread_move_t<shared_locker<Mutex, scope_tag_type> >(*this);
+ }
+
+
+ shared_locker& operator=(detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > other)
+ {
+ shared_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ shared_locker& operator=(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ shared_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ shared_locker& operator=(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other)
+ {
+ shared_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ void swap(shared_locker&& other)
+ {
+ this->base_type.swap(other);
+ }
+#else
+ void swap(shared_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+ void swap(boost::detail::thread_move_t<shared_locker<Mutex, scope_tag_type> > other)
+ {
+ this->base_type.swap(detail::thread_move_t<base_type>(other.t));
+ }
+#endif
+
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+
+ bool try_lock_until(boost::system_time const& absolute_time)
+ {
+ return this->timed_lock(absolute_time);
+ }
+ template<typename Duration>
+ bool try_lock_for(Duration const& relative_time)
+ {
+ return this->timed_lock(relative_time);
+ }
+
+ template<typename TimeDuration>
+ void lock_for(TimeDuration const& relative_time)
+ {
+ if(!try_lock_for(relative_time)) throw timeout_exception();
+ }
+
+ void lock_until(::boost::system_time const& absolute_time)
+ {
+ if(!try_lock_until(absolute_time)) throw timeout_exception();
+ }
+
+ };
+
+#if 0
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex, typename ScopeTag>
+ void swap(shared_locker<Mutex, ScopeTag>&& lhs,shared_locker<Mutex, ScopeTag>&& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#else
+ template<typename Mutex, typename ScopeTag>
+ void swap(shared_locker<Mutex, ScopeTag>& lhs,shared_locker<Mutex, ScopeTag>& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#endif
+#endif
+ 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;
+ private:
+ explicit upgrade_locker(upgrade_locker&);
+ upgrade_locker& operator=(upgrade_locker&);
+ public:
+ upgrade_locker(): base_type()
+ {}
+
+ explicit upgrade_locker(Mutex& m_): base_type(m_)
+ {
+ }
+ upgrade_locker(Mutex& m_,adopt_lock_t): base_type(m_, boost::adopt_lock)
+ {}
+ upgrade_locker(Mutex& m_,defer_lock_t): base_type(m_, boost::defer_lock)
+ {}
+ upgrade_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::try_to_lock)
+ {}
+
+ upgrade_locker(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other)
+ : base_type(detail::thread_move_t<base_type>(other.t))
+ {}
+
+ upgrade_locker(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(detail::thread_move_t<typename unique_lock_type<Mutex>::type>(other.t))
+ {}
+
+ operator detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> >()
+ {
+ return move();
+ }
+
+ detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > move()
+ {
+ return detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> >(*this);
+ }
+
+ upgrade_locker& operator=(detail::thread_move_t<upgrade_locker<Mutex, scope_tag_type> > other)
+ {
+ upgrade_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ upgrade_locker& operator=(detail::thread_move_t<unique_locker<Mutex, scope_tag_type> > other)
+ {
+ upgrade_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ void swap(upgrade_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+
+ ~upgrade_locker()
+ {}
+
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+
+ friend class shared_locker<Mutex, scope_tag_type>;
+ friend class unique_locker<Mutex, scope_tag_type>;
+ };
+
+
+ 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;
+ private:
+ explicit upgrade_to_unique_locker(upgrade_to_unique_locker&);
+ upgrade_to_unique_locker& operator=(upgrade_to_unique_locker&);
+ public:
+ explicit upgrade_to_unique_locker(upgrade_locker<Mutex>& m_): base_type(m_)
+ {}
+ ~upgrade_to_unique_locker()
+ {}
+
+ upgrade_to_unique_locker(detail::thread_move_t<upgrade_to_unique_locker<Mutex, scope_tag_type> > other)
+ : base_type(detail::thread_move_t<base_type>(other.t))
+ {}
+
+ upgrade_to_unique_locker& operator=(detail::thread_move_t<upgrade_to_unique_locker<Mutex, scope_tag_type> > other)
+ {
+ upgrade_to_unique_locker temp(other);
+ swap(temp);
+ return *this;
+ }
+ void swap(upgrade_to_unique_locker& other)
+ {
+ this->base_type.swap(other);
+ }
+ Mutex* mutex() const
+ {
+ return static_cast<Mutex*>(this->base_type.mutex());
+ }
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
+ } /*< strict lockers specific function >*/
+ };
}
}
Modified: sandbox/synchro/boost/synchro/thread/mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/mutex.hpp (original)
+++ sandbox/synchro/boost/synchro/thread/mutex.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -51,6 +51,22 @@
};
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;
};
Modified: sandbox/synchro/boost/synchro/thread_synchronization_family.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread_synchronization_family.hpp (original)
+++ sandbox/synchro/boost/synchro/thread_synchronization_family.hpp 2009-02-14 14:58:25 EST (Sat, 14 Feb 2009)
@@ -14,6 +14,7 @@
#include <boost/synchro/thread/mutex.hpp>
#include <boost/synchro/thread/recursive_mutex.hpp>
#include <boost/synchro/thread/shared_mutex.hpp>
+#include <boost/synchro/thread/locks.hpp>
#include <boost/thread/condition_variable.hpp>
namespace boost {