/usr/include/boost/thread
Edit: /usr/include/boost/thread/externally_locked_stream.hpp (4784B)
// (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_EXTERNALLY_LOCKED_STREAM_HPP
#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost
{
template
class externally_locked_stream;
template
class stream_guard
{
friend class externally_locked_stream ;
public:
typedef typename externally_locked_stream::mutex_type mutex_type;
BOOST_THREAD_MOVABLE_ONLY( stream_guard)
stream_guard(externally_locked_stream& mtx) :
mtx_(&mtx)
{
mtx.lock();
}
stream_guard(externally_locked_stream& mtx, adopt_lock_t) :
mtx_(&mtx)
{
}
stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
: mtx_(rhs.mtx_)
{
rhs.mtx_= 0;
}
~stream_guard()
{
if (mtx_ != 0) mtx_->unlock();
}
bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
{
return l == mtx_->mutex();
}
/**
* @Requires mtx_
*/
Stream& get() const
{
BOOST_THREAD_ASSERT_PRECONDITION( mtx_, lock_error() );
return mtx_->get(*this);
}
Stream& bypass() const
{
return get();
}
private:
externally_locked_stream* mtx_;
};
template
struct is_strict_lock_sur_parole > : true_type
{
};
/**
* externally_locked_stream cloaks a reference to an stream of type Stream, and actually
* provides full access to that object through the get and set member functions, provided you
* pass a reference to a strict lock object.
*/
//[externally_locked_stream
template
class externally_locked_stream: public externally_locked
{
typedef externally_locked base_type;
public:
BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
/**
* Effects: Constructs an externally locked object storing the cloaked reference object.
*/
externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
base_type(stream, mtx)
{
}
stream_guard hold() BOOST_NOEXCEPT
{
return stream_guard (*this);
}
Stream& bypass() const
{
stream_guard lk(*this);
return get(lk);
}
};
//]
template
inline const stream_guard& operator<<(const stream_guard& lck, T arg)
{
lck.get() << arg;
return lck;
}
template
inline const stream_guard& operator<<(const stream_guard& lck, Stream& (*arg)(Stream&))
{
lck.get() << arg;
return lck;
}
template
inline const stream_guard& operator>>(const stream_guard& lck, T& arg)
{
lck.get() >> arg;
return lck;
}
template
inline stream_guard operator<<(externally_locked_stream& mtx, T arg)
{
stream_guard lk(mtx);
mtx.get(lk) << arg;
return boost::move(lk);
}
template
inline stream_guard operator<<(externally_locked_stream& mtx, Stream& (*arg)(Stream&))
{
stream_guard lk(mtx);
mtx.get(lk) << arg;
return boost::move(lk);
}
template
inline stream_guard operator>>(externally_locked_stream& mtx, T& arg)
{
stream_guard lk(mtx);
mtx.get(lk) >> arg;
return boost::move(lk);
}
}
#include
#endif // header