[Boost-commit] svn:boost r81087 - in trunk: boost/thread libs/thread/example

Subject: [Boost-commit] svn:boost r81087 - in trunk: boost/thread libs/thread/example
From: vicente.botet_at_[hidden]
Date: 2012-10-28 21:09:59

Author: viboes
Date: 2012-10-28 21:09:58 EDT (Sun, 28 Oct 2012)
New Revision: 81087
URL: http://svn.boost.org/trac/boost/changeset/81087

Log:
Thread: Added externally_locked
Added:
   trunk/boost/thread/externally_locked.hpp   (contents, props changed)
   trunk/libs/thread/example/ba_externallly_locked.cpp   (contents, props changed)

Added: trunk/boost/thread/externally_locked.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/thread/externally_locked.hpp	2012-10-28 21:09:58 EDT (Sun, 28 Oct 2012)
@@ -0,0 +1,320 @@
+// (C) Copyright 2012 Vicente J. Botet Escriba
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_HPP
+#define BOOST_THREAD_EXTERNALLY_LOCKED_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/lock_concepts.hpp>
+#include <boost/thread/lock_traits.hpp>
+#include <boost/thread/lockable_concepts.hpp>
+#include <boost/thread/strict_lock.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/utility/swap.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+
+  /**
+   * externally_locked cloaks an object of type T, and actually provides full
+   * access to that object through the get and set member functions, provided you
+   * pass a reference to a strict lock object
+   */
+
+  //[externally_locked
+  template <typename T, typename MutexType = boost::mutex>
+  class externally_locked
+  {
+    //BOOST_CONCEPT_ASSERT(( CopyConstructible<T> ));
+    BOOST_CONCEPT_ASSERT(( BasicLockable<MutexType> ));
+
+  public:
+    typedef MutexType mutex_type;
+
+    BOOST_THREAD_COPYABLE_AND_MOVABLE( externally_locked )
+    /**
+     * Requires: T is a model of CopyConstructible.
+     * Effects: Constructs an externally locked object copying the cloaked type.
+     */
+    BOOST_CONSTEXPR externally_locked(mutex_type& mtx, const T& obj) :
+      obj_(obj), mtx_(&mtx)
+    {
+    }
+
+    /**
+     * Requires: T is a model of Movable.
+     * Effects: Constructs an externally locked object copying the cloaked type.
+     */
+    BOOST_CONSTEXPR externally_locked(mutex_type& mtx, BOOST_THREAD_RV_REF(T) obj) :
+      obj_(move(obj)), mtx_(&mtx)
+    {
+    }
+
+    /**
+     * Requires: T is a model of DefaultConstructible.
+     * Effects: Constructs an externally locked object initializing the cloaked type with the default constructor.
+     */
+    externally_locked(mutex_type& mtx) :
+      obj_(), mtx_(&mtx)
+    {
+    }
+
+    /**
+     *  Move constructor
+     */
+    externally_locked(BOOST_THREAD_RV_REF(externally_locked) rhs) :
+    obj_(move(rhs.obj_)), mtx_(rhs.mtx_)
+    {
+      rhs.mtx_=0;
+    }
+
+    /**
+     * Requires: The lk parameter must be locking the associated mtx.
+     *
+     * Returns: The address of the cloaked object..
+     *
+     * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+     */
+    T& get(strict_lock<mutex_type>& lk)
+    {
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (lk.mutex()!=mtx_) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return obj_;
+    }
+
+    const T& get(strict_lock<mutex_type>& lk) const
+    {
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (lk.mutex()!=mtx_) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return obj_;
+    }
+
+    template <class Lock>
+    T& get(nested_strict_lock<Lock>& lk)
+    {
+      BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (lk.mutex()!=mtx_) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return obj_;
+    }
+
+    template <class Lock>
+    const T& get(nested_strict_lock<Lock>& lk) const
+    {
+      BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (lk.mutex()!=mtx_) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return obj_;
+    }
+
+    /**
+     * Requires: The lk parameter must be locking the associated mtx.
+     * Returns: The address of the cloaked object..
+     *
+     * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+     */
+    template <class Lock>
+    T& get(Lock& lk)
+    {
+      BOOST_CONCEPT_ASSERT(( StrictLock<Lock> ));
+      BOOST_STATIC_ASSERT( (is_strict_lock<Lock>::value)); /*< lk is a strict lock "sur parolle" >*/
+      BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_OWNERSHIP  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_NO_CHECK_OWNERSHIP if you don't want to check lock ownership >*/
+      if (!lk.own_lock()) throw lock_error(); /*< run time check throw if no locked >*/
+#endif
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME
+      if (lk.mutex()!=mtx_) throw lock_error();
+#endif
+      return obj_;
+    }
+
+    mutex_type* mutex()
+    {
+      return mtx_;
+    }
+
+    // modifiers
+
+    void lock()
+    {
+      mtx_->lock();
+    }
+    void unlock()
+    {
+      mtx_->unlock();
+    }
+    bool try_lock()
+    {
+      return mtx_->try_lock();
+    }
+    // todo add time related functions
+
+  private:
+    T obj_;
+    mutex_type* mtx_;
+  };
+  //]
+
+  /**
+   * externally_locked<T&,M> specialization for T& that cloaks an reference to an object of type T, and actually
+   * provides full access to that object through the get and set member functions, provided you
+   * pass a reference to a strict lock object.
+   */
+
+  //[externally_locked_ref
+  template <typename T, typename MutexType>
+  class externally_locked<T&, MutexType>
+  {
+    //BOOST_CONCEPT_ASSERT(( CopyConstructible<T> ));
+    BOOST_CONCEPT_ASSERT(( BasicLockable<MutexType> ));
+
+  public:
+    typedef MutexType mutex_type;
+
+    BOOST_THREAD_MOVABLE_ONLY( externally_locked )
+
+    /**
+     * Effects: Constructs an externally locked object storing the cloaked reference object.
+     */
+    externally_locked(T& obj, mutex_type& mtx) :
+      obj_(&obj), mtx_(&mtx)
+    {
+    }
+
+    /// move constructor
+    externally_locked(BOOST_THREAD_RV_REF(externally_locked) rhs) :
+    obj_(rhs.obj_), mtx_(rhs.mtx_)
+    {
+      rhs.obj_=0;
+      rhs.mtx_=0;
+    }
+
+    void swap(externally_locked& rhs)
+    {
+      swap(obj_, rhs.obj_);
+      swap(mtx_, rhs.mtx_);
+    }
+    /**
+     * Requires: The lk parameter must be locking the associated mtx.
+     *
+     * Returns: The address of the cloaked object..
+     *
+     * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+     */
+    T& get(strict_lock<mutex_type>& lk)
+    {
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (lk.mutex()!=mtx_) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return *obj_;
+    }
+
+    const T& get(strict_lock<mutex_type>& lk) const
+    {
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (lk.mutex()!=mtx_) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return *obj_;
+    }
+
+    template <class Lock>
+    T& get(nested_strict_lock<Lock>& lk)
+    {
+      BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (lk.mutex()!=mtx_) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return *obj_;
+    }
+
+    template <class Lock>
+    const T& get(nested_strict_lock<Lock>& lk) const
+    {
+      BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check lk check the same mtx >*/
+      if (!lk.is_locking(&mtx_)) throw lock_error(); /*< run time check throw if not locks the same >*/
+#endif
+      return *obj_;
+    }
+
+    /**
+     * Requires: The lk parameter must be locking the associated mtx.
+     * Returns: The address of the cloaked object..
+     *
+     * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+     */
+    template <class Lock>
+    T& get(Lock& lk)
+    {
+      BOOST_CONCEPT_ASSERT(( StrictLock<Lock> ));
+      BOOST_STATIC_ASSERT( (is_strict_lock<Lock>::value)); /*< lk is a strict lock "sur parolle" >*/
+      BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
+
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_OWNERSHIP  /*< define BOOST_THREAD_EXTERNALLY_LOCKED_NO_CHECK_OWNERSHIP if you don't want to check lock ownership >*/
+      if (!lk.own_lock()) throw lock_error(); /*< run time check throw if no locked >*/
+#endif
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME
+      if (lk.mutex()!=mtx_) throw lock_error();
+#endif
+      return *obj_;
+    }
+
+    mutex_type* mutex()
+    {
+      return mtx_;
+    }
+
+    void lock()
+    {
+      mtx_->lock();
+    }
+    void unlock()
+    {
+      mtx_->unlock();
+    }
+    bool try_lock()
+    {
+      return mtx_->try_lock();
+    }
+    // todo add time related functions
+
+  protected:
+    T* obj_;
+    mutex_type* mtx_;
+  };
+  //]
+
+  template <typename T, typename MutexType>
+  void swap(externally_locked<T, MutexType> & lhs, externally_locked<T, MutexType> & rhs)
+  {
+    lhs.swap(rhs);
+  }
+
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif // header

Added: trunk/libs/thread/example/ba_externallly_locked.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/example/ba_externallly_locked.cpp	2012-10-28 21:09:58 EDT (Sun, 28 Oct 2012)
@@ -0,0 +1,115 @@
+// Copyright (C) 2012 Vicente Botet
+//
+//  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)
+
+#define BOOST_THREAD_VERSION 4
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/externally_locked.hpp>
+#include <boost/thread/strict_lock.hpp>
+#include <boost/thread/lock_types.hpp>
+#include <iostream>
+
+using namespace boost;
+
+class BankAccount
+{
+  int balance_;
+public:
+  void Deposit(int amount)
+  {
+    balance_ += amount;
+  }
+  void Withdraw(int amount)
+  {
+    balance_ -= amount;
+  }
+  int GetBalance()
+  {
+    return balance_;
+  }
+};
+
+//[AccountManager
+class AccountManager
+{
+  mutex mtx_;
+public:
+  AccountManager() :
+    checkingAcct_(mtx_), savingsAcct_(mtx_)
+  {
+  }
+  inline void Checking2Savings(int amount);
+  inline void AMoreComplicatedChecking2Savings(int amount);
+private:
+  /*<-*/
+  bool some_condition()
+  {
+    return true;
+  } /*->*/
+  externally_locked<BankAccount, mutex > checkingAcct_;
+  externally_locked<BankAccount, mutex > savingsAcct_;
+};
+//]
+
+//[Checking2Savings
+void AccountManager::Checking2Savings(int amount)
+{
+  strict_lock<mutex> guard(mtx_);
+  checkingAcct_.get(guard).Withdraw(amount);
+  savingsAcct_.get(guard).Deposit(amount);
+}
+//]
+
+#if MUST_NOT_COMPILE
+//[AMoreComplicatedChecking2Savings_DO_NOT_COMPILE
+void AccountManager::AMoreComplicatedChecking2Savings(int amount) {
+    unique_lock<mutex> guard(mtx_);
+    if (some_condition()) {
+        guard.lock();
+    }
+    checkingAcct_.get(guard).Withdraw(amount);
+    savingsAcct_.get(guard).Deposit(amount);
+    guard1.unlock();
+}
+//]
+#elif MUST_NOT_COMPILE_2
+//[AMoreComplicatedChecking2Savings_DO_NOT_COMPILE2
+void AccountManager::AMoreComplicatedChecking2Savings(int amount) {
+    unique_lock<mutex> guard1(mtx_);
+    if (some_condition()) {
+        guard1.lock();
+    }
+    {
+        strict_lock<mutex> guard(guard1);
+        checkingAcct_.get(guard).Withdraw(amount);
+        savingsAcct_.get(guard).Deposit(amount);
+    }
+    guard1.unlock();
+}
+]
+#else
+//[AMoreComplicatedChecking2Savings
+void AccountManager::AMoreComplicatedChecking2Savings(int amount) {
+    unique_lock<mutex> guard1(mtx_);
+    if (some_condition()) {
+        guard1.lock();
+    }
+    {
+        nested_strict_lock<unique_lock<mutex> > guard(guard1);
+        checkingAcct_.get(guard).Withdraw(amount);
+        savingsAcct_.get(guard).Deposit(amount);
+    }
+    guard1.unlock();
+}
+//]
+#endif
+
+int main()
+{
+  AccountManager mgr;
+  mgr.Checking2Savings(100);
+  return 0;
+}
+