Subject: [Boost-commit] svn:boost r81100 - trunk/boost/thread
From: vicente.botet_at_[hidden]
Date: 2012-10-29 15:05:36
Author: viboes
Date: 2012-10-29 15:05:35 EDT (Mon, 29 Oct 2012)
New Revision: 81100
URL: http://svn.boost.org/trac/boost/changeset/81100
Log:
Thread: change strict_lock is_locking by own_lock and update lockable concepts
Added:
trunk/boost/thread/lockable_adapter.hpp (contents, props changed)
Text files modified:
trunk/boost/thread/lock_concepts.hpp | 60 ++++++++++++++++++++++++++++++++-------
trunk/boost/thread/lockable_concepts.hpp | 30 ++++++++++++++-----
trunk/boost/thread/strict_lock.hpp | 13 +++++---
3 files changed, 79 insertions(+), 24 deletions(-)
Modified: trunk/boost/thread/lock_concepts.hpp
==============================================================================
--- trunk/boost/thread/lock_concepts.hpp (original)
+++ trunk/boost/thread/lock_concepts.hpp 2012-10-29 15:05:35 EDT (Mon, 29 Oct 2012)
@@ -10,6 +10,7 @@
#include <boost/thread/lock_options.hpp>
#include <boost/thread/lockable_concepts.hpp>
#include <boost/thread/exceptions.hpp>
+#include <boost/thread/detail/move.hpp>
#include <boost/chrono/chrono.hpp>
#include <boost/concept_check.hpp>
@@ -37,7 +38,7 @@
Lk l2(mtx, defer_lock);
Lk l3(mtx, adopt_lock);
Lk l4(( Lk()));
- // BUG Lk l5(( boost::move(l1)));
+ Lk l5(( boost::move(l2)));
cvt_mutex_ptr(l1.mutex());
if (l1.owns_lock()) return;
if (l1) return;
@@ -48,7 +49,12 @@
l2.release();
}
- mutex_type mtx;
+ BasicLock() :
+ mtx(*static_cast<mutex_type*>(0))
+ {}
+ private:
+ BasicLock operator=(BasicLock const&);
+ mutex_type& mtx;
}
;
@@ -64,7 +70,12 @@
Lk l1(mtx, try_to_lock);
if (l1.try_lock()) return;
}
- mutex_type mtx;
+ Lock() :
+ mtx(*static_cast<mutex_type*>(0))
+ {}
+ private:
+ Lock operator=(Lock const&);
+ mutex_type& mtx;
};
template <typename Lk>
@@ -76,12 +87,17 @@
BOOST_CONCEPT_USAGE(TimedLock)
{
- Lk l1(mtx, t);
+ const Lk l1(mtx, t);
Lk l2(mtx, d);
if (l1.try_lock_until(t)) return;
if (l1.try_lock_for(d)) return;
}
- mutex_type mtx;
+ TimedLock() :
+ mtx(*static_cast<mutex_type*>(0))
+ {}
+ private:
+ TimedLock operator=(TimedLock const&);
+ mutex_type& mtx;
boost::chrono::system_clock::time_point t;
boost::chrono::system_clock::duration d;
};
@@ -96,7 +112,12 @@
{
}
- mutex_type mtx;
+ UniqueLock() :
+ mtx(*static_cast<mutex_type*>(0))
+ {}
+ private:
+ UniqueLock operator=(UniqueLock const&);
+ mutex_type& mtx;
};
template <typename Lk>
@@ -108,7 +129,12 @@
BOOST_CONCEPT_USAGE(SharedLock)
{
}
- mutex_type mtx;
+ SharedLock() :
+ mtx(*static_cast<mutex_type*>(0))
+ {}
+ private:
+ SharedLock operator=(SharedLock const&);
+ mutex_type& mtx;
};
@@ -121,7 +147,12 @@
BOOST_CONCEPT_USAGE(UpgradeLock)
{
}
- mutex_type mtx;
+ UpgradeLock() :
+ mtx(*static_cast<mutex_type*>(0))
+ {}
+ private:
+ UpgradeLock operator=(UpgradeLock const&);
+ mutex_type& mtx;
};
/**
@@ -147,10 +178,17 @@
BOOST_CONCEPT_USAGE( StrictLock)
{
- if (l1.is_locking(&mtx)) return;
+ if (l1.owns_lock(&mtx)) return;
}
- const Lk &l1;
- mutex_type mtx;
+ StrictLock() :
+ l1(*static_cast<Lk*>(0)),
+ mtx(*static_cast<mutex_type*>(0))
+ {}
+ private:
+ StrictLock operator=(StrictLock const&);
+
+ Lk const& l1;
+ mutex_type const& mtx;
};
Added: trunk/boost/thread/lockable_adapter.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/thread/lockable_adapter.hpp 2012-10-29 15:05:35 EDT (Mon, 29 Oct 2012)
@@ -0,0 +1,226 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009,2012. 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/thread for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_THREAD_LOCKABLE_ADAPTER_HPP
+#define BOOST_THREAD_LOCKABLE_ADAPTER_HPP
+
+#include <boost/thread/detail/delete.hpp>
+#include <boost/chrono/chrono.hpp>
+
+namespace boost
+{
+
+ //[basic_lockable_adapter
+ template <typename BasicLockable>
+ class basic_lockable_adapter
+ {
+ public:
+ typedef BasicLockable mutex_type;
+
+ protected:
+ mutex_type& lockable() const
+ {
+ return lockable_;
+ }
+ mutable mutex_type lockable_; /*< mutable so that it can be modified by const functions >*/
+ public:
+
+ BOOST_THREAD_NO_COPYABLE( basic_lockable_adapter) /*< no copyable >*/
+
+ basic_lockable_adapter()
+ {}
+
+ void lock()
+ {
+ lockable().lock();
+ }
+ void unlock()
+ {
+ lockable().unlock();
+ }
+
+ };
+ //]
+
+ //[lockable_adapter
+ template <typename Lockable>
+ class lockable_adapter : public basic_lockable_adapter<Lockable>
+ {
+ public:
+ typedef Lockable mutex_type;
+
+ bool try_lock()
+ {
+ return this->lockable().try_lock();
+ }
+ };
+ //]
+
+ //[timed_lockable_adapter
+ template <typename TimedLock>
+ class timed_lockable_adapter: public lockable_adapter<TimedLock>
+ {
+ public:
+ typedef TimedLock mutex_type;
+
+ template <typename Clock, typename Duration>
+ bool try_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
+ {
+ return this->lockable().try_lock_until(abs_time);
+ }
+ template <typename Rep, typename Period>
+ bool try_lock_for(chrono::duration<Rep, Period> const & rel_time)
+ {
+ return this->lockable().try_lock_for(rel_time);
+ }
+
+ };
+ //]
+
+ //[shared_lockable_adapter
+ template <typename SharableLock>
+ class shared_lockable_adapter: public timed_lockable_adapter<SharableLock>
+ {
+ public:
+ typedef SharableLock mutex_type;
+
+ void lock_shared()
+ {
+ this->lockable().lock_shared();
+ }
+ bool try_lock_shared()
+ {
+ return this->lockable().try_lock_shared();
+ }
+ void unlock_shared()
+ {
+ this->lockable().unlock_shared();
+ }
+
+ template <typename Clock, typename Duration>
+ bool try_lock_shared_until(chrono::time_point<Clock, Duration> const & abs_time)
+ {
+ return this->lockable().try_lock_shared_until(abs_time);
+ }
+ template <typename Rep, typename Period>
+ bool try_lock_shared_for(chrono::duration<Rep, Period> const & rel_time)
+ {
+ return this->lockable().try_lock_shared_for(rel_time);
+ }
+
+ };
+
+ //]
+
+ //[upgrade_lockable_adapter
+ template <typename UpgradableLock>
+ class upgrade_lockable_adapter: public shared_lockable_adapter<UpgradableLock>
+ {
+ public:
+ typedef UpgradableLock mutex_type;
+
+ void lock_upgrade()
+ {
+ this->lockable().lock_upgrade();
+ }
+
+ bool try_lock_upgrade()
+ {
+ return this->lockable().try_lock_upgrade();
+ }
+
+ void unlock_upgrade()
+ {
+ this->lockable().unlock_upgrade();
+ }
+
+ template <typename Clock, typename Duration>
+ bool try_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
+ {
+ return this->lockable().try_lock_upgrade_until(abs_time);
+ }
+ template <typename Rep, typename Period>
+ bool try_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
+ {
+ return this->lockable().try_lock_upgrade_for(rel_time);
+ }
+
+ bool try_unlock_shared_and_lock()
+ {
+ return this->lockable().try_unlock_shared_and_lock();
+ }
+
+ template <typename Clock, typename Duration>
+ bool try_unlock_shared_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
+ {
+ return this->lockable().try_unlock_shared_and_lock_until(abs_time);
+ }
+ template <typename Rep, typename Period>
+ bool try_unlock_shared_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
+ {
+ return this->lockable().try_unlock_shared_and_lock_for(rel_time);
+ }
+
+ void unlock_and_lock_shared()
+ {
+ this->lockable().unlock_and_lock_shared();
+ }
+
+ bool try_unlock_shared_and_lock_upgrade()
+ {
+ return this->lockable().try_unlock_shared_and_lock_upgrade();
+ }
+
+ template <typename Clock, typename Duration>
+ bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
+ {
+ return this->lockable().try_unlock_shared_and_lock_upgrade_until(abs_time);
+ }
+ template <typename Rep, typename Period>
+ bool try_unlock_shared_and_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
+ {
+ return this->lockable().try_unlock_shared_and_lock_upgrade_for(rel_time);
+ }
+
+ void unlock_and_lock_upgrade()
+ {
+ this->lockable().unlock_and_lock_upgrade();
+ }
+
+ void unlock_upgrade_and_lock()
+ {
+ this->lockable().unlock_upgrade_and_lock();
+ }
+
+ bool try_unlock_upgrade_and_lock()
+ {
+ return this->lockable().try_unlock_upgrade_and_lock();
+ }
+ template <typename Clock, typename Duration>
+ bool try_unlock_upgrade_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
+ {
+ return this->lockable().try_unlock_upgrade_and_lock_until(abs_time);
+ }
+ template <typename Rep, typename Period>
+ bool try_unlock_upgrade_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
+ {
+ return this->lockable().try_unlock_upgrade_and_lock_for(rel_time);
+ }
+
+ void unlock_upgrade_and_lock_shared()
+ {
+ this->lockable().unlock_upgrade_and_lock_shared();
+ }
+
+ };
+//]
+
+}
+#endif
Modified: trunk/boost/thread/lockable_concepts.hpp
==============================================================================
--- trunk/boost/thread/lockable_concepts.hpp (original)
+++ trunk/boost/thread/lockable_concepts.hpp 2012-10-29 15:05:35 EDT (Mon, 29 Oct 2012)
@@ -28,8 +28,11 @@
l.lock();
l.unlock();
}
+ BasicLockable() : l(*static_cast<Mutex*>(0)) {}
private:
- Mutex l;
+ BasicLockable operator=(BasicLockable const&);
+
+ Mutex& l;
}
;
//]
@@ -48,8 +51,10 @@
{
if (l.try_lock()) return;
}
+ Lockable() : l(*static_cast<Mutex*>(0)) {}
private:
- Mutex l;
+ Lockable operator=(Lockable const&);
+ Mutex& l;
};
//]
@@ -69,9 +74,12 @@
if (l.try_lock_until(t)) return;
if (l.try_lock_for(d)) return;
}
+ TimedLockable() : l(*static_cast<Mutex*>(0)) {}
+ private:
+ TimedLockable operator=(TimedLockable const&);
Mutex& l;
- chrono::system_clock::time_point& t;
- chrono::system_clock::duration& d;
+ chrono::system_clock::time_point t;
+ chrono::system_clock::duration d;
};
//]
@@ -94,9 +102,12 @@
if (l.try_lock_shared_until(t)) return;
if (l.try_lock_shared_for(d)) return;
}
+ SharedLockable() : l(*static_cast<Mutex*>(0)) {}
+ private:
+ SharedLockable operator=(SharedLockable const&);
Mutex& l;
- chrono::system_clock::time_point& t;
- chrono::system_clock::duration& d;
+ chrono::system_clock::time_point t;
+ chrono::system_clock::duration d;
};
//]
@@ -133,9 +144,12 @@
if (l.try_unlock_upgrade_and_lock_for(d)) return;
l.unlock_upgrade_and_lock_shared();
}
+ UpgradeLockable() : l(*static_cast<Mutex*>(0)) {}
+ private:
+ UpgradeLockable operator=(UpgradeLockable const&);
Mutex& l;
- chrono::system_clock::time_point& t;
- chrono::system_clock::duration& d;
+ chrono::system_clock::time_point t;
+ chrono::system_clock::duration d;
};
//]
Modified: trunk/boost/thread/strict_lock.hpp
==============================================================================
--- trunk/boost/thread/strict_lock.hpp (original)
+++ trunk/boost/thread/strict_lock.hpp 2012-10-29 15:05:35 EDT (Mon, 29 Oct 2012)
@@ -62,6 +62,8 @@
// observers
+ private:
+
/**
* @return the owned mutex.
*/
@@ -69,11 +71,12 @@
{
return &mtx_;
}
+ public:
/**
* @return whether if this lock is locking that mutex.
*/
- bool is_locking(mutex_type* l) const BOOST_NOEXCEPT
+ bool owns_lock(mutex_type const* l) const BOOST_NOEXCEPT
{
return l == mutex();
} /*< strict locks specific function >*/
@@ -115,7 +118,7 @@
* __Requires: <c>lk.mutex() != null_ptr</c>
* __Effects: Stores the reference to the lock parameter and takes ownership on it.
* If the lock doesn't owns the mutex @mtx lock it.
- * __Postconditions: @c is_locking()
+ * __Postconditions: @c owns_lock()
* __StrongException
* __Throws:
*
@@ -148,7 +151,7 @@
}
// observers
-
+private:
/**
* return @c the owned mutex.
*/
@@ -156,11 +159,11 @@
{
return tmp_lk_.mutex();
}
-
+public:
/**
* @return whether if this lock is locking that mutex.
*/
- bool is_locking(mutex_type* l) const BOOST_NOEXCEPT
+ bool owns_lock(mutex_type const* l) const BOOST_NOEXCEPT
{
return l == mutex();
}