synchronized_value.hpp File Reference

#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/swap.hpp>
#include <boost/utility/declval.hpp>
#include <tuple>
#include <functional>
#include <boost/utility/result_of.hpp>
#include <boost/config/abi_prefix.hpp>
#include <boost/config/abi_suffix.hpp>

Include dependency graph for synchronized_value.hpp:

Classes
class	boost::const_strict_lock_ptr< T, Lockable >
	strict lock providing a const pointer access to the synchronized value type. More...
class	boost::strict_lock_ptr< T, Lockable >
	strict lock providing a pointer access to the synchronized value type. More...
struct	boost::synchronized_value_strict_lock_ptr< SV >
struct	boost::synchronized_value_strict_lock_ptr< const SV >
class	boost::const_unique_lock_ptr< T, Lockable >
	unique_lock providing a const pointer access to the synchronized value type. More...
class	boost::unique_lock_ptr< T, Lockable >
	unique lock providing a pointer access to the synchronized value type. More...
struct	boost::synchronized_value_unique_lock_ptr< SV >
struct	boost::synchronized_value_unique_lock_ptr< const SV >
class	boost::synchronized_value< T, Lockable >
	cloaks a value type and the mutex used to protect it together. More...

Namespaces
	boost
	Duration formatting facet for input.

Functions
template<typename T , typename L >
void	boost::swap (synchronized_value< T, L > &lhs, synchronized_value< T, L > &rhs)
template<typename T , typename L >
void	boost::swap (synchronized_value< T, L > &lhs, T &rhs)
template<typename T , typename L >
void	boost::swap (T &lhs, synchronized_value< T, L > &rhs)
template<typename T , typename L >
bool	boost::operator!= (synchronized_value< T, L > const &lhs, synchronized_value< T, L > const &rhs)
template<typename T , typename L >
bool	boost::operator== (T const &lhs, synchronized_value< T, L > const &rhs)
template<typename T , typename L >
bool	boost::operator!= (T const &lhs, synchronized_value< T, L > const &rhs)
template<typename T , typename L >
bool	boost::operator< (T const &lhs, synchronized_value< T, L > const &rhs)
template<typename T , typename L >
bool	boost::operator<= (T const &lhs, synchronized_value< T, L > const &rhs)
template<typename T , typename L >
bool	boost::operator> (T const &lhs, synchronized_value< T, L > const &rhs)
template<typename T , typename L >
bool	boost::operator>= (T const &lhs, synchronized_value< T, L > const &rhs)
template<typename OStream , typename T , typename L >
OStream &	boost::operator<< (OStream &os, synchronized_value< T, L > const &rhs)
template<typename IStream , typename T , typename L >
IStream &	boost::operator>> (IStream &is, synchronized_value< T, L > const &rhs)
template<typename... SV>
std::tuple< typename synchronized_value_strict_lock_ptr < SV >::type...>	boost::synchronize (SV &...sv)