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

Subject: [Boost-commit] svn:boost r81072 - in trunk: boost/thread libs/thread/example
From: vicente.botet_at_[hidden]
Date: 2012-10-28 13:43:41

Author: viboes
Date: 2012-10-28 13:43:40 EDT (Sun, 28 Oct 2012)
New Revision: 81072
URL: http://svn.boost.org/trac/boost/changeset/81072

Log:
Thread: added first version of synchronized_value
Added:
   trunk/boost/thread/synchronized_value.hpp   (contents, props changed)
   trunk/libs/thread/example/synchronized_value.cpp   (contents, props changed)

Added: trunk/boost/thread/synchronized_value.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/thread/synchronized_value.hpp	2012-10-28 13:43:40 EDT (Sun, 28 Oct 2012)
@@ -0,0 +1,221 @@
+// (C) Copyright 2010 Just Software Solutions Ltd http://www.justsoftwaresolutions.co.uk
+// (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_SYNCHRONIZED_VALUE_HPP
+#define BOOST_THREAD_SYNCHRONIZED_VALUE_HPP
+
+#include <boost/thread/detail/config.hpp>
+#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/lock_types.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+  /**
+   *
+   */
+  template <typename T, typename Lockable = mutex>
+  class synchronized_value
+  {
+  public:
+    typedef T value_type;
+    typedef Lockable lockable_type;
+  private:
+    T value_;
+    mutable lockable_type mtx_;
+  public:
+    /**
+     *
+     */
+    struct strict_synchronizer
+    {
+    private:
+      friend class synchronized_value;
+
+      boost::unique_lock<lockable_type> lk_;
+      T& value_;
+
+      explicit strict_synchronizer(synchronized_value& outer) :
+        lk_(outer.mtx_), value_(outer.value_)
+      {
+      }
+    public:
+      BOOST_THREAD_NO_COPYABLE( strict_synchronizer )
+
+      strict_synchronizer(strict_synchronizer&& other)
+      : lk_(boost::move(other.lk_)),value_(other.value_)
+      {
+      }
+
+      ~strict_synchronizer()
+      {
+      }
+
+      T* operator->()
+      {
+        return &value_;
+      }
+
+      const T* operator->() const
+      {
+        return &value_;
+      }
+
+      T& operator*()
+      {
+        return value_;
+      }
+
+      const T& operator*() const
+      {
+        return value_;
+      }
+
+    };
+
+    strict_synchronizer operator->()
+    {
+      return BOOST_THREAD_MAKE_RV_REF(strict_synchronizer(*this));
+    }
+
+    strict_synchronizer synchronize()
+    {
+      return BOOST_THREAD_MAKE_RV_REF(strict_synchronizer(*this));
+    }
+
+    /**
+     *
+     */
+    struct unique_synchronizer : unique_lock<lockable_type>
+    {
+    private:
+      friend class synchronized_value;
+      typedef unique_lock<lockable_type> base_type;
+
+      T& value_;
+
+      explicit unique_synchronizer(synchronized_value& outer)
+      : base_type(outer.mtx_), value_(outer.value_)
+      {
+      }
+    public:
+      BOOST_THREAD_NO_COPYABLE(unique_synchronizer)
+
+      unique_synchronizer(unique_synchronizer&& other):
+      base_type(static_cast<base_type&&>(other)),value_(other.value_)
+      {
+      }
+
+      ~unique_synchronizer()
+      {
+      }
+
+      T* operator->()
+      {
+        if (this->owns_lock())
+        return &value_;
+        else
+        return 0;
+      }
+
+      const T* operator->() const
+      {
+        if (this->owns_lock())
+        return &value_;
+        else
+        return 0;
+      }
+
+      T& operator*()
+      {
+        BOOST_ASSERT (this->owns_lock());
+        return value_;
+      }
+
+      const T& operator*() const
+      {
+        BOOST_ASSERT (this->owns_lock());
+        return value_;
+      }
+
+    };
+
+  private:
+    class deref_value
+    {
+    private:
+      friend class synchronized_value;
+
+      boost::unique_lock<lockable_type> lk_;
+      T& value_;
+
+      explicit deref_value(synchronized_value& outer):
+      lk_(outer.mtx_),value_(outer.value_)
+      {}
+
+    public:
+      BOOST_THREAD_NO_COPYABLE(deref_value)
+      deref_value(deref_value&& other):
+      lk_(boost::move(other.lk_)),value_(other.value_)
+      {}
+      operator T()
+      {
+        return value_;
+      }
+
+      deref_value& operator=(T const& newVal)
+      {
+        value_=newVal;
+        return *this;
+      }
+    };
+    class const_deref_value
+    {
+    private:
+      friend class synchronized_value;
+
+      boost::unique_lock<lockable_type> lk_;
+      const T& value_;
+
+      explicit const_deref_value(synchronized_value const& outer):
+      lk_(outer.mtx_), value_(outer.value_)
+      {}
+
+    public:
+      BOOST_THREAD_NO_COPYABLE(const_deref_value)
+      const_deref_value(const_deref_value&& other):
+      lk_(boost::move(other.lk_)), value_(other.value_)
+      {}
+
+      operator T()
+      {
+        return value_;
+      }
+    };
+
+  public:
+    deref_value operator*()
+    {
+      return BOOST_THREAD_MAKE_RV_REF(deref_value(*this));
+    }
+
+    const_deref_value operator*() const
+    {
+      return BOOST_THREAD_MAKE_RV_REF(const_deref_value(*this));
+    }
+
+  };
+
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif // header

Added: trunk/libs/thread/example/synchronized_value.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/example/synchronized_value.cpp	2012-10-28 13:43:40 EDT (Sun, 28 Oct 2012)
@@ -0,0 +1,95 @@
+// (C) Copyright 2010 Just Software Solutions Ltd http://www.justsoftwaresolutions.co.uk
+// (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
+
+void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
+{
+  boost::synchronized_value<std::string>::strict_synchronizer u=path.synchronize();
+
+  if(u->empty() || (*u->rbegin()!='/'))
+  {
+    *u+='/';
+  }
+}
+
+void f(const boost::synchronized_value<int> &v) {
+  std::cout<<"v="<<*v<<std::endl;
+}
+
+void g(const boost::synchronized_value<int>::strict_synchronizer &v) {
+  std::cout<<"v="<<*v<<std::endl;
+}
+
+bool checkIfMissingTrailingSlash(boost::synchronized_value<std::string> & path)
+{
+  boost::synchronized_value<std::string>::strict_synchronizer u=path.synchronize();
+
+  return (u->empty() || (*u->rbegin()!='/'));
+}
+
+int main()
+{
+  {
+    boost::synchronized_value<int> v1;
+    *v1=42;
+    std::cout<<"v1="<<*v1<<std::endl;
+    f(v1);
+    int i=*v1;
+    std::cout<<"i="<<i<<std::endl;
+
+    {
+      boost::synchronized_value<int>::strict_synchronizer u=v1.synchronize();
+
+      *u+=43;
+      std::cout<<"v1="<<*u<<std::endl;
+      g(u);
+    }
+  }
+  {
+    boost::synchronized_value<std::string> s;
+    addTrailingSlashIfMissing(s);
+    std::cout<<"s="<<std::string(*s)<<std::endl;
+  }
+  {
+    boost::synchronized_value<std::string> s;
+#if 0
+    s->append("foo/");
+#else
+    s.synchronize()->append("foo");
+#endif
+    addTrailingSlashIfMissing(s);
+    std::cout<<"s="<<std::string(*s)<<std::endl;
+  }
+  {
+    boost::synchronized_value<std::string> s;
+#if 0
+    s->append("foo");
+#else
+    s.synchronize()->append("foo");
+#endif
+    addTrailingSlashIfMissing(s);
+    std::cout<<"s="<<std::string(*s)<<std::endl;
+  }
+  return 0;
+}
+
+#else
+
+int main()
+{
+  return 0;
+}
+#endif