EIC code displayed by LXR master/​include/​boost/​thread/​synchronized_value.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-15 10:09:31

 // (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>
 
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/lock_guard.hpp>
 #include <boost/thread/lock_algorithms.hpp>
 #include <boost/thread/lock_factories.hpp>
 #include <boost/thread/strict_lock.hpp>
 #include <boost/core/invoke_swap.hpp>
 #include <boost/type_traits/declval.hpp>
 //#include <boost/type_traits.hpp>
 //#include <boost/thread/detail/is_nothrow_default_constructible.hpp>
 //#if ! defined BOOST_NO_CXX11_HDR_TYPE_TRAITS
 //#include <type_traits>
 //#endif
 
 #if ! defined(BOOST_THREAD_NO_SYNCHRONIZE)
 #include <tuple> // todo change to <boost/tuple.hpp> once Boost.Tuple or Boost.Fusion provides Move semantics on C++98 compilers.
 #include <functional>
 #endif
 
 #include <boost/utility/result_of.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
 {
 
   /**
    * strict lock providing a const pointer access to the synchronized value type.
    *
    * @param T the value type.
    * @param Lockable the mutex type protecting the value type.
    */
   template <typename T, typename Lockable = mutex>
   class const_strict_lock_ptr
   {
   public:
     typedef T value_type;
     typedef Lockable mutex_type;
   protected:
 
     // this should be a strict_lock, but unique_lock is needed to be able to return it.
     boost::unique_lock<mutex_type> lk_;
     T const& value_;
 
   public:
     BOOST_THREAD_MOVABLE_ONLY( const_strict_lock_ptr )
 
     /**
      * @param value constant reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value.
      */
     const_strict_lock_ptr(T const& val, Lockable & mtx) :
       lk_(mtx), value_(val)
     {
     }
     const_strict_lock_ptr(T const& val, Lockable & mtx, adopt_lock_t tag) BOOST_NOEXCEPT :
       lk_(mtx, tag), value_(val)
     {
     }
     /**
      * Move constructor.
      * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other.
      */
     const_strict_lock_ptr(BOOST_THREAD_RV_REF(const_strict_lock_ptr) other) BOOST_NOEXCEPT
     : lk_(boost::move(BOOST_THREAD_RV(other).lk_)),value_(BOOST_THREAD_RV(other).value_)
     {
     }
 
     ~const_strict_lock_ptr()
     {
     }
 
     /**
      * @return a constant pointer to the protected value
      */
     const T* operator->() const
     {
       return &value_;
     }
 
     /**
      * @return a constant reference to the protected value
      */
     const T& operator*() const
     {
       return value_;
     }
 
   };
 
   /**
    * strict lock providing a pointer access to the synchronized value type.
    *
    * @param T the value type.
    * @param Lockable the mutex type protecting the value type.
    */
   template <typename T, typename Lockable = mutex>
   class strict_lock_ptr : public const_strict_lock_ptr<T,Lockable>
   {
     typedef const_strict_lock_ptr<T,Lockable> base_type;
   public:
     BOOST_THREAD_MOVABLE_ONLY( strict_lock_ptr )
 
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value.
      */
     strict_lock_ptr(T & val, Lockable & mtx) :
     base_type(val, mtx)
     {
     }
     strict_lock_ptr(T & val, Lockable & mtx, adopt_lock_t tag) :
     base_type(val, mtx, tag)
     {
     }
 
     /**
      * Move constructor.
      * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other.
      */
     strict_lock_ptr(BOOST_THREAD_RV_REF(strict_lock_ptr) other)
     : base_type(boost::move(static_cast<base_type&>(other)))
     {
     }
 
     ~strict_lock_ptr()
     {
     }
 
     /**
      * @return a pointer to the protected value
      */
     T* operator->()
     {
       return const_cast<T*>(&this->value_);
     }
 
     /**
      * @return a reference to the protected value
      */
     T& operator*()
     {
       return const_cast<T&>(this->value_);
     }
 
   };
 
   template <typename SV>
   struct synchronized_value_strict_lock_ptr
   {
    typedef strict_lock_ptr<typename SV::value_type, typename SV::mutex_type> type;
   };
 
   template <typename SV>
   struct synchronized_value_strict_lock_ptr<const SV>
   {
    typedef const_strict_lock_ptr<typename SV::value_type, typename SV::mutex_type> type;
   };
   /**
    * unique_lock providing a const pointer access to the synchronized value type.
    *
    * An object of type const_unique_lock_ptr is a unique_lock that provides a const pointer access to the synchronized value type.
    * As unique_lock controls the ownership of a lockable object within a scope.
    * Ownership of the lockable object may be acquired at construction or after construction,
    * and may be transferred, after acquisition, to another const_unique_lock_ptr object.
    * Objects of type const_unique_lock_ptr are not copyable but are movable.
    * The behavior of a program is undefined if the mutex and the value type
    * pointed do not exist for the entire remaining lifetime of the const_unique_lock_ptr object.
    * The supplied Mutex type shall meet the BasicLockable requirements.
    *
    * @note const_unique_lock_ptr<T, Lockable> meets the Lockable requirements.
    * If Lockable meets the TimedLockable requirements, const_unique_lock_ptr<T,Lockable>
    * also meets the TimedLockable requirements.
    *
    * @param T the value type.
    * @param Lockable the mutex type protecting the value type.
    */
   template <typename T, typename Lockable = mutex>
   class const_unique_lock_ptr : public unique_lock<Lockable>
   {
     typedef unique_lock<Lockable> base_type;
   public:
     typedef T value_type;
     typedef Lockable mutex_type;
   protected:
     T const& value_;
 
   public:
     BOOST_THREAD_MOVABLE_ONLY(const_unique_lock_ptr)
 
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      *
      * @requires If mutex_type is not a recursive mutex the calling thread does not own the mutex.
      *
      * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value.
      */
     const_unique_lock_ptr(T const& val, Lockable & mtx)
     : base_type(mtx), value_(val)
     {
     }
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @param tag of type adopt_lock_t used to differentiate the constructor.
      * @requires The calling thread own the mutex.
      * @effects stores a reference to it and to the value type @c value taking ownership.
      */
     const_unique_lock_ptr(T const& val, Lockable & mtx, adopt_lock_t) BOOST_NOEXCEPT
     : base_type(mtx, adopt_lock), value_(val)
     {
     }
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @param tag of type defer_lock_t used to differentiate the constructor.
      * @effects stores a reference to it and to the value type @c value c.
      */
     const_unique_lock_ptr(T const& val, Lockable & mtx, defer_lock_t) BOOST_NOEXCEPT
     : base_type(mtx, defer_lock), value_(val)
     {
     }
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @param tag of type try_to_lock_t used to differentiate the constructor.
      * @requires If mutex_type is not a recursive mutex the calling thread does not own the mutex.
      * @effects try to lock the mutex @c mtx, stores a reference to it and to the value type @c value.
      */
     const_unique_lock_ptr(T const& val, Lockable & mtx, try_to_lock_t) BOOST_NOEXCEPT
     : base_type(mtx, try_to_lock), value_(val)
     {
     }
     /**
      * Move constructor.
      * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other.
      */
     const_unique_lock_ptr(BOOST_THREAD_RV_REF(const_unique_lock_ptr) other) BOOST_NOEXCEPT
     : base_type(boost::move(static_cast<base_type&>(other))), value_(BOOST_THREAD_RV(other).value_)
     {
     }
 
     /**
      * @effects If owns calls unlock() on the owned mutex.
      */
     ~const_unique_lock_ptr()
     {
     }
 
     /**
      * @return a constant pointer to the protected value
      */
     const T* operator->() const
     {
       BOOST_ASSERT (this->owns_lock());
       return &value_;
     }
 
     /**
      * @return a constant reference to the protected value
      */
     const T& operator*() const
     {
       BOOST_ASSERT (this->owns_lock());
       return value_;
     }
 
   };
 
   /**
    * unique lock providing a pointer access to the synchronized value type.
    *
    * @param T the value type.
    * @param Lockable the mutex type protecting the value type.
    */
   template <typename T, typename Lockable = mutex>
   class unique_lock_ptr : public const_unique_lock_ptr<T, Lockable>
   {
     typedef const_unique_lock_ptr<T, Lockable> base_type;
   public:
     typedef T value_type;
     typedef Lockable mutex_type;
 
     BOOST_THREAD_MOVABLE_ONLY(unique_lock_ptr)
 
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value.
      */
     unique_lock_ptr(T & val, Lockable & mtx)
     : base_type(val, mtx)
     {
     }
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @param tag of type adopt_lock_t used to differentiate the constructor.
      * @effects stores a reference to it and to the value type @c value taking ownership.
      */
     unique_lock_ptr(T & value, Lockable & mtx, adopt_lock_t) BOOST_NOEXCEPT
     : base_type(value, mtx, adopt_lock)
     {
     }
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @param tag of type defer_lock_t used to differentiate the constructor.
      * @effects stores a reference to it and to the value type @c value c.
      */
     unique_lock_ptr(T & value, Lockable & mtx, defer_lock_t) BOOST_NOEXCEPT
     : base_type(value, mtx, defer_lock)
     {
     }
     /**
      * @param value reference of the value to protect.
      * @param mtx reference to the mutex used to protect the value.
      * @param tag of type try_to_lock_t used to differentiate the constructor.
      * @effects try to lock the mutex @c mtx, stores a reference to it and to the value type @c value.
      */
     unique_lock_ptr(T & value, Lockable & mtx, try_to_lock_t) BOOST_NOEXCEPT
     : base_type(value, mtx, try_to_lock)
     {
     }
     /**
      * Move constructor.
      * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other.
      */
     unique_lock_ptr(BOOST_THREAD_RV_REF(unique_lock_ptr) other) BOOST_NOEXCEPT
     : base_type(boost::move(static_cast<base_type&>(other)))
     {
     }
 
     ~unique_lock_ptr()
     {
     }
 
     /**
      * @return a pointer to the protected value
      */
     T* operator->()
     {
       BOOST_ASSERT (this->owns_lock());
       return const_cast<T*>(&this->value_);
     }
 
     /**
      * @return a reference to the protected value
      */
     T& operator*()
     {
       BOOST_ASSERT (this->owns_lock());
       return const_cast<T&>(this->value_);
     }
 
 
   };
 
   template <typename SV>
   struct synchronized_value_unique_lock_ptr
   {
    typedef unique_lock_ptr<typename SV::value_type, typename SV::mutex_type> type;
   };
 
   template <typename SV>
   struct synchronized_value_unique_lock_ptr<const SV>
   {
    typedef const_unique_lock_ptr<typename SV::value_type, typename SV::mutex_type> type;
   };
   /**
    * cloaks a value type and the mutex used to protect it together.
    * @param T the value type.
    * @param Lockable the mutex type protecting the value type.
    */
   template <typename T, typename Lockable = mutex>
   class synchronized_value
   {
 
 #if ! defined(BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS)
 #if ! defined BOOST_NO_CXX11_VARIADIC_TEMPLATES
     template <typename ...SV>
     friend std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> synchronize(SV& ...sv);
 #else
     template <typename SV1, typename SV2>
     friend std::tuple<
       typename synchronized_value_strict_lock_ptr<SV1>::type,
       typename synchronized_value_strict_lock_ptr<SV2>::type
     >
     synchronize(SV1& sv1, SV2& sv2);
     template <typename SV1, typename SV2, typename SV3>
     friend std::tuple<
       typename synchronized_value_strict_lock_ptr<SV1>::type,
       typename synchronized_value_strict_lock_ptr<SV2>::type,
       typename synchronized_value_strict_lock_ptr<SV3>::type
     >
     synchronize(SV1& sv1, SV2& sv2, SV3& sv3);
 #endif
 #endif
 
   public:
     typedef T value_type;
     typedef Lockable mutex_type;
   private:
     T value_;
     mutable mutex_type mtx_;
   public:
     // construction/destruction
     /**
      * Default constructor.
      *
      * @Requires: T is DefaultConstructible
      */
     synchronized_value()
     //BOOST_NOEXCEPT_IF(is_nothrow_default_constructible<T>::value)
     : value_()
     {
     }
 
     /**
      * Constructor from copy constructible value.
      *
      * Requires: T is CopyConstructible
      */
     synchronized_value(T const& other)
     //BOOST_NOEXCEPT_IF(is_nothrow_copy_constructible<T>::value)
     : value_(other)
     {
     }
 
     /**
      * Move Constructor.
      *
      * Requires: T is CopyMovable
      */
     synchronized_value(BOOST_THREAD_RV_REF(T) other)
     //BOOST_NOEXCEPT_IF(is_nothrow_move_constructible<T>::value)
     : value_(boost::move(other))
     {
     }
 
     /**
      * Constructor from value type.
      *
      * Requires: T is DefaultConstructible and Assignable
      * Effects: Assigns the value on a scope protected by the mutex of the rhs. The mutex is not copied.
      */
     synchronized_value(synchronized_value const& rhs)
     {
       strict_lock<mutex_type> lk(rhs.mtx_);
       value_ = rhs.value_;
     }
 
     /**
      * Move Constructor from movable value type
      *
      */
     synchronized_value(BOOST_THREAD_RV_REF(synchronized_value) other)
     {
       strict_lock<mutex_type> lk(BOOST_THREAD_RV(other).mtx_);
       value_= boost::move(BOOST_THREAD_RV(other).value_);
     }
 
     // mutation
     /**
      * Assignment operator.
      *
      * Effects: Copies the underlying value on a scope protected by the two mutexes.
      * The mutex is not copied. The locks are acquired using lock, so deadlock is avoided.
      * For example, there is no problem if one thread assigns a = b and the other assigns b = a.
      *
      * Return: *this
      */
 
     synchronized_value& operator=(synchronized_value const& rhs)
     {
       if(&rhs != this)
       {
         // auto _ = make_unique_locks(mtx_, rhs.mtx_);
         unique_lock<mutex_type> lk1(mtx_, defer_lock);
         unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
         lock(lk1,lk2);
 
         value_ = rhs.value_;
       }
       return *this;
     }
     /**
      * Assignment operator from a T const&.
      * Effects: The operator copies the value on a scope protected by the mutex.
      * Return: *this
      */
     synchronized_value& operator=(value_type const& val)
     {
       {
         strict_lock<mutex_type> lk(mtx_);
         value_ = val;
       }
       return *this;
     }
 
     //observers
     /**
      * Explicit conversion to value type.
      *
      * Requires: T is CopyConstructible
      * Return: A copy of the protected value obtained on a scope protected by the mutex.
      *
      */
     T get() const
     {
       strict_lock<mutex_type> lk(mtx_);
       return value_;
     }
     /**
      * Explicit conversion to value type.
      *
      * Requires: T is CopyConstructible
      * Return: A copy of the protected value obtained on a scope protected by the mutex.
      *
      */
 #if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
     explicit operator T() const
     {
       return get();
     }
 #endif
 
     /**
      * value type getter.
      *
      * Return: A constant reference to the protected value.
      *
      * Note: Not thread safe
      *
      */
     T const& value() const
     {
       return value_;
     }
     /**
      * mutex getter.
      *
      * Return: A constant reference to the protecting mutex.
      *
      * Note: Not thread safe
      *
      */
     mutex_type const& mutex() const
     {
       return mtx_;
     }
     /**
      * Swap
      *
      * Effects: Swaps the data. Again, locks are acquired using lock(). The mutexes are not swapped.
      * A swap method accepts a T& and swaps the data inside a critical section.
      * This is by far the preferred method of changing the guarded datum wholesale because it keeps the lock only
      * for a short time, thus lowering the pressure on the mutex.
      */
     void swap(synchronized_value & rhs)
     {
       if (this == &rhs) {
         return;
       }
       // auto _ = make_unique_locks(mtx_, rhs.mtx_);
       unique_lock<mutex_type> lk1(mtx_, defer_lock);
       unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
       lock(lk1,lk2);
       boost::core::invoke_swap(value_, rhs.value_);
     }
     /**
      * Swap with the underlying value type
      *
      * Effects: Swaps the data on a scope protected by the mutex.
      */
     void swap(value_type & rhs)
     {
       strict_lock<mutex_type> lk(mtx_);
       boost::core::invoke_swap(value_, rhs);
     }
 
     /**
      * Essentially calling a method obj->foo(x, y, z) calls the method foo(x, y, z) inside a critical section as
      * long-lived as the call itself.
      */
     strict_lock_ptr<T,Lockable> operator->()
     {
       return BOOST_THREAD_MAKE_RV_REF((strict_lock_ptr<T,Lockable>(value_, mtx_)));
     }
     /**
      * If the synchronized_value object involved is const-qualified, then you'll only be able to call const methods
      * through operator->. So, for example, vec->push_back("xyz") won't work if vec were const-qualified.
      * The locking mechanism capitalizes on the assumption that const methods don't modify their underlying data.
      */
     const_strict_lock_ptr<T,Lockable> operator->() const
     {
       return BOOST_THREAD_MAKE_RV_REF((const_strict_lock_ptr<T,Lockable>(value_, mtx_)));
     }
 
     /**
      * Call function on a locked block.
      *
      * @requires fct(value_) is well formed.
      *
      * Example
      *   void fun(synchronized_value<vector<int>> & v) {
      *     v ( [](vector<int>> & vec)
      *     {
      *       vec.push_back(42);
      *       assert(vec.back() == 42);
      *     } );
      *   }
      */
     template <typename F>
     inline
     typename boost::result_of<F(value_type&)>::type
     operator()(BOOST_THREAD_RV_REF(F) fct)
     {
       strict_lock<mutex_type> lk(mtx_);
       return fct(value_);
     }
     template <typename F>
     inline
     typename boost::result_of<F(value_type const&)>::type
     operator()(BOOST_THREAD_RV_REF(F) fct) const
     {
       strict_lock<mutex_type> lk(mtx_);
       return fct(value_);
     }
 
 
 #if defined  BOOST_NO_CXX11_RVALUE_REFERENCES
     template <typename F>
     inline
     typename boost::result_of<F(value_type&)>::type
     operator()(F const & fct)
     {
       strict_lock<mutex_type> lk(mtx_);
       return fct(value_);
     }
     template <typename F>
     inline
     typename boost::result_of<F(value_type const&)>::type
     operator()(F const & fct) const
     {
       strict_lock<mutex_type> lk(mtx_);
       return fct(value_);
     }
 
     template <typename R>
     inline
     R operator()(R(*fct)(value_type&))
     {
       strict_lock<mutex_type> lk(mtx_);
       return fct(value_);
     }
     template <typename R>
     inline
     R operator()(R(*fct)(value_type const&)) const
     {
       strict_lock<mutex_type> lk(mtx_);
       return fct(value_);
     }
 #endif
 
 
     /**
      * The synchronize() factory make easier to lock on a scope.
      * As discussed, operator-> can only lock over the duration of a call, so it is insufficient for complex operations.
      * With synchronize() you get to lock the object in a scoped and to directly access the object inside that scope.
      *
      * Example
      *   void fun(synchronized_value<vector<int>> & v) {
      *     auto&& vec=v.synchronize();
      *     vec.push_back(42);
      *     assert(vec.back() == 42);
      *   }
      */
     strict_lock_ptr<T,Lockable> synchronize()
     {
       return BOOST_THREAD_MAKE_RV_REF((strict_lock_ptr<T,Lockable>(value_, mtx_)));
     }
     const_strict_lock_ptr<T,Lockable> synchronize() const
     {
       return BOOST_THREAD_MAKE_RV_REF((const_strict_lock_ptr<T,Lockable>(value_, mtx_)));
     }
 
     unique_lock_ptr<T,Lockable> unique_synchronize()
     {
       return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_)));
     }
     const_unique_lock_ptr<T,Lockable> unique_synchronize() const
     {
       return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_)));
     }
     unique_lock_ptr<T,Lockable> unique_synchronize(defer_lock_t tag)
     {
       return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, tag)));
     }
     const_unique_lock_ptr<T,Lockable> unique_synchronize(defer_lock_t tag) const
     {
       return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, tag)));
     }
     unique_lock_ptr<T,Lockable> defer_synchronize() BOOST_NOEXCEPT
     {
       return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, defer_lock)));
     }
     const_unique_lock_ptr<T,Lockable> defer_synchronize() const BOOST_NOEXCEPT
     {
       return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, defer_lock)));
     }
     unique_lock_ptr<T,Lockable> try_to_synchronize() BOOST_NOEXCEPT
     {
       return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, try_to_lock)));
     }
     const_unique_lock_ptr<T,Lockable> try_to_synchronize() const BOOST_NOEXCEPT
     {
       return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, try_to_lock)));
     }
     unique_lock_ptr<T,Lockable> adopt_synchronize() BOOST_NOEXCEPT
     {
       return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, adopt_lock)));
     }
     const_unique_lock_ptr<T,Lockable> adopt_synchronize() const BOOST_NOEXCEPT
     {
       return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, adopt_lock)));
     }
 
 
 #if ! defined __IBMCPP__
     private:
 #endif
     class deref_value
     {
     private:
       friend class synchronized_value;
 
       boost::unique_lock<mutex_type> lk_;
       T& value_;
 
       explicit deref_value(synchronized_value& outer):
       lk_(outer.mtx_),value_(outer.value_)
       {}
 
     public:
       BOOST_THREAD_MOVABLE_ONLY(deref_value)
 
       deref_value(BOOST_THREAD_RV_REF(deref_value) other):
       lk_(boost::move(BOOST_THREAD_RV(other).lk_)),value_(BOOST_THREAD_RV(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<mutex_type> lk_;
       const T& value_;
 
       explicit const_deref_value(synchronized_value const& outer):
       lk_(outer.mtx_), value_(outer.value_)
       {}
 
     public:
       BOOST_THREAD_MOVABLE_ONLY(const_deref_value)
 
       const_deref_value(BOOST_THREAD_RV_REF(const_deref_value) other):
       lk_(boost::move(BOOST_THREAD_RV(other).lk_)), value_(BOOST_THREAD_RV(other).value_)
       {}
 
       operator const 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));
     }
 
     // io functions
     /**
      * @requires T is OutputStreamable
      * @effects saves the value type on the output stream @c os.
      */
     template <typename OStream>
     void save(OStream& os) const
     {
       strict_lock<mutex_type> lk(mtx_);
       os << value_;
     }
     /**
      * @requires T is InputStreamable
      * @effects loads the value type from the input stream @c is.
      */
     template <typename IStream>
     void load(IStream& is)
     {
       strict_lock<mutex_type> lk(mtx_);
       is >> value_;
     }
 
     // relational operators
     /**
      * @requires T is EqualityComparable
      *
      */
     bool operator==(synchronized_value const& rhs)  const
     {
       unique_lock<mutex_type> lk1(mtx_, defer_lock);
       unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
       lock(lk1,lk2);
 
       return value_ == rhs.value_;
     }
     /**
      * @requires T is LessThanComparable
      *
      */
     bool operator<(synchronized_value const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_, defer_lock);
       unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
       lock(lk1,lk2);
 
       return value_ < rhs.value_;
     }
     /**
      * @requires T is GreaterThanComparable
      *
      */
     bool operator>(synchronized_value const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_, defer_lock);
       unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
       lock(lk1,lk2);
 
       return value_ > rhs.value_;
     }
     bool operator<=(synchronized_value const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_, defer_lock);
       unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
       lock(lk1,lk2);
 
       return value_ <= rhs.value_;
     }
     bool operator>=(synchronized_value const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_, defer_lock);
       unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
       lock(lk1,lk2);
 
       return value_ >= rhs.value_;
     }
     bool operator==(value_type const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_);
 
       return value_ == rhs;
     }
     bool operator!=(value_type const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_);
 
       return value_ != rhs;
     }
     bool operator<(value_type const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_);
 
       return value_ < rhs;
     }
     bool operator<=(value_type const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_);
 
       return value_ <= rhs;
     }
     bool operator>(value_type const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_);
 
       return value_ > rhs;
     }
     bool operator>=(value_type const& rhs) const
     {
       unique_lock<mutex_type> lk1(mtx_);
 
       return value_ >= rhs;
     }
 
   };
 
   // Specialized algorithms
   /**
    *
    */
   template <typename T, typename L>
   inline void swap(synchronized_value<T,L> & lhs, synchronized_value<T,L> & rhs)
   {
     lhs.swap(rhs);
   }
   template <typename T, typename L>
   inline void swap(synchronized_value<T,L> & lhs, T & rhs)
   {
     lhs.swap(rhs);
   }
   template <typename T, typename L>
   inline void swap(T & lhs, synchronized_value<T,L> & rhs)
   {
     rhs.swap(lhs);
   }
 
   //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>& rhs)
   {
     rhs.load(is);
     return is;
   }
 
 #if ! defined(BOOST_THREAD_NO_SYNCHRONIZE)
 #if ! defined BOOST_NO_CXX11_VARIADIC_TEMPLATES
 
   template <typename ...SV>
   std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> synchronize(SV& ...sv)
   {
     boost::lock(sv.mtx_ ...);
     typedef std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> t_type;
 
     return t_type(typename synchronized_value_strict_lock_ptr<SV>::type(sv.value_, sv.mtx_, adopt_lock) ...);
   }
 #else
 
   template <typename SV1, typename SV2>
   std::tuple<
     typename synchronized_value_strict_lock_ptr<SV1>::type,
     typename synchronized_value_strict_lock_ptr<SV2>::type
   >
   synchronize(SV1& sv1, SV2& sv2)
   {
     boost::lock(sv1.mtx_, sv2.mtx_);
     typedef std::tuple<
         typename synchronized_value_strict_lock_ptr<SV1>::type,
         typename synchronized_value_strict_lock_ptr<SV2>::type
         > t_type;
 
     return t_type(
         typename synchronized_value_strict_lock_ptr<SV1>::type(sv1.value_, sv1.mtx_, adopt_lock),
         typename synchronized_value_strict_lock_ptr<SV2>::type(sv2.value_, sv2.mtx_, adopt_lock)
         );
 
   }
   template <typename SV1, typename SV2, typename SV3>
   std::tuple<
     typename synchronized_value_strict_lock_ptr<SV1>::type,
     typename synchronized_value_strict_lock_ptr<SV2>::type,
     typename synchronized_value_strict_lock_ptr<SV3>::type
   >
   synchronize(SV1& sv1, SV2& sv2, SV3& sv3)
   {
     boost::lock(sv1.mtx_, sv2.mtx_);
     typedef std::tuple<
         typename synchronized_value_strict_lock_ptr<SV1>::type,
         typename synchronized_value_strict_lock_ptr<SV2>::type,
         typename synchronized_value_strict_lock_ptr<SV3>::type
         > t_type;
 
     return t_type(
         typename synchronized_value_strict_lock_ptr<SV1>::type(sv1.value_, sv1.mtx_, adopt_lock),
         typename synchronized_value_strict_lock_ptr<SV2>::type(sv2.value_, sv2.mtx_, adopt_lock),
         typename synchronized_value_strict_lock_ptr<SV3>::type(sv3.value_, sv3.mtx_, adopt_lock)
         );
 
   }
 #endif
 #endif
 }
 
 #include <boost/config/abi_suffix.hpp>
 
 #endif // header

This page was automatically generated by the 2.3.7 LXR engine. The LXR team