/usr/include/boost/thread
Edit: /usr/include/boost/thread/null_mutex.hpp (6346B)
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Vicente J. Botet Escriba 2008-2009,2012. 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)
//
// See http://www.boost.org/libs/thread for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_THREAD_NULL_MUTEX_HPP
#define BOOST_THREAD_NULL_MUTEX_HPP
#include
#include
#include
/// \file
/// Describes null_mutex class
namespace boost
{
/// Implements a mutex that simulates a mutex without doing any operation and
/// simulates a successful operation.
class null_mutex
{
public:
BOOST_THREAD_NO_COPYABLE( null_mutex) /*< no copyable >*/
null_mutex() {}
/// Simulates a mutex lock() operation. Empty function.
void lock()
{
}
/// Simulates a mutex try_lock() operation.
/// Equivalent to "return true;"
bool try_lock()
{
return true;
}
/// Simulates a mutex unlock() operation.
/// Empty function.
void unlock()
{
}
#ifdef BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_lock_until() operation.
/// Equivalent to "return true;"
template
bool try_lock_until(chrono::time_point const &)
{
return true;
}
/// Simulates a mutex try_lock_for() operation.
/// Equivalent to "return true;"
template
bool try_lock_for(chrono::duration const &)
{
return true;
}
#endif
/// Simulates a mutex lock_shared() operation.
/// Empty function.
void lock_shared()
{
}
/// Simulates a mutex try_lock_shared() operation.
/// Equivalent to "return true;"
bool try_lock_shared()
{
return true;
}
/// Simulates a mutex unlock_shared() operation.
/// Empty function.
void unlock_shared()
{
}
/// Simulates a mutex try_lock_shared_until() operation.
/// Equivalent to "return true;"
template
bool try_lock_shared_until(chrono::time_point const &)
{
return true;
}
/// Simulates a mutex try_lock_shared_for() operation.
/// Equivalent to "return true;"
template
bool try_lock_shared_for(chrono::duration const &)
{
return true;
}
/// Simulates a mutex lock_upgrade() operation.
/// Empty function.
void lock_upgrade()
{
}
/// Simulates a mutex try_lock_upgrade() operation.
/// Equivalent to "return true;"
bool try_lock_upgrade()
{
return true;
}
/// Simulates a mutex unlock_upgrade() operation.
/// Empty function.
void unlock_upgrade()
{
}
/// Simulates a mutex try_lock_upgrade_until() operation.
/// Equivalent to "return true;"
template
bool try_lock_upgrade_until(chrono::time_point const &)
{
return true;
}
/// Simulates a mutex try_lock_upgrade_for() operation.
/// Equivalent to "return true;"
template
bool try_lock_upgrade_for(chrono::duration const &)
{
return true;
}
/// Simulates a mutex try_unlock_shared_and_lock() operation.
/// Equivalent to "return true;"
bool try_unlock_shared_and_lock()
{
return true;
}
#ifdef BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_unlock_shared_and_lock_until() operation.
/// Equivalent to "return true;"
template
bool try_unlock_shared_and_lock_until(chrono::time_point const &)
{
return true;
}
/// Simulates a mutex try_unlock_shared_and_lock_for() operation.
/// Equivalent to "return true;"
template
bool try_unlock_shared_and_lock_for(chrono::duration const &)
{
return true;
}
#endif
/// Simulates unlock_and_lock_shared().
/// Empty function.
void unlock_and_lock_shared()
{
}
/// Simulates a mutex try_unlock_shared_and_lock_upgrade() operation.
/// Equivalent to "return true;"
bool try_unlock_shared_and_lock_upgrade()
{
return true;
}
#ifdef BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_unlock_shared_and_lock_upgrade_until() operation.
/// Equivalent to "return true;"
template
bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point const &)
{
return true;
}
/// Simulates a mutex try_unlock_shared_and_lock_upgrade_for() operation.
/// Equivalent to "return true;"
template
bool try_unlock_shared_and_lock_upgrade_for(chrono::duration const &)
{
return true;
}
#endif
/// Simulates unlock_and_lock_upgrade().
/// Empty function.
void unlock_and_lock_upgrade()
{
}
/// Simulates unlock_upgrade_and_lock().
/// Empty function.
void unlock_upgrade_and_lock()
{
}
/// Simulates a mutex try_unlock_upgrade_and_lock() operation.
/// Equivalent to "return true;"
bool try_unlock_upgrade_and_lock()
{
return true;
}
#ifdef BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_unlock_upgrade_and_lock_until() operation.
/// Equivalent to "return true;"
template
bool try_unlock_upgrade_and_lock_until(chrono::time_point const &)
{
return true;
}
/// Simulates a mutex try_unlock_upgrade_and_lock_for() operation.
/// Equivalent to "return true;"
template
bool try_unlock_upgrade_and_lock_for(chrono::duration const &)
{
return true;
}
#endif
/// Simulates unlock_upgrade_and_lock_shared().
/// Empty function.
void unlock_upgrade_and_lock_shared()
{
}
};
} //namespace boost {
#endif