Swift
summaryrefslogtreecommitdiffstats
path: root/3rdParty/Boost/boost/thread/locks.hpp
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2010-02-11 12:14:00 (GMT)
committerRemko Tronçon <git@el-tramo.be>2010-02-11 12:14:00 (GMT)
commit0efa7c32aaf21a29b42b5926cc116007056843be (patch)
tree882f663a5dd0e65694bf6077b71086dd77fd7ff8 /3rdParty/Boost/boost/thread/locks.hpp
parent1d20eabbc32274b491b4c2bedf73d19933d97bfd (diff)
downloadswift-contrib-0efa7c32aaf21a29b42b5926cc116007056843be.zip
swift-contrib-0efa7c32aaf21a29b42b5926cc116007056843be.tar.bz2
Moved some modules into separate git modules.
Diffstat (limited to '3rdParty/Boost/boost/thread/locks.hpp')
m---------3rdParty/Boost0
-rw-r--r--3rdParty/Boost/boost/thread/locks.hpp1430
2 files changed, 0 insertions, 1430 deletions
diff --git a/3rdParty/Boost b/3rdParty/Boost
new file mode 160000
+Subproject 3bbdbc8cf1996f23d9a366da8bac0f97be6ad79
diff --git a/3rdParty/Boost/boost/thread/locks.hpp b/3rdParty/Boost/boost/thread/locks.hpp
deleted file mode 100644
index abbfd75..0000000
--- a/3rdParty/Boost/boost/thread/locks.hpp
+++ /dev/null
@@ -1,1430 +0,0 @@
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// (C) Copyright 2007 Anthony Williams
-#ifndef BOOST_THREAD_LOCKS_HPP
-#define BOOST_THREAD_LOCKS_HPP
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <algorithm>
-#include <iterator>
-#include <boost/thread/thread_time.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
- struct xtime;
-
-#if defined(BOOST_NO_SFINAE) || \
- BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \
- BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-#define BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
-#endif
-
-#ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
- namespace detail
- {
- template<typename T>
- struct has_member_lock
- {
- typedef char true_type;
- struct false_type
- {
- true_type dummy[2];
- };
-
- template<typename U>
- static true_type has_member(U*,void (U::*dummy)()=&U::lock);
- static false_type has_member(void*);
-
- BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_lock<T>::has_member((T*)NULL))==sizeof(true_type));
- };
-
- template<typename T>
- struct has_member_unlock
- {
- typedef char true_type;
- struct false_type
- {
- true_type dummy[2];
- };
-
- template<typename U>
- static true_type has_member(U*,void (U::*dummy)()=&U::unlock);
- static false_type has_member(void*);
-
- BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_unlock<T>::has_member((T*)NULL))==sizeof(true_type));
- };
-
- template<typename T>
- struct has_member_try_lock
- {
- typedef char true_type;
- struct false_type
- {
- true_type dummy[2];
- };
-
- template<typename U>
- static true_type has_member(U*,bool (U::*dummy)()=&U::try_lock);
- static false_type has_member(void*);
-
- BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_try_lock<T>::has_member((T*)NULL))==sizeof(true_type));
- };
-
- }
-
-
- template<typename T>
- struct is_mutex_type
- {
- BOOST_STATIC_CONSTANT(bool, value = detail::has_member_lock<T>::value &&
- detail::has_member_unlock<T>::value &&
- detail::has_member_try_lock<T>::value);
-
- };
-#else
- template<typename T>
- struct is_mutex_type
- {
- BOOST_STATIC_CONSTANT(bool, value = false);
- };
-#endif
-
- struct defer_lock_t
- {};
- struct try_to_lock_t
- {};
- struct adopt_lock_t
- {};
-
- const defer_lock_t defer_lock={};
- const try_to_lock_t try_to_lock={};
- const adopt_lock_t adopt_lock={};
-
- template<typename Mutex>
- class shared_lock;
-
- template<typename Mutex>
- class upgrade_lock;
-
- template<typename Mutex>
- class unique_lock;
-
- namespace detail
- {
- template<typename Mutex>
- class try_lock_wrapper;
- }
-
-#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
- template<typename T>
- struct is_mutex_type<unique_lock<T> >
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
-
- template<typename T>
- struct is_mutex_type<shared_lock<T> >
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
-
- template<typename T>
- struct is_mutex_type<upgrade_lock<T> >
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
-
- template<typename T>
- struct is_mutex_type<detail::try_lock_wrapper<T> >
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
-
- class mutex;
- class timed_mutex;
- class recursive_mutex;
- class recursive_timed_mutex;
- class shared_mutex;
-
- template<>
- struct is_mutex_type<mutex>
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
- template<>
- struct is_mutex_type<timed_mutex>
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
- template<>
- struct is_mutex_type<recursive_mutex>
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
- template<>
- struct is_mutex_type<recursive_timed_mutex>
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
- template<>
- struct is_mutex_type<shared_mutex>
- {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
-
-#endif
-
- template<typename Mutex>
- class lock_guard
- {
- private:
- Mutex& m;
-
- explicit lock_guard(lock_guard&);
- lock_guard& operator=(lock_guard&);
- public:
- explicit lock_guard(Mutex& m_):
- m(m_)
- {
- m.lock();
- }
- lock_guard(Mutex& m_,adopt_lock_t):
- m(m_)
- {}
- ~lock_guard()
- {
- m.unlock();
- }
- };
-
-
- template<typename Mutex>
- class unique_lock
- {
- private:
- Mutex* m;
- bool is_locked;
- unique_lock(unique_lock&);
- explicit unique_lock(upgrade_lock<Mutex>&);
- unique_lock& operator=(unique_lock&);
- unique_lock& operator=(upgrade_lock<Mutex>& other);
- public:
- unique_lock():
- m(0),is_locked(false)
- {}
-
- explicit unique_lock(Mutex& m_):
- m(&m_),is_locked(false)
- {
- lock();
- }
- unique_lock(Mutex& m_,adopt_lock_t):
- m(&m_),is_locked(true)
- {}
- unique_lock(Mutex& m_,defer_lock_t):
- m(&m_),is_locked(false)
- {}
- unique_lock(Mutex& m_,try_to_lock_t):
- m(&m_),is_locked(false)
- {
- try_lock();
- }
- template<typename TimeDuration>
- unique_lock(Mutex& m_,TimeDuration const& target_time):
- m(&m_),is_locked(false)
- {
- timed_lock(target_time);
- }
- unique_lock(Mutex& m_,system_time const& target_time):
- m(&m_),is_locked(false)
- {
- timed_lock(target_time);
- }
-#ifdef BOOST_HAS_RVALUE_REFS
- unique_lock(unique_lock&& other):
- m(other.m),is_locked(other.is_locked)
- {
- other.is_locked=false;
- other.m=0;
- }
- explicit unique_lock(upgrade_lock<Mutex>&& other);
-
- unique_lock<Mutex>&& move()
- {
- return static_cast<unique_lock<Mutex>&&>(*this);
- }
-
-
- unique_lock& operator=(unique_lock<Mutex>&& other)
- {
- unique_lock temp(other);
- swap(temp);
- return *this;
- }
-
- unique_lock& operator=(upgrade_lock<Mutex>&& other)
- {
- unique_lock temp(other);
- swap(temp);
- return *this;
- }
- void swap(unique_lock&& other)
- {
- std::swap(m,other.m);
- std::swap(is_locked,other.is_locked);
- }
-#else
- unique_lock(detail::thread_move_t<unique_lock<Mutex> > other):
- m(other->m),is_locked(other->is_locked)
- {
- other->is_locked=false;
- other->m=0;
- }
- unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other);
-
- operator detail::thread_move_t<unique_lock<Mutex> >()
- {
- return move();
- }
-
- detail::thread_move_t<unique_lock<Mutex> > move()
- {
- return detail::thread_move_t<unique_lock<Mutex> >(*this);
- }
-
- unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
- {
- unique_lock temp(other);
- swap(temp);
- return *this;
- }
-
- unique_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
- {
- unique_lock temp(other);
- swap(temp);
- return *this;
- }
- void swap(unique_lock& other)
- {
- std::swap(m,other.m);
- std::swap(is_locked,other.is_locked);
- }
- void swap(detail::thread_move_t<unique_lock<Mutex> > other)
- {
- std::swap(m,other->m);
- std::swap(is_locked,other->is_locked);
- }
-#endif
-
- ~unique_lock()
- {
- if(owns_lock())
- {
- m->unlock();
- }
- }
- void lock()
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- m->lock();
- is_locked=true;
- }
- bool try_lock()
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- is_locked=m->try_lock();
- return is_locked;
- }
- template<typename TimeDuration>
- bool timed_lock(TimeDuration const& relative_time)
- {
- is_locked=m->timed_lock(relative_time);
- return is_locked;
- }
-
- bool timed_lock(::boost::system_time const& absolute_time)
- {
- is_locked=m->timed_lock(absolute_time);
- return is_locked;
- }
- bool timed_lock(::boost::xtime const& absolute_time)
- {
- is_locked=m->timed_lock(absolute_time);
- return is_locked;
- }
- void unlock()
- {
- if(!owns_lock())
- {
- throw boost::lock_error();
- }
- m->unlock();
- is_locked=false;
- }
-
- typedef void (unique_lock::*bool_type)();
- operator bool_type() const
- {
- return is_locked?&unique_lock::lock:0;
- }
- bool operator!() const
- {
- return !owns_lock();
- }
- bool owns_lock() const
- {
- return is_locked;
- }
-
- Mutex* mutex() const
- {
- return m;
- }
-
- Mutex* release()
- {
- Mutex* const res=m;
- m=0;
- is_locked=false;
- return res;
- }
-
- friend class shared_lock<Mutex>;
- friend class upgrade_lock<Mutex>;
- };
-
-#ifdef BOOST_HAS_RVALUE_REFS
- template<typename Mutex>
- void swap(unique_lock<Mutex>&& lhs,unique_lock<Mutex>&& rhs)
- {
- lhs.swap(rhs);
- }
-#else
- template<typename Mutex>
- void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs)
- {
- lhs.swap(rhs);
- }
-#endif
-
-#ifdef BOOST_HAS_RVALUE_REFS
- template<typename Mutex>
- inline unique_lock<Mutex>&& move(unique_lock<Mutex>&& ul)
- {
- return ul;
- }
-#endif
-
- template<typename Mutex>
- class shared_lock
- {
- protected:
- Mutex* m;
- bool is_locked;
- private:
- explicit shared_lock(shared_lock&);
- shared_lock& operator=(shared_lock&);
- public:
- shared_lock():
- m(0),is_locked(false)
- {}
-
- explicit shared_lock(Mutex& m_):
- m(&m_),is_locked(false)
- {
- lock();
- }
- shared_lock(Mutex& m_,adopt_lock_t):
- m(&m_),is_locked(true)
- {}
- shared_lock(Mutex& m_,defer_lock_t):
- m(&m_),is_locked(false)
- {}
- shared_lock(Mutex& m_,try_to_lock_t):
- m(&m_),is_locked(false)
- {
- try_lock();
- }
- shared_lock(Mutex& m_,system_time const& target_time):
- m(&m_),is_locked(false)
- {
- timed_lock(target_time);
- }
-
- shared_lock(detail::thread_move_t<shared_lock<Mutex> > other):
- m(other->m),is_locked(other->is_locked)
- {
- other->is_locked=false;
- other->m=0;
- }
-
- shared_lock(detail::thread_move_t<unique_lock<Mutex> > other):
- m(other->m),is_locked(other->is_locked)
- {
- if(is_locked)
- {
- m->unlock_and_lock_shared();
- }
- other->is_locked=false;
- other->m=0;
- }
-
- shared_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
- m(other->m),is_locked(other->is_locked)
- {
- if(is_locked)
- {
- m->unlock_upgrade_and_lock_shared();
- }
- other->is_locked=false;
- other->m=0;
- }
-
- operator detail::thread_move_t<shared_lock<Mutex> >()
- {
- return move();
- }
-
- detail::thread_move_t<shared_lock<Mutex> > move()
- {
- return detail::thread_move_t<shared_lock<Mutex> >(*this);
- }
-
-
- shared_lock& operator=(detail::thread_move_t<shared_lock<Mutex> > other)
- {
- shared_lock temp(other);
- swap(temp);
- return *this;
- }
-
- shared_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
- {
- shared_lock temp(other);
- swap(temp);
- return *this;
- }
-
- shared_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
- {
- shared_lock temp(other);
- swap(temp);
- return *this;
- }
-
-#ifdef BOOST_HAS_RVALUE_REFS
- void swap(shared_lock&& other)
- {
- std::swap(m,other.m);
- std::swap(is_locked,other.is_locked);
- }
-#else
- void swap(shared_lock& other)
- {
- std::swap(m,other.m);
- std::swap(is_locked,other.is_locked);
- }
- void swap(boost::detail::thread_move_t<shared_lock<Mutex> > other)
- {
- std::swap(m,other->m);
- std::swap(is_locked,other->is_locked);
- }
-#endif
-
- Mutex* mutex() const
- {
- return m;
- }
-
- ~shared_lock()
- {
- if(owns_lock())
- {
- m->unlock_shared();
- }
- }
- void lock()
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- m->lock_shared();
- is_locked=true;
- }
- bool try_lock()
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- is_locked=m->try_lock_shared();
- return is_locked;
- }
- bool timed_lock(boost::system_time const& target_time)
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- is_locked=m->timed_lock_shared(target_time);
- return is_locked;
- }
- template<typename Duration>
- bool timed_lock(Duration const& target_time)
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- is_locked=m->timed_lock_shared(target_time);
- return is_locked;
- }
- void unlock()
- {
- if(!owns_lock())
- {
- throw boost::lock_error();
- }
- m->unlock_shared();
- is_locked=false;
- }
-
- typedef void (shared_lock<Mutex>::*bool_type)();
- operator bool_type() const
- {
- return is_locked?&shared_lock::lock:0;
- }
- bool operator!() const
- {
- return !owns_lock();
- }
- bool owns_lock() const
- {
- return is_locked;
- }
-
- };
-
-#ifdef BOOST_HAS_RVALUE_REFS
- template<typename Mutex>
- void swap(shared_lock<Mutex>&& lhs,shared_lock<Mutex>&& rhs)
- {
- lhs.swap(rhs);
- }
-#else
- template<typename Mutex>
- void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs)
- {
- lhs.swap(rhs);
- }
-#endif
-
- template<typename Mutex>
- class upgrade_lock
- {
- protected:
- Mutex* m;
- bool is_locked;
- private:
- explicit upgrade_lock(upgrade_lock&);
- upgrade_lock& operator=(upgrade_lock&);
- public:
- upgrade_lock():
- m(0),is_locked(false)
- {}
-
- explicit upgrade_lock(Mutex& m_):
- m(&m_),is_locked(false)
- {
- lock();
- }
- upgrade_lock(Mutex& m_,adopt_lock_t):
- m(&m_),is_locked(true)
- {}
- upgrade_lock(Mutex& m_,defer_lock_t):
- m(&m_),is_locked(false)
- {}
- upgrade_lock(Mutex& m_,try_to_lock_t):
- m(&m_),is_locked(false)
- {
- try_lock();
- }
- upgrade_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
- m(other->m),is_locked(other->is_locked)
- {
- other->is_locked=false;
- other->m=0;
- }
-
- upgrade_lock(detail::thread_move_t<unique_lock<Mutex> > other):
- m(other->m),is_locked(other->is_locked)
- {
- if(is_locked)
- {
- m->unlock_and_lock_upgrade();
- }
- other->is_locked=false;
- other->m=0;
- }
-
- operator detail::thread_move_t<upgrade_lock<Mutex> >()
- {
- return move();
- }
-
- detail::thread_move_t<upgrade_lock<Mutex> > move()
- {
- return detail::thread_move_t<upgrade_lock<Mutex> >(*this);
- }
-
-
- upgrade_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
- {
- upgrade_lock temp(other);
- swap(temp);
- return *this;
- }
-
- upgrade_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
- {
- upgrade_lock temp(other);
- swap(temp);
- return *this;
- }
-
- void swap(upgrade_lock& other)
- {
- std::swap(m,other.m);
- std::swap(is_locked,other.is_locked);
- }
-
- ~upgrade_lock()
- {
- if(owns_lock())
- {
- m->unlock_upgrade();
- }
- }
- void lock()
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- m->lock_upgrade();
- is_locked=true;
- }
- bool try_lock()
- {
- if(owns_lock())
- {
- throw boost::lock_error();
- }
- is_locked=m->try_lock_upgrade();
- return is_locked;
- }
- void unlock()
- {
- if(!owns_lock())
- {
- throw boost::lock_error();
- }
- m->unlock_upgrade();
- is_locked=false;
- }
-
- typedef void (upgrade_lock::*bool_type)();
- operator bool_type() const
- {
- return is_locked?&upgrade_lock::lock:0;
- }
- bool operator!() const
- {
- return !owns_lock();
- }
- bool owns_lock() const
- {
- return is_locked;
- }
- friend class shared_lock<Mutex>;
- friend class unique_lock<Mutex>;
- };
-
-
-#ifdef BOOST_HAS_RVALUE_REFS
- template<typename Mutex>
- unique_lock<Mutex>::unique_lock(upgrade_lock<Mutex>&& other):
- m(other.m),is_locked(other.is_locked)
- {
- other.is_locked=false;
- if(is_locked)
- {
- m.unlock_upgrade_and_lock();
- }
- }
-#else
- template<typename Mutex>
- unique_lock<Mutex>::unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
- m(other->m),is_locked(other->is_locked)
- {
- other->is_locked=false;
- if(is_locked)
- {
- m->unlock_upgrade_and_lock();
- }
- }
-#endif
- template <class Mutex>
- class upgrade_to_unique_lock
- {
- private:
- upgrade_lock<Mutex>* source;
- unique_lock<Mutex> exclusive;
-
- explicit upgrade_to_unique_lock(upgrade_to_unique_lock&);
- upgrade_to_unique_lock& operator=(upgrade_to_unique_lock&);
- public:
- explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_):
- source(&m_),exclusive(move(*source))
- {}
- ~upgrade_to_unique_lock()
- {
- if(source)
- {
- *source=move(exclusive);
- }
- }
-
- upgrade_to_unique_lock(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other):
- source(other->source),exclusive(move(other->exclusive))
- {
- other->source=0;
- }
-
- upgrade_to_unique_lock& operator=(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other)
- {
- upgrade_to_unique_lock temp(other);
- swap(temp);
- return *this;
- }
- void swap(upgrade_to_unique_lock& other)
- {
- std::swap(source,other.source);
- exclusive.swap(other.exclusive);
- }
- typedef void (upgrade_to_unique_lock::*bool_type)(upgrade_to_unique_lock&);
- operator bool_type() const
- {
- return exclusive.owns_lock()?&upgrade_to_unique_lock::swap:0;
- }
- bool operator!() const
- {
- return !owns_lock();
- }
- bool owns_lock() const
- {
- return exclusive.owns_lock();
- }
- };
-
- namespace detail
- {
- template<typename Mutex>
- class try_lock_wrapper:
- private unique_lock<Mutex>
- {
- typedef unique_lock<Mutex> base;
- public:
- try_lock_wrapper()
- {}
-
- explicit try_lock_wrapper(Mutex& m):
- base(m,try_to_lock)
- {}
-
- try_lock_wrapper(Mutex& m_,adopt_lock_t):
- base(m_,adopt_lock)
- {}
- try_lock_wrapper(Mutex& m_,defer_lock_t):
- base(m_,defer_lock)
- {}
- try_lock_wrapper(Mutex& m_,try_to_lock_t):
- base(m_,try_to_lock)
- {}
- try_lock_wrapper(detail::thread_move_t<try_lock_wrapper<Mutex> > other):
- base(detail::thread_move_t<base>(*other))
- {}
-
- operator detail::thread_move_t<try_lock_wrapper<Mutex> >()
- {
- return move();
- }
-
- detail::thread_move_t<try_lock_wrapper<Mutex> > move()
- {
- return detail::thread_move_t<try_lock_wrapper<Mutex> >(*this);
- }
-
- try_lock_wrapper& operator=(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
- {
- try_lock_wrapper temp(other);
- swap(temp);
- return *this;
- }
-
-#ifdef BOOST_HAS_RVALUE_REFS
- void swap(try_lock_wrapper&& other)
- {
- base::swap(other);
- }
-#else
- void swap(try_lock_wrapper& other)
- {
- base::swap(other);
- }
- void swap(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
- {
- base::swap(*other);
- }
-#endif
-
- void lock()
- {
- base::lock();
- }
- bool try_lock()
- {
- return base::try_lock();
- }
- void unlock()
- {
- base::unlock();
- }
- bool owns_lock() const
- {
- return base::owns_lock();
- }
- Mutex* mutex() const
- {
- return base::mutex();
- }
- Mutex* release()
- {
- return base::release();
- }
- bool operator!() const
- {
- return !this->owns_lock();
- }
-
- typedef typename base::bool_type bool_type;
- operator bool_type() const
- {
- return base::operator bool_type();
- }
- };
-
-#ifdef BOOST_HAS_RVALUE_REFS
- template<typename Mutex>
- void swap(try_lock_wrapper<Mutex>&& lhs,try_lock_wrapper<Mutex>&& rhs)
- {
- lhs.swap(rhs);
- }
-#else
- template<typename Mutex>
- void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
- {
- lhs.swap(rhs);
- }
-#endif
-
- template<typename MutexType1,typename MutexType2>
- unsigned try_lock_internal(MutexType1& m1,MutexType2& m2)
- {
- boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
- if(!l1)
- {
- return 1;
- }
- if(!m2.try_lock())
- {
- return 2;
- }
- l1.release();
- return 0;
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3>
- unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3)
- {
- boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
- if(!l1)
- {
- return 1;
- }
- if(unsigned const failed_lock=try_lock_internal(m2,m3))
- {
- return failed_lock+1;
- }
- l1.release();
- return 0;
- }
-
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,
- typename MutexType4>
- unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3,
- MutexType4& m4)
- {
- boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
- if(!l1)
- {
- return 1;
- }
- if(unsigned const failed_lock=try_lock_internal(m2,m3,m4))
- {
- return failed_lock+1;
- }
- l1.release();
- return 0;
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,
- typename MutexType4,typename MutexType5>
- unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3,
- MutexType4& m4,MutexType5& m5)
- {
- boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
- if(!l1)
- {
- return 1;
- }
- if(unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
- {
- return failed_lock+1;
- }
- l1.release();
- return 0;
- }
-
-
- template<typename MutexType1,typename MutexType2>
- unsigned lock_helper(MutexType1& m1,MutexType2& m2)
- {
- boost::unique_lock<MutexType1> l1(m1);
- if(!m2.try_lock())
- {
- return 1;
- }
- l1.release();
- return 0;
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3>
- unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3)
- {
- boost::unique_lock<MutexType1> l1(m1);
- if(unsigned const failed_lock=try_lock_internal(m2,m3))
- {
- return failed_lock;
- }
- l1.release();
- return 0;
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,
- typename MutexType4>
- unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3,
- MutexType4& m4)
- {
- boost::unique_lock<MutexType1> l1(m1);
- if(unsigned const failed_lock=try_lock_internal(m2,m3,m4))
- {
- return failed_lock;
- }
- l1.release();
- return 0;
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,
- typename MutexType4,typename MutexType5>
- unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3,
- MutexType4& m4,MutexType5& m5)
- {
- boost::unique_lock<MutexType1> l1(m1);
- if(unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
- {
- return failed_lock;
- }
- l1.release();
- return 0;
- }
- }
-
- namespace detail
- {
- template<bool x>
- struct is_mutex_type_wrapper
- {};
-
- template<typename MutexType1,typename MutexType2>
- void lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
- {
- unsigned const lock_count=2;
- unsigned lock_first=0;
- while(true)
- {
- switch(lock_first)
- {
- case 0:
- lock_first=detail::lock_helper(m1,m2);
- if(!lock_first)
- return;
- break;
- case 1:
- lock_first=detail::lock_helper(m2,m1);
- if(!lock_first)
- return;
- lock_first=(lock_first+1)%lock_count;
- break;
- }
- }
- }
-
- template<typename Iterator>
- void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
- }
-
-
- template<typename MutexType1,typename MutexType2>
- void lock(MutexType1& m1,MutexType2& m2)
- {
- detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2>
- void lock(const MutexType1& m1,MutexType2& m2)
- {
- detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2>
- void lock(MutexType1& m1,const MutexType2& m2)
- {
- detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2>
- void lock(const MutexType1& m1,const MutexType2& m2)
- {
- detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3>
- void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3)
- {
- unsigned const lock_count=3;
- unsigned lock_first=0;
- while(true)
- {
- switch(lock_first)
- {
- case 0:
- lock_first=detail::lock_helper(m1,m2,m3);
- if(!lock_first)
- return;
- break;
- case 1:
- lock_first=detail::lock_helper(m2,m3,m1);
- if(!lock_first)
- return;
- lock_first=(lock_first+1)%lock_count;
- break;
- case 2:
- lock_first=detail::lock_helper(m3,m1,m2);
- if(!lock_first)
- return;
- lock_first=(lock_first+2)%lock_count;
- break;
- }
- }
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,
- typename MutexType4>
- void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,
- MutexType4& m4)
- {
- unsigned const lock_count=4;
- unsigned lock_first=0;
- while(true)
- {
- switch(lock_first)
- {
- case 0:
- lock_first=detail::lock_helper(m1,m2,m3,m4);
- if(!lock_first)
- return;
- break;
- case 1:
- lock_first=detail::lock_helper(m2,m3,m4,m1);
- if(!lock_first)
- return;
- lock_first=(lock_first+1)%lock_count;
- break;
- case 2:
- lock_first=detail::lock_helper(m3,m4,m1,m2);
- if(!lock_first)
- return;
- lock_first=(lock_first+2)%lock_count;
- break;
- case 3:
- lock_first=detail::lock_helper(m4,m1,m2,m3);
- if(!lock_first)
- return;
- lock_first=(lock_first+3)%lock_count;
- break;
- }
- }
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,
- typename MutexType4,typename MutexType5>
- void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,
- MutexType4& m4,MutexType5& m5)
- {
- unsigned const lock_count=5;
- unsigned lock_first=0;
- while(true)
- {
- switch(lock_first)
- {
- case 0:
- lock_first=detail::lock_helper(m1,m2,m3,m4,m5);
- if(!lock_first)
- return;
- break;
- case 1:
- lock_first=detail::lock_helper(m2,m3,m4,m5,m1);
- if(!lock_first)
- return;
- lock_first=(lock_first+1)%lock_count;
- break;
- case 2:
- lock_first=detail::lock_helper(m3,m4,m5,m1,m2);
- if(!lock_first)
- return;
- lock_first=(lock_first+2)%lock_count;
- break;
- case 3:
- lock_first=detail::lock_helper(m4,m5,m1,m2,m3);
- if(!lock_first)
- return;
- lock_first=(lock_first+3)%lock_count;
- break;
- case 4:
- lock_first=detail::lock_helper(m5,m1,m2,m3,m4);
- if(!lock_first)
- return;
- lock_first=(lock_first+4)%lock_count;
- break;
- }
- }
- }
-
- namespace detail
- {
- template<typename Mutex,bool x=is_mutex_type<Mutex>::value>
- struct try_lock_impl_return
- {
- typedef int type;
- };
-
- template<typename Iterator>
- struct try_lock_impl_return<Iterator,false>
- {
- typedef Iterator type;
- };
-
- template<typename MutexType1,typename MutexType2>
- int try_lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
- {
- return ((int)detail::try_lock_internal(m1,m2))-1;
- }
-
- template<typename Iterator>
- Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
- }
-
- template<typename MutexType1,typename MutexType2>
- typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,MutexType2& m2)
- {
- return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2>
- typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,MutexType2& m2)
- {
- return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2>
- typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,const MutexType2& m2)
- {
- return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2>
- typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,const MutexType2& m2)
- {
- return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3>
- int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3)
- {
- return ((int)detail::try_lock_internal(m1,m2,m3))-1;
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,typename MutexType4>
- int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,MutexType4& m4)
- {
- return ((int)detail::try_lock_internal(m1,m2,m3,m4))-1;
- }
-
- template<typename MutexType1,typename MutexType2,typename MutexType3,typename MutexType4,typename MutexType5>
- int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,MutexType4& m4,MutexType5& m5)
- {
- return ((int)detail::try_lock_internal(m1,m2,m3,m4,m5))-1;
- }
-
-
- namespace detail
- {
- template<typename Iterator>
- struct range_lock_guard
- {
- Iterator begin;
- Iterator end;
-
- range_lock_guard(Iterator begin_,Iterator end_):
- begin(begin_),end(end_)
- {
- lock(begin,end);
- }
-
- void release()
- {
- begin=end;
- }
-
- ~range_lock_guard()
- {
- for(;begin!=end;++begin)
- {
- begin->unlock();
- }
- }
- };
-
- template<typename Iterator>
- Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
-
- {
- if(begin==end)
- {
- return end;
- }
- typedef typename std::iterator_traits<Iterator>::value_type lock_type;
- unique_lock<lock_type> guard(*begin,try_to_lock);
-
- if(!guard.owns_lock())
- {
- return begin;
- }
- Iterator const failed=try_lock(++begin,end);
- if(failed==end)
- {
- guard.release();
- }
-
- return failed;
- }
- }
-
-
- namespace detail
- {
- template<typename Iterator>
- void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
- {
- typedef typename std::iterator_traits<Iterator>::value_type lock_type;
-
- if(begin==end)
- {
- return;
- }
- bool start_with_begin=true;
- Iterator second=begin;
- ++second;
- Iterator next=second;
-
- for(;;)
- {
- unique_lock<lock_type> begin_lock(*begin,defer_lock);
- if(start_with_begin)
- {
- begin_lock.lock();
- Iterator const failed_lock=try_lock(next,end);
- if(failed_lock==end)
- {
- begin_lock.release();
- return;
- }
- start_with_begin=false;
- next=failed_lock;
- }
- else
- {
- detail::range_lock_guard<Iterator> guard(next,end);
- if(begin_lock.try_lock())
- {
- Iterator const failed_lock=try_lock(second,next);
- if(failed_lock==next)
- {
- begin_lock.release();
- guard.release();
- return;
- }
- start_with_begin=false;
- next=failed_lock;
- }
- else
- {
- start_with_begin=true;
- next=second;
- }
- }
- }
- }
-
- }
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif