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

Subject: [Boost-commit] svn:boost r81644 - in trunk: boost/thread libs/thread/example
From: vicente.botet_at_[hidden]
Date: 2012-12-01 06:02:18

Author: viboes
Date: 2012-12-01 06:02:16 EST (Sat, 01 Dec 2012)
New Revision: 81644
URL: http://svn.boost.org/trac/boost/changeset/81644

Log:
Thread: Added const_strict_synchronizer.
Added:
   trunk/libs/thread/example/synchronized_person.cpp   (contents, props changed)
Text files modified: 
   trunk/boost/thread/synchronized_value.hpp        |    74 ++++++++++++++++++++++++++++++++------- 
   trunk/libs/thread/example/synchronized_value.cpp |     2                                         
   2 files changed, 61 insertions(+), 15 deletions(-)

Modified: trunk/boost/thread/synchronized_value.hpp
==============================================================================
--- trunk/boost/thread/synchronized_value.hpp	(original)
+++ trunk/boost/thread/synchronized_value.hpp	2012-12-01 06:02:16 EST (Sat, 01 Dec 2012)
@@ -13,6 +13,7 @@
 
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/lock_types.hpp>
+#include <boost/thread/lock_guard.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -31,64 +32,109 @@
     T value_;
     mutable lockable_type mtx_;
   public:
+    synchronized_value()
+    : value_()
+    {
+    }
+
+    synchronized_value(T other)
+    : value_(other)
+    {
+    }
+
     /**
      *
      */
-    struct strict_synchronizer
+    struct const_strict_synchronizer
     {
-    private:
+    protected:
       friend class synchronized_value;
 
       boost::unique_lock<lockable_type> lk_;
-      T& value_;
+      T const& value_;
 
-      explicit strict_synchronizer(synchronized_value& outer) :
+      explicit const_strict_synchronizer(synchronized_value const& outer) :
         lk_(outer.mtx_), value_(outer.value_)
       {
       }
     public:
-      BOOST_THREAD_NO_COPYABLE( strict_synchronizer )
+      BOOST_THREAD_NO_COPYABLE( const_strict_synchronizer )
 
-      strict_synchronizer(strict_synchronizer&& other)
+      const_strict_synchronizer(const_strict_synchronizer&& other)
       : lk_(boost::move(other.lk_)),value_(other.value_)
       {
       }
 
-      ~strict_synchronizer()
+      ~const_strict_synchronizer()
       {
       }
 
-      T* operator->()
+      const T* operator->() const
       {
         return &value_;
       }
 
-      const T* operator->() const
+      const T& operator*() const
       {
-        return &value_;
+        return value_;
       }
 
-      T& operator*()
+    };
+
+    /**
+     *
+     */
+    struct strict_synchronizer : const_strict_synchronizer
+    {
+    protected:
+      friend class synchronized_value;
+
+      explicit strict_synchronizer(synchronized_value& outer) :
+        const_strict_synchronizer(const_cast<synchronized_value&>(outer))
       {
-        return value_;
       }
+    public:
+      BOOST_THREAD_NO_COPYABLE( strict_synchronizer )
 
-      const T& operator*() const
+      strict_synchronizer(strict_synchronizer&& other)
+      : const_strict_synchronizer(boost::move(other))
+      {
+      }
+
+      ~strict_synchronizer()
       {
-        return value_;
+      }
+
+      T* operator->()
+      {
+        return const_cast<T*>(&this->value_);
+      }
+
+      T& operator*()
+      {
+        return const_cast<T&>(this->value_);
       }
 
     };
 
+
     strict_synchronizer operator->()
     {
       return BOOST_THREAD_MAKE_RV_REF(strict_synchronizer(*this));
     }
+    const_strict_synchronizer operator->() const
+    {
+      return BOOST_THREAD_MAKE_RV_REF(const_strict_synchronizer(*this));
+    }
 
     strict_synchronizer synchronize()
     {
       return BOOST_THREAD_MAKE_RV_REF(strict_synchronizer(*this));
     }
+    const_strict_synchronizer synchronize() const
+    {
+      return BOOST_THREAD_MAKE_RV_REF(const_strict_synchronizer(*this));
+    }
 
     /**
      *

Added: trunk/libs/thread/example/synchronized_person.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/example/synchronized_person.cpp	2012-12-01 06:02:16 EST (Sat, 01 Dec 2012)
@@ -0,0 +1,246 @@
+// (C) Copyright 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
+
+// There is yet a limitation when BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET is defined
+#define BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET
+
+#include <iostream>
+#include <string>
+#include <boost/thread/synchronized_value.hpp>
+
+#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES && ! defined BOOST_NO_CXX11_AUTO
+
+
+//class SafePerson {
+//public:
+//  std::string GetName() const {
+//    const_unique_access<std::string> name(nameGuard);
+//    return *name;
+//  }
+//  void SetName(const std::string& newName)  {
+//    unique_access<std::string> name(nameGuard);
+//    *name = newName;
+//  }
+//private:
+//  unique_access_guard<std::string> nameGuard;
+//};
+
+class SafePerson {
+public:
+  std::string GetName() const {
+    return *name;
+  }
+  void SetName(const std::string& newName)  {
+    *name = newName;
+  }
+
+private:
+  boost::synchronized_value<std::string> name;
+};
+
+class Person {
+public:
+  std::string GetName() const {
+    return name;
+  }
+  void SetName(const std::string& newName) {
+    name = newName;
+  }
+private:
+  std::string name;
+};
+typedef boost::synchronized_value<Person> Person_ts;
+
+
+//class SafeMemberPerson {
+//public:
+//  SafeMemberPerson(unsigned int age) :
+//    memberGuard(age)
+//  {  }
+//  std::string GetName() const  {
+//    const_unique_access<Member> member(memberGuard);
+//    return member->name;
+//  }
+//  void SetName(const std::string& newName)  {
+//    unique_access<Member> member(memberGuard);
+//    member->name = newName;
+//  }
+//private:
+//  struct Member
+//  {
+//    Member(unsigned int age) :
+//      age(age)
+//    {    }
+//    std::string name;
+//    unsigned int age;
+//  };
+//  unique_access_guard<Member> memberGuard;
+//};
+
+class SafeMemberPerson {
+public:
+  SafeMemberPerson(unsigned int age) :
+    member(Member(age))
+  {  }
+  std::string GetName() const  {
+    return member->name;
+  }
+  void SetName(const std::string& newName)  {
+    member->name = newName;
+  }
+private:
+  struct Member  {
+    Member(unsigned int age) :
+      age(age)
+    {    }
+    std::string name;
+    unsigned int age;
+  };
+  boost::synchronized_value<Member> member;
+};
+
+
+class Person2 {
+public:
+  Person2(unsigned int age) : age_(age)
+  {}
+  std::string GetName() const  {
+    return name_;
+  }
+  void SetName(const std::string& newName)  {
+    name_ = newName;
+  }
+  unsigned int GetAge() const  {
+    return age_;
+  }
+
+private:
+  std::string name_;
+  unsigned int age_;
+};
+typedef boost::synchronized_value<Person2> Person2_ts;
+
+//===================
+
+//class HelperPerson {
+//public:
+//  HelperPerson(unsigned int age) :
+//    memberGuard(age)
+//  {  }
+//  std::string GetName() const  {
+//    const_unique_access<Member> member(memberGuard);
+//    Invariant(member);
+//    return member->name;
+//  }
+//  void SetName(const std::string& newName)  {
+//    unique_access<Member> member(memberGuard);
+//    Invariant(member);
+//    member->name = newName;
+//  }
+//private:
+//  void Invariant(const_unique_access<Member>& member) const  {
+//    if (member->age < 0) throw std::runtime_error("Age cannot be negative");
+//  }
+//  struct Member  {
+//    Member(unsigned int age) :
+//      age(age)
+//    {    }
+//    std::string name;
+//    unsigned int age;
+//  };
+//  unique_access_guard<Member> memberGuard;
+//};
+
+class HelperPerson {
+public:
+  HelperPerson(unsigned int age) :
+    member(age)
+  {  }
+  std::string GetName() const  {
+    auto&& memberSync = member.synchronize();
+    Invariant(memberSync);
+    return memberSync->name;
+  }
+  void SetName(const std::string& newName)  {
+    auto&& memberSync = member.synchronize();
+    Invariant(memberSync);
+    memberSync->name = newName;
+  }
+private:
+  struct Member  {
+    Member(unsigned int age) :
+      age(age)
+    {    }
+    std::string name;
+    unsigned int age;
+  };
+  void Invariant(boost::synchronized_value<Member>::const_strict_synchronizer & mbr) const
+  {
+    if (mbr->age < 1) throw std::runtime_error("Age cannot be negative");
+  }
+  boost::synchronized_value<Member> member;
+};
+
+class Person3 {
+public:
+  Person3(unsigned int age) :
+    age_(age)
+  {  }
+  std::string GetName() const  {
+    Invariant();
+    return name_;
+  }
+  void SetName(const std::string& newName)  {
+    Invariant();
+    name_ = newName;
+  }
+private:
+  std::string name_;
+  unsigned int age_;
+  void Invariant() const  {
+    if (age_ < 1) throw std::runtime_error("Age cannot be negative");
+  }
+};
+
+typedef boost::synchronized_value<Person3> Person3_ts;
+
+int main()
+{
+  {
+    SafePerson p;
+    p.SetName("Vicente");
+  }
+  {
+    Person_ts p;
+    p->SetName("Vicente");
+  }
+  {
+    SafeMemberPerson p(1);
+    p.SetName("Vicente");
+  }
+  {
+    Person2_ts p(1);
+    p->SetName("Vicente");
+  }
+  {
+    HelperPerson p(1);
+    p.SetName("Vicente");
+  }
+  {
+    Person3_ts p(1);
+    p->SetName("Vicente");
+  }
+  return 0;
+}
+
+#else
+
+int main()
+{
+  return 0;
+}
+#endif

Modified: trunk/libs/thread/example/synchronized_value.cpp
==============================================================================
--- trunk/libs/thread/example/synchronized_value.cpp	(original)
+++ trunk/libs/thread/example/synchronized_value.cpp	2012-12-01 06:02:16 EST (Sat, 01 Dec 2012)
@@ -29,7 +29,7 @@
   std::cout<<"v="<<*v<<std::endl;
 }
 
-void g(const boost::synchronized_value<int>::strict_synchronizer &v) {
+void g(const boost::synchronized_value<int>::const_strict_synchronizer &v) {
   std::cout<<"v="<<*v<<std::endl;
 }