Subject: [Boost-commit] svn:boost r85607 - in trunk/boost/sync: . detail locks support
From: andrey.semashev_at_[hidden]
Date: 2013-09-08 13:11:07
Author: andysem
Date: 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013)
New Revision: 85607
URL: http://svn.boost.org/trac/boost/changeset/85607
Log:
Proceeding with Boost.Sync.
Added:
trunk/boost/sync/detail/time_traits.hpp (contents, props changed)
trunk/boost/sync/detail/time_units.hpp (contents, props changed)
trunk/boost/sync/locks/lock_guard_fwd.hpp (contents, props changed)
trunk/boost/sync/locks/shared_lock_fwd.hpp (contents, props changed)
trunk/boost/sync/locks/shared_lock_guard_fwd.hpp (contents, props changed)
trunk/boost/sync/locks/unique_lock_fwd.hpp (contents, props changed)
trunk/boost/sync/locks/upgrade_lock_fwd.hpp (contents, props changed)
trunk/boost/sync/support/
trunk/boost/sync/support/date_time.hpp (contents, props changed)
Text files modified:
trunk/boost/sync/detail/config.hpp | 8
trunk/boost/sync/detail/lockable_wrapper.hpp | 14
trunk/boost/sync/detail/time_traits.hpp | 60 +++++
trunk/boost/sync/detail/time_units.hpp | 158 +++++++++++++++
trunk/boost/sync/locks.hpp | 1
trunk/boost/sync/locks/lock_guard.hpp | 11
trunk/boost/sync/locks/lock_guard_fwd.hpp | 43 ++++
trunk/boost/sync/locks/shared_lock_fwd.hpp | 43 ++++
trunk/boost/sync/locks/shared_lock_guard.hpp | 11
trunk/boost/sync/locks/shared_lock_guard_fwd.hpp | 43 ++++
trunk/boost/sync/locks/unique_lock.hpp | 405 ++++++++++++++++-----------------------
trunk/boost/sync/locks/unique_lock_fwd.hpp | 43 ++++
trunk/boost/sync/locks/upgrade_lock_fwd.hpp | 43 ++++
trunk/boost/sync/support/date_time.hpp | 87 ++++++++
14 files changed, 710 insertions(+), 260 deletions(-)
Modified: trunk/boost/sync/detail/config.hpp
==============================================================================
--- trunk/boost/sync/detail/config.hpp Sun Sep 8 12:10:04 2013 (r85606)
+++ trunk/boost/sync/detail/config.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -32,15 +32,15 @@
#endif
#if defined(BOOST_SYNC_USE_PTHREAD)
-#define BOOST_SYNC_AUX_PLATFORM_PTHREAD
+#define BOOST_SYNC_DETAIL_PLATFORM_PTHREAD
#elif defined(BOOST_SYNC_USE_WINAPI_VERSION)
-#define BOOST_SYNC_AUX_PLATFORM_WINAPI
+#define BOOST_SYNC_DETAIL_PLATFORM_WINAPI
#else
-#define BOOST_SYNC_AUX_PLATFORM_PTHREAD
+#define BOOST_SYNC_DETAIL_PLATFORM_PTHREAD
#endif
#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#define BOOST_SYNC_AUX_NO_CXX11_INITIALIZER_LISTS
+#define BOOST_SYNC_DETAIL_NO_CXX11_INITIALIZER_LISTS
#endif
#endif // BOOST_SYNC_DETAIL_CONFIG_HPP_INCLUDED_
Modified: trunk/boost/sync/detail/lockable_wrapper.hpp
==============================================================================
--- trunk/boost/sync/detail/lockable_wrapper.hpp Sun Sep 8 12:10:04 2013 (r85606)
+++ trunk/boost/sync/detail/lockable_wrapper.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -19,17 +19,21 @@
#include <boost/sync/detail/config.hpp>
#include <boost/sync/detail/header.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
namespace boost {
namespace sync {
-namespace aux {
+namespace detail {
-template< typename MutexT, typename OptionT = void >
+template< typename Mutex, typename Option = void >
struct lockable_wrapper
{
- typedef MutexT mutex_type;
- typedef OptionT lock_option;
+ typedef Mutex mutex_type;
+ typedef Option lock_option;
mutex_type* m_mutex;
@@ -38,7 +42,7 @@
}
};
-} // namespace aux
+} // namespace detail
} // namespace sync
Added: trunk/boost/sync/detail/time_traits.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/detail/time_traits.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,60 @@
+/*
+ * 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 2012-2013 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file time_traits.hpp
+ *
+ * \brief This header is the Boost.Sync library implementation, see the library documentation
+ * at http://www.boost.org/doc/libs/release/libs/sync/doc/html/index.html.
+ */
+
+#ifndef BOOST_SYNC_DETAIL_TIME_TRAITS_HPP_INCLUDED_
+#define BOOST_SYNC_DETAIL_TIME_TRAITS_HPP_INCLUDED_
+
+#include <boost/sync/detail/config.hpp>
+#include <boost/sync/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+struct time_point_tag {};
+struct time_duration_tag {};
+
+template< typename T, typename Void = void >
+struct time_traits
+{
+ static BOOST_CONSTEXPR_OR_CONST bool is_specialized = false;
+};
+
+template< typename T, typename Tag, typename R >
+struct enable_if_tag
+{
+};
+
+template< typename T, typename R >
+struct enable_if_tag< T, typename time_traits< T >::tag, R >
+{
+ typedef R type;
+};
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_DETAIL_TIME_TRAITS_HPP_INCLUDED_
Added: trunk/boost/sync/detail/time_units.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/detail/time_units.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,158 @@
+/*
+ * Copyright Andrey Semashev 2013.
+ * 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)
+ */
+/*!
+ * \file time_units.hpp
+ *
+ * \brief This header is the Boost.Sync library implementation, see the library documentation
+ * at http://www.boost.org/doc/libs/release/libs/sync/doc/html/index.html.
+ */
+
+#ifndef BOOST_SYNC_DETAIL_TIME_UNITS_HPP_INCLUDED_
+#define BOOST_SYNC_DETAIL_TIME_UNITS_HPP_INCLUDED_
+
+#include <time.h>
+#include <boost/cstdint.hpp>
+#include <boost/sync/detail/config.hpp>
+#include <boost/sync/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+#if defined(BOOST_SYNC_DETAIL_PLATFORM_PTHREAD)
+
+class duration
+{
+public:
+ typedef int64_t native_type;
+ // The native duration is in nanoseconds
+ static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = 1000000000u;
+
+private:
+ native_type m_value;
+
+public:
+ duration() : m_value(0) {}
+ explicit duration(native_type value) : m_value(value) {}
+
+ native_type get() const { return m_value; }
+
+ duration& operator+= (duration const& that)
+ {
+ m_value += that.m_value;
+ return *this;
+ }
+ duration& operator-= (duration const& that)
+ {
+ m_value -= that.m_value;
+ return *this;
+ }
+ duration operator- () const
+ {
+ return duration(-m_value);
+ }
+
+ friend duration operator+ (duration left, duration const& right)
+ {
+ left += right;
+ return left;
+ }
+ friend duration operator- (duration left, duration const& right)
+ {
+ left -= right;
+ return left;
+ }
+};
+
+class time_point
+{
+public:
+ typedef struct ::timespec native_type;
+ // The native subsecond precision is nanoseconds
+ static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = duration::subsecond_fraction;
+
+private:
+ native_type m_value;
+
+public:
+ time_point() : m_value() {}
+ explicit time_point(time_t t, unsigned long subsecond = 0)
+ {
+ m_value.tv_sec = t;
+ m_value.tv_nsec = subsecond;
+ }
+
+ native_type const& get() const { return m_value; }
+
+ static time_point now()
+ {
+#if defined(BOOST_HAS_CLOCK_GETTIME)
+ time_point t;
+ ::clock_gettime(CLOCK_REALTIME, &t.m_value);
+ return t;
+#else
+ return time_point(::time(0));
+#endif
+ }
+
+ time_point& operator+= (duration const& dur)
+ {
+ int64_t nsec = static_cast< int64_t >(m_value.tv_nsec) + dur.get();
+ int64_t tv_nsec = nsec % duration::subsecond_fraction;
+ if (tv_nsec < 0)
+ {
+ tv_nsec += subsecond_fraction;
+ --m_value.tv_sec;
+ }
+ m_value.tv_nsec = tv_nsec;
+ m_value.tv_sec += nsec / duration::subsecond_fraction;
+ }
+ time_point& operator-= (duration const& dur)
+ {
+ return operator+= (-dur);
+ }
+
+ friend time_point operator+ (time_point left, duration const& right)
+ {
+ left += right;
+ return left;
+ }
+ friend time_point operator- (time_point left, duration const& right)
+ {
+ left -= right;
+ return left;
+ }
+
+ friend duration operator- (time_point const& left, time_point const& right)
+ {
+ int64_t seconds = static_cast< int64_t >(left.m_value.tv_sec) - static_cast< int64_t >(right.m_value.tv_sec);
+ int64_t nseconds = static_cast< int64_t >(left.m_value.tv_nsec) - static_cast< int64_t >(right.m_value.tv_nsec);
+ return duration(seconds * duration::subsecond_fraction + nseconds);
+ }
+};
+
+#elif defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)
+
+// TODO
+
+#endif
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_DETAIL_TIME_UNITS_HPP_INCLUDED_
Modified: trunk/boost/sync/locks.hpp
==============================================================================
--- trunk/boost/sync/locks.hpp Sun Sep 8 12:10:04 2013 (r85606)
+++ trunk/boost/sync/locks.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -22,5 +22,6 @@
#include <boost/sync/locks/lock_guard.hpp>
#include <boost/sync/locks/shared_lock_guard.hpp>
+#include <boost/sync/locks/unique_lock.hpp>
#endif // BOOST_SYNC_LOCKS_HPP_INCLUDED_
Modified: trunk/boost/sync/locks/lock_guard.hpp
==============================================================================
--- trunk/boost/sync/locks/lock_guard.hpp Sun Sep 8 12:10:04 2013 (r85606)
+++ trunk/boost/sync/locks/lock_guard.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -23,6 +23,7 @@
#endif
#include <boost/sync/locks/lock_options.hpp>
+#include <boost/sync/locks/lock_guard_fwd.hpp>
#include <boost/sync/detail/header.hpp>
@@ -33,14 +34,14 @@
/*!
* \brief A unique lock scope guard
*/
-template< typename MutexT >
+template< typename Mutex >
class lock_guard
{
-private:
- MutexT& m_mutex;
-
public:
- typedef MutexT mutex_type;
+ typedef Mutex mutex_type;
+
+private:
+ mutex_type& m_mutex;
public:
explicit lock_guard(mutex_type& m) : m_mutex(m)
Added: trunk/boost/sync/locks/lock_guard_fwd.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/locks/lock_guard_fwd.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * (C) Copyright 2011-2012 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file locks/lock_guard_fwd.hpp
+ *
+ * \brief This header declares an exclusive lock guard.
+ */
+
+#ifndef BOOST_SYNC_LOCKS_LOCK_GUARD_FWD_HPP_INCLUDED_
+#define BOOST_SYNC_LOCKS_LOCK_GUARD_FWD_HPP_INCLUDED_
+
+#include <boost/sync/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#include <boost/sync/detail/header.hpp>
+
+namespace boost {
+
+namespace sync {
+
+/*!
+ * \brief A unique lock scope guard
+ */
+template< typename Mutex >
+class lock_guard;
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_LOCKS_LOCK_GUARD_FWD_HPP_INCLUDED_
Added: trunk/boost/sync/locks/shared_lock_fwd.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/locks/shared_lock_fwd.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * (C) Copyright 2011-2012 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file locks/shared_lock_fwd.hpp
+ *
+ * \brief This header declares a shared lock guard.
+ */
+
+#ifndef BOOST_SYNC_LOCKS_SHARED_LOCK_FWD_HPP_INCLUDED_
+#define BOOST_SYNC_LOCKS_SHARED_LOCK_FWD_HPP_INCLUDED_
+
+#include <boost/sync/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#include <boost/sync/detail/header.hpp>
+
+namespace boost {
+
+namespace sync {
+
+/*!
+ * \brief A unique lock scope guard
+ */
+template< typename Mutex >
+class shared_lock;
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_LOCKS_SHARED_LOCK_FWD_HPP_INCLUDED_
Modified: trunk/boost/sync/locks/shared_lock_guard.hpp
==============================================================================
--- trunk/boost/sync/locks/shared_lock_guard.hpp Sun Sep 8 12:10:04 2013 (r85606)
+++ trunk/boost/sync/locks/shared_lock_guard.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -22,6 +22,7 @@
#endif
#include <boost/sync/locks/lock_options.hpp>
+#include <boost/sync/locks/shared_lock_guard_fwd.hpp>
#include <boost/sync/detail/header.hpp>
@@ -32,14 +33,14 @@
/*!
* \brief A shared lock scope guard
*/
-template< typename MutexT >
+template< typename Mutex >
class shared_lock_guard
{
-private:
- MutexT& m_mutex;
-
public:
- typedef MutexT mutex_type;
+ typedef Mutex mutex_type;
+
+private:
+ mutex_type& m_mutex;
public:
explicit shared_lock_guard(mutex_type& m) : m_mutex(m)
Added: trunk/boost/sync/locks/shared_lock_guard_fwd.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/locks/shared_lock_guard_fwd.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * (C) Copyright 2011-2012 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file locks/shared_lock_guard_fwd.hpp
+ *
+ * \brief This header declares a shared lock guard.
+ */
+
+#ifndef BOOST_SYNC_LOCKS_SHARED_LOCK_GUARD_FWD_HPP_INCLUDED_
+#define BOOST_SYNC_LOCKS_SHARED_LOCK_GUARD_FWD_HPP_INCLUDED_
+
+#include <boost/sync/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#include <boost/sync/detail/header.hpp>
+
+namespace boost {
+
+namespace sync {
+
+/*!
+ * \brief A shared lock scope guard
+ */
+template< typename Mutex >
+class shared_lock_guard;
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_LOCKS_SHARED_LOCK_GUARD_FWD_HPP_INCLUDED_
Modified: trunk/boost/sync/locks/unique_lock.hpp
==============================================================================
--- trunk/boost/sync/locks/unique_lock.hpp Sun Sep 8 12:10:04 2013 (r85606)
+++ trunk/boost/sync/locks/unique_lock.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -17,10 +17,17 @@
#define BOOST_SYNC_LOCKS_UNIQUE_LOCK_HPP_INCLUDED_
#include <cstddef>
+#include <boost/throw_exception.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/utility/explicit_operator_bool.hpp>
#include <boost/sync/detail/config.hpp>
+#include <boost/sync/detail/time_traits.hpp>
#include <boost/sync/locks/lock_options.hpp>
+#include <boost/sync/locks/unique_lock_fwd.hpp>
+#include <boost/sync/locks/shared_lock_fwd.hpp>
+#include <boost/sync/locks/upgrade_lock_fwd.hpp>
#include <boost/sync/detail/header.hpp>
@@ -35,11 +42,11 @@
/*!
* \brief A unique lock scope guard
*/
-template< typename MutexT >
+template< typename Mutex >
class unique_lock
{
public:
- typedef MutexT mutex_type;
+ typedef Mutex mutex_type;
private:
mutex_type* m_mutex;
@@ -50,7 +57,7 @@
unique_lock& operator= (upgrade_lock< mutex_type >& other);
public:
- BOOST_THREAD_MOVABLE_ONLY( unique_lock)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_lock)
unique_lock() BOOST_NOEXCEPT :
m_mutex(NULL), m_is_locked(false)
@@ -76,300 +83,207 @@
try_lock();
}
- template< typename TimeT >
- unique_lock(typename enable_if_c< aux::time_traits< TimeT >::is_supported, mutex_type& >::type m, TimeT const& t) :
+ template< typename Time >
+ unique_lock(typename enable_if_c< detail::time_traits< Time >::is_supported, mutex_type& >::type m, Time const& t) :
m_mutex(&m), m_is_locked(false)
{
timed_lock(t);
}
- unique_lock(BOOST_THREAD_RV_REF(unique_lock) other) BOOST_NOEXCEPT :
- m_mutex(BOOST_THREAD_RV(other).m_mutex), m_is_locked(BOOST_THREAD_RV(other).m_is_locked)
+ unique_lock(BOOST_RV_REF(unique_lock) that) BOOST_NOEXCEPT :
+ m_mutex(that.m_mutex), m_is_locked(that.m_is_locked)
{
- BOOST_THREAD_RV(other).m_is_locked = false;
- BOOST_THREAD_RV(other).m_mutex = NULL;
+ that.m_mutex = NULL;
+ that.m_is_locked = false;
}
- BOOST_THREAD_EXPLICIT_LOCK_CONVERSION unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other);
-
-#ifndef BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
- //std-2014 unique_lock move-assignment should not be noexcept
- unique_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other) //BOOST_NOEXCEPT
- {
- unique_lock temp(::boost::move(other));
- swap(temp);
- return *this;
- }
-#endif
-
- //std-2014 unique_lock move-assignment should not be noexcept
- unique_lock& operator=(BOOST_THREAD_RV_REF(unique_lock) other) //BOOST_NOEXCEPT
+ explicit unique_lock(BOOST_RV_REF(upgrade_lock< mutex_type >) that)
+ m_mutex(that.m_mutex), is_locked(that.m_is_locked)
{
- unique_lock temp(::boost::move(other));
- swap(temp);
- return *this;
+ if (m_is_locked)
+ {
+ m_mutex->unlock_upgrade_and_lock();
+ }
+ that.release();
}
// Conversion from upgrade lock
- unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul, try_to_lock_t) :
+ unique_lock(BOOST_RV_REF(upgrade_lock< mutex_type >) ul, try_to_lock_t) :
m_mutex(NULL), m_is_locked(false)
{
- if (BOOST_THREAD_RV(ul).owns_lock())
+ if (ul.owns_lock())
{
- if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock())
+ if (ul.mutex()->try_unlock_upgrade_and_lock())
{
- m_mutex = BOOST_THREAD_RV(ul).release();
+ m_mutex = ul.release();
m_is_locked = true;
}
}
else
{
- m_mutex = BOOST_THREAD_RV(ul).release();
+ m_mutex = ul.release();
}
}
-#ifdef BOOST_THREAD_USES_CHRONO
- template <class Clock, class Duration>
- unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul,
- const chrono::time_point<Clock, Duration>& abs_time)
- : m(0),m_is_locked(false)
- {
- if (BOOST_THREAD_RV(ul).owns_lock())
- {
- if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock_until(abs_time))
- {
- m = BOOST_THREAD_RV(ul).release();
- m_is_locked = true;
- }
- }
- else
+ // Conversion from shared locking
+ unique_lock(BOOST_RV_REF(shared_lock< mutex_type >) sl, try_to_lock_t) :
+ m_mutex(NULL), m_is_locked(false)
{
- m = BOOST_THREAD_RV(ul).release();
+ if (sl.owns_lock())
+ {
+ if (sl.mutex()->try_unlock_shared_and_lock())
+ {
+ m_mutex = sl.release();
+ m_is_locked = true;
+ }
+ }
+ else
+ {
+ m_mutex = sl.release();
+ }
}
- }
- template <class Rep, class Period>
- unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul,
- const chrono::duration<Rep, Period>& rel_time)
- : m(0),m_is_locked(false)
- {
- if (BOOST_THREAD_RV(ul).owns_lock())
- {
- if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock_for(rel_time))
- {
- m = BOOST_THREAD_RV(ul).release();
- m_is_locked = true;
- }
- }
- else
+ template< typename Time >
+ unique_lock(BOOST_RV_REF(shared_lock< mutex_type >) sl, Time const& t, typename enable_if_c< detail::time_traits< Time >::is_supported, int >::type = 0) :
+ m_mutex(NULL), m_is_locked(false)
{
- m = BOOST_THREAD_RV(ul).release();
+ if (sl.owns_lock())
+ {
+ if (sl.mutex()->timed_unlock_shared_and_lock(t))
+ {
+ m_mutex = sl.release();
+ m_is_locked = true;
+ }
+ }
+ else
+ {
+ m_mutex = sl.release();
+ }
}
- }
-#endif
-#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
- // Conversion from shared locking
- unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, try_to_lock_t)
- : m(0),m_is_locked(false)
- {
- if (BOOST_THREAD_RV(sl).owns_lock())
- {
- if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock())
- {
- m = BOOST_THREAD_RV(sl).release();
- m_is_locked = true;
- }
- }
- else
+ ~unique_lock()
{
- m = BOOST_THREAD_RV(sl).release();
+ if (m_is_locked)
+ {
+ m_mutex->unlock();
+ }
}
- }
-#ifdef BOOST_THREAD_USES_CHRONO
- template <class Clock, class Duration>
- unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl,
- const chrono::time_point<Clock, Duration>& abs_time)
- : m(0),m_is_locked(false)
- {
- if (BOOST_THREAD_RV(sl).owns_lock())
+ unique_lock& operator= (BOOST_RV_REF(unique_lock) that) BOOST_NOEXCEPT
{
- if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_until(abs_time))
- {
- m = BOOST_THREAD_RV(sl).release();
- m_is_locked = true;
- }
+ swap((unique_lock&)that);
+ return *this;
}
- else
+
+ unique_lock& operator= (BOOST_RV_REF(upgrade_lock< mutex_type >) other)
{
- m = BOOST_THREAD_RV(sl).release();
+ unique_lock temp(boost::move(other));
+ swap(temp);
+ return *this;
}
- }
- template <class Rep, class Period>
- unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl,
- const chrono::duration<Rep, Period>& rel_time)
- : m(0),m_is_locked(false)
- {
- if (BOOST_THREAD_RV(sl).owns_lock())
+ void lock()
{
- if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_for(rel_time))
- {
- m = BOOST_THREAD_RV(sl).release();
+ if (!m_mutex)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
+ }
+ if (m_is_locked)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock already owns the mutex"));
+ }
+
+ m_mutex->lock();
m_is_locked = true;
- }
}
- else
+
+ bool try_lock()
{
- m = BOOST_THREAD_RV(sl).release();
- }
- }
-#endif // BOOST_THREAD_USES_CHRONO
-#endif // BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+ if (!m_mutex)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
+ }
+ if (m_is_locked)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock already owns the mutex"));
+ }
- void swap(unique_lock& other)BOOST_NOEXCEPT
- {
- std::swap(m,other.m);
- std::swap(m_is_locked,other.m_is_locked);
- }
+ m_is_locked = m_mutex->try_lock();
- ~unique_lock()
- {
- if (owns_lock())
- {
- m->unlock();
+ return m_is_locked;
}
- }
- void lock()
- {
- if (m == 0)
+ template< typename Time >
+ typename enable_if_c< detail::time_traits< Time >::is_supported, bool >::type timed_lock(Time const& time)
{
- boost::throw_exception(
- boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
- }
- if (owns_lock())
- {
- boost::throw_exception(
- boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
- }
- m->lock();
- m_is_locked = true;
- }
+ if (!m_mutex)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
+ }
+ if (m_is_locked)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock already owns the mutex"));
+ }
- bool try_lock()
- {
- if (m == 0)
- {
- boost::throw_exception(
- boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
- }
- if (owns_lock())
- {
- boost::throw_exception(
- boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
- }
- m_is_locked = m->try_lock();
- return m_is_locked;
- }
-#if defined BOOST_THREAD_USES_DATETIME
- template<typename TimeDuration>
- bool timed_lock(TimeDuration const& relative_time)
- {
- if(m==0)
- {
- boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
- }
- if(owns_lock())
- {
- boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
- }
- m_is_locked=m->timed_lock(relative_time);
- return m_is_locked;
- }
+ m_is_locked = m->timed_lock(time);
- bool timed_lock(::boost::system_time const& absolute_time)
- {
- if(m==0)
- {
- boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
- }
- if(owns_lock())
- {
- boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
- }
- m_is_locked=m->timed_lock(absolute_time);
- return m_is_locked;
- }
- bool timed_lock(::boost::xtime const& absolute_time)
- {
- if(m==0)
- {
- boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
- }
- if(owns_lock())
- {
- boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
+ return m_is_locked;
}
- m_is_locked=m->timed_lock(absolute_time);
- return m_is_locked;
- }
-#endif
-#ifdef BOOST_THREAD_USES_CHRONO
- template <class Rep, class Period>
- bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
- {
- if(m==0)
- {
- boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
- }
- if(owns_lock())
+ template< typename Duration >
+ typename detail::enable_if_tag< Duration, detail::time_duration_tag, bool >::type try_lock_for(Duration const& rel_time)
{
- boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
- }
- m_is_locked=m->try_lock_for(rel_time);
- return m_is_locked;
- }
- template <class Clock, class Duration>
- bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
- {
- if(m==0)
- {
- boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
- }
- if(owns_lock())
- {
- boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
+ if (!m_mutex)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
+ }
+ if (m_is_locked)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock already owns the mutex"));
+ }
+
+ m_is_locked = m_mutex->try_lock_for(rel_time);
+
+ return m_is_locked;
}
- m_is_locked=m->try_lock_until(abs_time);
- return m_is_locked;
- }
-#endif
- void unlock()
- {
- if (m == 0)
+ template< typename TimePoint >
+ typename detail::enable_if_tag< Duration, detail::time_point_tag, bool >::type try_lock_until(TimePoint const& abs_time)
{
- boost::throw_exception(
- boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
+ if (!m_mutex)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
+ }
+ if (m_is_locked)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
+ }
+
+ m_is_locked = m_mutex->try_lock_until(abs_time);
+
+ return m_is_locked;
}
- if (!owns_lock())
+
+ void unlock()
{
- boost::throw_exception(
- boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock doesn't own the mutex"));
- }
- m->unlock();
- m_is_locked = false;
- }
+ if (!m_mutex)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
+ }
+ if (m_is_locked)
+ {
+ boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock doesn't own the mutex"));
+ }
+ m_mutex->unlock();
+ m_is_locked = false;
+ }
BOOST_EXPLICIT_OPERATOR_BOOL()
- bool operator!() const BOOST_NOEXCEPT
+ bool operator! () const BOOST_NOEXCEPT
{
- return !owns_lock();
+ return !m_is_locked;
}
bool owns_lock() const BOOST_NOEXCEPT
@@ -377,27 +291,36 @@
return m_is_locked;
}
- Mutex* mutex() const BOOST_NOEXCEPT
+ mutex_type* mutex() const BOOST_NOEXCEPT
{
return m_mutex;
}
- Mutex* release() BOOST_NOEXCEPT
+ mutex_type* release() BOOST_NOEXCEPT
{
- Mutex* const res = m_mutex;
+ mutex_type* const res = m_mutex;
m_mutex = NULL;
m_is_locked = false;
return res;
}
+
+ void swap(unique_lock& that) BOOST_NOEXCEPT
+ {
+ mutex_type* const p = m_mutex;
+ m_mutex = that.m_mutex;
+ that.m_mutex = p;
+ const bool f = m_is_locked;
+ m_is_locked = that.m_is_locked;
+ that.m_is_locked = f;
+ }
};
-template< typename MutexT >
-inline void swap(unique_lock< MutexT >& lhs, unique_lock< MutexT >& rhs) BOOST_NOEXCEPT
+template< typename Mutex >
+inline void swap(unique_lock< Mutex >& lhs, unique_lock< Mutex >& rhs) BOOST_NOEXCEPT
{
lhs.swap(rhs);
}
-
} // namespace sync
} // namespace boost
Added: trunk/boost/sync/locks/unique_lock_fwd.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/locks/unique_lock_fwd.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * (C) Copyright 2011-2012 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file locks/unique_lock_fwd.hpp
+ *
+ * \brief This header declares an exclusive lock guard.
+ */
+
+#ifndef BOOST_SYNC_LOCKS_UNIQUE_LOCK_FWD_HPP_INCLUDED_
+#define BOOST_SYNC_LOCKS_UNIQUE_LOCK_FWD_HPP_INCLUDED_
+
+#include <boost/sync/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#include <boost/sync/detail/header.hpp>
+
+namespace boost {
+
+namespace sync {
+
+/*!
+ * \brief A unique lock scope guard
+ */
+template< typename Mutex >
+class unique_lock;
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_LOCKS_UNIQUE_LOCK_FWD_HPP_INCLUDED_
Added: trunk/boost/sync/locks/upgrade_lock_fwd.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/locks/upgrade_lock_fwd.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * (C) Copyright 2011-2012 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file locks/upgrade_lock_fwd.hpp
+ *
+ * \brief This header declares an upgrade lock guard.
+ */
+
+#ifndef BOOST_SYNC_LOCKS_UPGRADE_LOCK_FWD_HPP_INCLUDED_
+#define BOOST_SYNC_LOCKS_UPGRADE_LOCK_FWD_HPP_INCLUDED_
+
+#include <boost/sync/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#include <boost/sync/detail/header.hpp>
+
+namespace boost {
+
+namespace sync {
+
+/*!
+ * \brief A unique lock scope guard
+ */
+template< typename Mutex >
+class upgrade_lock;
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_LOCKS_UPGRADE_LOCK_FWD_HPP_INCLUDED_
Added: trunk/boost/sync/support/date_time.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/support/date_time.hpp 2013-09-08 13:11:07 EDT (Sun, 08 Sep 2013) (r85607)
@@ -0,0 +1,87 @@
+/*
+ * Copyright Andrey Semashev 2013.
+ * 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)
+ */
+/*!
+ * \file support/date_time.hpp
+ *
+ * \brief This header enables support for Boost.DateTime time units.
+ */
+
+#ifndef BOOST_SYNC_SUPPORT_DATE_TIME_HPP_INCLUDED_
+#define BOOST_SYNC_SUPPORT_DATE_TIME_HPP_INCLUDED_
+
+#include <ctime>
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/sync/detail/config.hpp>
+#include <boost/sync/detail/time_traits.hpp>
+#include <boost/sync/detail/time_units.hpp>
+#include <boost/sync/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+template< typename T >
+struct time_traits< T, typename T::_is_boost_date_time_duration >
+{
+ typedef duration_tag tag;
+
+ static BOOST_CONSTEXPR_OR_CONST bool is_specialized = true;
+
+ static duration to_sync_unit(T const& dur)
+ {
+ typedef typename T::traits_type traits_type;
+ enum
+ {
+ conversion_ratio = traits_type::ticks_per_second >= duration::subsecond_fraction ?
+ traits_type::ticks_per_second / duration::subsecond_fraction :
+ duration::subsecond_fraction / traits_type::ticks_per_second
+ };
+ return duration(traits_type::ticks_per_second >= duration::subsecond_fraction ? dur.ticks() / conversion_ratio : dur.ticks() * conversion_ratio);
+ }
+};
+
+template< typename T >
+struct time_traits< T, typename T::_is_boost_date_time_time_point >
+{
+ typedef time_point_tag tag;
+
+ static BOOST_CONSTEXPR_OR_CONST bool is_specialized = true;
+
+ static time_point to_sync_unit(T const& point)
+ {
+ typedef typename T::date_type date_type;
+ typedef typename T::time_duration_type time_duration_type;
+ time_duration_type dur = point - T(date_type(1970, 1, 1));
+
+ std::time_t seconds = dur.total_seconds();
+ uint64_t fractional_seconds = dur.fractional_seconds();
+
+ typedef typename time_duration_type::traits_type traits_type;
+ enum
+ {
+ conversion_ratio = traits_type::ticks_per_second >= time_point::subsecond_fraction ?
+ traits_type::ticks_per_second / time_point::subsecond_fraction :
+ time_point::subsecond_fraction / traits_type::ticks_per_second
+ };
+ return time_point(seconds, traits_type::ticks_per_second >= time_point::subsecond_fraction ? fractional_seconds / conversion_ratio : fractional_seconds * conversion_ratio);
+ }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_SUPPORT_DATE_TIME_HPP_INCLUDED_