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

Subject: [Boost-commit] svn:boost r83086 - in trunk: boost/thread libs/thread/example
From: vicente.botet_at_[hidden]
Date: 2013-02-22 12:42:45

Author: viboes
Date: 2013-02-22 12:42:44 EST (Fri, 22 Feb 2013)
New Revision: 83086
URL: http://svn.boost.org/trac/boost/changeset/83086

Log:
Thread: Added value semantics to synchronized value
Text files modified: 
   trunk/boost/thread/synchronized_value.hpp        |   155 +++++++++++++++++++++++++++++++++++++++ 
   trunk/libs/thread/example/synchronized_value.cpp |    78 ++++++++++++++++++--                    
   2 files changed, 224 insertions(+), 9 deletions(-)

Modified: trunk/boost/thread/synchronized_value.hpp
==============================================================================
--- trunk/boost/thread/synchronized_value.hpp	(original)
+++ trunk/boost/thread/synchronized_value.hpp	2013-02-22 12:42:44 EST (Fri, 22 Feb 2013)
@@ -225,6 +225,7 @@
     T value_;
     mutable lockable_type mtx_;
   public:
+    // construction/destruction
     /**
      * Default constructor.
      *
@@ -277,6 +278,7 @@
       value_= boost::move(other.value);
     }
 
+    // mutation
     /**
      * Assignment operator.
      *
@@ -314,6 +316,7 @@
       return *this;
     }
 
+    //observers
     /**
      * Explicit conversion to value type.
      *
@@ -339,7 +342,6 @@
       return get();
     }
 #endif
-
     /**
      * Swap
      *
@@ -497,8 +499,99 @@
       return BOOST_THREAD_MAKE_RV_REF(const_deref_value(*this));
     }
 
+    template <typename OStream>
+    void save(OStream& os) const
+    {
+      strict_lock<lockable_type> lk(mtx_);
+      os << value_;
+    }
+    template <typename IStream>
+    void load(IStream& is) const
+    {
+      strict_lock<lockable_type> lk(mtx_);
+      is >> value_;
+    }
+
+    bool operator==(synchronized_value const& rhs)  const
+    {
+      unique_lock<lockable_type> lk1(mtx_, defer_lock);
+      unique_lock<lockable_type> lk2(rhs.mtx_, defer_lock);
+      lock(lk1,lk2);
+
+      return value_ == rhs.value_;
+    }
+    bool operator<(synchronized_value const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_, defer_lock);
+      unique_lock<lockable_type> lk2(rhs.mtx_, defer_lock);
+      lock(lk1,lk2);
+
+      return value_ < rhs.value_;
+    }
+    bool operator>(synchronized_value const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_, defer_lock);
+      unique_lock<lockable_type> lk2(rhs.mtx_, defer_lock);
+      lock(lk1,lk2);
+
+      return value_ > rhs.value_;
+    }
+    bool operator<=(synchronized_value const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_, defer_lock);
+      unique_lock<lockable_type> lk2(rhs.mtx_, defer_lock);
+      lock(lk1,lk2);
+
+      return value_ <= rhs.value_;
+    }
+    bool operator>=(synchronized_value const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_, defer_lock);
+      unique_lock<lockable_type> lk2(rhs.mtx_, defer_lock);
+      lock(lk1,lk2);
+
+      return value_ >= rhs.value_;
+    }
+    bool operator==(value_type const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_);
+
+      return value_ == rhs;
+    }
+    bool operator!=(value_type const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_);
+
+      return value_ != rhs;
+    }
+    bool operator<(value_type const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_);
+
+      return value_ < rhs;
+    }
+    bool operator<=(value_type const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_);
+
+      return value_ <= rhs;
+    }
+    bool operator>(value_type const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_);
+
+      return value_ > rhs;
+    }
+    bool operator>=(value_type const& rhs) const
+    {
+      unique_lock<lockable_type> lk1(mtx_);
+
+      return value_ >= rhs;
+    }
+
   };
 
+  // Specialized algorithms
   /**
    *
    */
@@ -508,6 +601,66 @@
     lhs.swap(rhs);
   }
 
+  //Hash support
+
+  template <class T> struct hash;
+  template <typename T, typename L>
+  struct hash<synchronized_value<T,L> >;
+
+  // Comparison with T
+  template <typename T, typename L>
+  bool operator!=(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs)
+  {
+    return ! (lhs==rhs);
+  }
+
+  template <typename T, typename L>
+  bool operator==(T const& lhs, synchronized_value<T,L> const&rhs)
+  {
+    return rhs==lhs;
+  }
+  template <typename T, typename L>
+  bool operator!=(T const& lhs, synchronized_value<T,L> const&rhs)
+  {
+    return rhs!=lhs;
+  }
+  template <typename T, typename L>
+  bool operator<(T const& lhs, synchronized_value<T,L> const&rhs)
+  {
+    return rhs>=lhs;
+  }
+  template <typename T, typename L>
+  bool operator<=(T const& lhs, synchronized_value<T,L> const&rhs)
+  {
+    return rhs>lhs;
+  }
+  template <typename T, typename L>
+  bool operator>(T const& lhs, synchronized_value<T,L> const&rhs)
+  {
+    return rhs<=lhs;
+  }
+  template <typename T, typename L>
+  bool operator>=(T const& lhs, synchronized_value<T,L> const&rhs)
+  {
+    return rhs<lhs;
+  }
+
+  /**
+   *
+   */
+  template <typename OStream, typename T, typename L>
+  inline OStream& operator<<(OStream& os, synchronized_value<T,L> const& rhs)
+  {
+    rhs.save(os);
+    return os;
+  }
+  template <typename IStream, typename T, typename L>
+  inline IStream& operator>>(IStream& is, synchronized_value<T,L> const& rhs)
+  {
+    rhs.load(is);
+    return is;
+  }
+
 }
 
 #include <boost/config/abi_suffix.hpp>

Modified: trunk/libs/thread/example/synchronized_value.cpp
==============================================================================
--- trunk/libs/thread/example/synchronized_value.cpp	(original)
+++ trunk/libs/thread/example/synchronized_value.cpp	2013-02-22 12:42:44 EST (Fri, 22 Feb 2013)
@@ -10,15 +10,15 @@
 #include <string>
 #include <boost/thread/synchronized_value.hpp>
 
-void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
-{
-  boost::strict_lock_ptr<std::string> u=path.synchronize();
-
-  if(u->empty() || (*u->rbegin()!='/'))
+  void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
   {
-    *u+='/';
+    boost::strict_lock_ptr<std::string> u=path.synchronize();
+
+    if(u->empty() || (*u->rbegin()!='/'))
+    {
+      *u+='/';
+    }
   }
-}
 
 void f(const boost::synchronized_value<int> &v) {
   std::cout<<"v="<<*v<<std::endl;
@@ -80,6 +80,68 @@
     addTrailingSlashIfMissing(s);
     std::cout<<"s="<<std::string(*s)<<std::endl;
   }
-  return 0;
+  {
+    boost::synchronized_value<std::string> s;
+    s = std::string("foo/");
+    std::cout<<"ss="<< s << std::endl;
+  }
+  {
+    boost::synchronized_value<std::string> s;
+    s = "foo/";
+    std::cout<<"ss="<< s << std::endl;
+  }
+  {
+    boost::synchronized_value<std::string> s1("a");
+    boost::synchronized_value<std::string> s2;
+    s2=s1;
+    std::cout<<"s1="<< s1 << std::endl;
+    std::cout<<"s2="<< s2 << std::endl;
+  }
+  {
+    boost::synchronized_value<std::string> s1("a");
+    boost::synchronized_value<std::string> s2("b");
+    std::cout<<"s1="<< s1 << std::endl;
+    std::cout<<"s2="<< s2 << std::endl;
+    swap(s1,s2);
+    std::cout<<"s1="<< s1 << std::endl;
+    std::cout<<"s2="<< s2 << std::endl;
+  }
+#if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+  {
+    boost::synchronized_value<std::string> sts("a");
+    std::string s(sts);
+    std::cout<<"ssts="<< s << std::endl;
+  }
+#endif
+  {
+    boost::synchronized_value<int> s1(1);
+    boost::synchronized_value<int> s2(1);
+    BOOST_ASSERT(s1==s2);
+    BOOST_ASSERT(s1<=s2);
+    BOOST_ASSERT(s1>=s2);
+    BOOST_ASSERT(s1==1);
+    BOOST_ASSERT(s1<=1);
+    BOOST_ASSERT(s1>=1);
+  }
+  {
+    boost::synchronized_value<int> s1(1);
+    boost::synchronized_value<int> s2(2);
+    BOOST_ASSERT(s1!=s2);
+    BOOST_ASSERT(s1!=2);
+    BOOST_ASSERT(2!=s1);
+  }
+  {
+    boost::synchronized_value<int> s1(1);
+    boost::synchronized_value<int> s2(2);
+    BOOST_ASSERT(s1<s2);
+    BOOST_ASSERT(s1<=s2);
+    BOOST_ASSERT(s2>s1);
+    BOOST_ASSERT(s2>=s1);
+    BOOST_ASSERT(s1<2);
+    BOOST_ASSERT(s1<=2);
+    BOOST_ASSERT(s2>1);
+    BOOST_ASSERT(s2>=1);
+  }
+  return 1;
 }