/usr/include/boost/thread
Edit: /usr/include/boost/thread/lock_concepts.hpp (4792B)
// (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)
#ifndef BOOST_THREAD_LOCK_CONCEPTS_HPP
#define BOOST_THREAD_LOCK_CONCEPTS_HPP
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost
{
/**
* BasicLock object supports the basic features
* required to delimit a critical region
* Supports the basic lock, unlock and try_lock functions and
* defines the lock traits
*/
template
struct BasicLock
{
typedef typename Lk::mutex_type mutex_type;
void cvt_mutex_ptr(mutex_type*) {}
BOOST_CONCEPT_ASSERT(( BasicLockable ));
BOOST_CONCEPT_USAGE(BasicLock)
{
const Lk l1(mtx);
Lk l2(mtx, defer_lock);
Lk l3(mtx, adopt_lock);
Lk l4(( Lk()));
Lk l5(( boost::move(l2)));
cvt_mutex_ptr(l1.mutex());
if (l1.owns_lock()) return;
if (l1) return;
if (!l1) return;
l2.lock();
l2.unlock();
l2.release();
}
BasicLock() :
mtx(*static_cast(0))
{}
private:
BasicLock operator=(BasicLock const&);
mutex_type& mtx;
}
;
template
struct Lock
{
BOOST_CONCEPT_ASSERT(( BasicLock ));
typedef typename Lk::mutex_type mutex_type;
BOOST_CONCEPT_ASSERT(( Lockable ));
BOOST_CONCEPT_USAGE(Lock)
{
Lk l1(mtx, try_to_lock);
if (l1.try_lock()) return;
}
Lock() :
mtx(*static_cast(0))
{}
private:
Lock operator=(Lock const&);
mutex_type& mtx;
};
template
struct TimedLock
{
BOOST_CONCEPT_ASSERT(( Lock ));
typedef typename Lk::mutex_type mutex_type;
BOOST_CONCEPT_ASSERT(( TimedLockable ));
BOOST_CONCEPT_USAGE(TimedLock)
{
const Lk l1(mtx, t);
Lk l2(mtx, d);
if (l1.try_lock_until(t)) return;
if (l1.try_lock_for(d)) return;
}
TimedLock() :
mtx(*static_cast(0))
{}
private:
TimedLock operator=(TimedLock const&);
mutex_type& mtx;
boost::chrono::system_clock::time_point t;
boost::chrono::system_clock::duration d;
};
template
struct UniqueLock
{
BOOST_CONCEPT_ASSERT(( TimedLock ));
typedef typename Lk::mutex_type mutex_type;
BOOST_CONCEPT_USAGE(UniqueLock)
{
}
UniqueLock() :
mtx(*static_cast(0))
{}
private:
UniqueLock operator=(UniqueLock const&);
mutex_type& mtx;
};
template
struct SharedLock
{
BOOST_CONCEPT_ASSERT(( TimedLock ));
typedef typename Lk::mutex_type mutex_type;
BOOST_CONCEPT_USAGE(SharedLock)
{
}
SharedLock() :
mtx(*static_cast(0))
{}
private:
SharedLock operator=(SharedLock const&);
mutex_type& mtx;
};
template
struct UpgradeLock
{
BOOST_CONCEPT_ASSERT(( SharedLock ));
typedef typename Lk::mutex_type mutex_type;
BOOST_CONCEPT_USAGE(UpgradeLock)
{
}
UpgradeLock() :
mtx(*static_cast(0))
{}
private:
UpgradeLock operator=(UpgradeLock const&);
mutex_type& mtx;
};
/**
* An StrictLock is a scoped lock guard ensuring the mutex is locked on the
* scope of the lock, by locking the mutex on construction and unlocking it on
* destruction.
*
* Essentially, a StrictLock's role is only to live on the stack as an
* automatic variable. strict_lock must adhere to a non-copy and non-alias
* policy. StrictLock disables copying by making the copy constructor and the
* assignment operator private. While we're at it, let's disable operator new
* and operator delete; strict locks are not intended to be allocated on the
* heap. StrictLock avoids aliasing by using a slightly less orthodox and
* less well-known technique: disable address taking.
*/
template
struct StrictLock
{
typedef typename Lk::mutex_type mutex_type;
BOOST_CONCEPT_ASSERT(( BasicLockable ));
BOOST_STATIC_ASSERT(( is_strict_lock::value ));
BOOST_CONCEPT_USAGE( StrictLock)
{
if (l1.owns_lock(&mtx)) return;
}
StrictLock() :
l1(*static_cast(0)),
mtx(*static_cast(0))
{}
private:
StrictLock operator=(StrictLock const&);
Lk const& l1;
mutex_type const& mtx;
};
}
#endif