Files
externals/linux/include/ActivBoost/thread/null_mutex.hpp
T
2023-12-15 13:15:08 -05:00

244 lines
6.3 KiB
C++

//////////////////////////////////////////////////////////////////////////////
//
// (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 ACTIV_BOOST_THREAD_NULL_MUTEX_HPP
#define ACTIV_BOOST_THREAD_NULL_MUTEX_HPP
#include <ActivBoost/thread/detail/config.hpp>
#include <ActivBoost/thread/detail/delete.hpp>
#include <ActivBoost/chrono/chrono.hpp>
/// \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:
ACTIV_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 ACTIV_BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_lock_until() operation.
/// Equivalent to "return true;"
template <typename Clock, typename Duration>
bool try_lock_until(chrono::time_point<Clock, Duration> const &)
{
return true;
}
/// Simulates a mutex try_lock_for() operation.
/// Equivalent to "return true;"
template <typename Rep, typename Period>
bool try_lock_for(chrono::duration<Rep, Period> 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 <typename Clock, typename Duration>
bool try_lock_shared_until(chrono::time_point<Clock, Duration> const &)
{
return true;
}
/// Simulates a mutex try_lock_shared_for() operation.
/// Equivalent to "return true;"
template <typename Rep, typename Period>
bool try_lock_shared_for(chrono::duration<Rep, Period> 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 <typename Clock, typename Duration>
bool try_lock_upgrade_until(chrono::time_point<Clock, Duration> const &)
{
return true;
}
/// Simulates a mutex try_lock_upgrade_for() operation.
/// Equivalent to "return true;"
template <typename Rep, typename Period>
bool try_lock_upgrade_for(chrono::duration<Rep, Period> 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 ACTIV_BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_unlock_shared_and_lock_until() operation.
/// Equivalent to "return true;"
template <typename Clock, typename Duration>
bool try_unlock_shared_and_lock_until(chrono::time_point<Clock, Duration> const &)
{
return true;
}
/// Simulates a mutex try_unlock_shared_and_lock_for() operation.
/// Equivalent to "return true;"
template <typename Rep, typename Period>
bool try_unlock_shared_and_lock_for(chrono::duration<Rep, Period> 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 ACTIV_BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_unlock_shared_and_lock_upgrade_until() operation.
/// Equivalent to "return true;"
template <typename Clock, typename Duration>
bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point<Clock, Duration> const &)
{
return true;
}
/// Simulates a mutex try_unlock_shared_and_lock_upgrade_for() operation.
/// Equivalent to "return true;"
template <typename Rep, typename Period>
bool try_unlock_shared_and_lock_upgrade_for(chrono::duration<Rep, Period> 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 ACTIV_BOOST_THREAD_USES_CHRONO
/// Simulates a mutex try_unlock_upgrade_and_lock_until() operation.
/// Equivalent to "return true;"
template <typename Clock, typename Duration>
bool try_unlock_upgrade_and_lock_until(chrono::time_point<Clock, Duration> const &)
{
return true;
}
/// Simulates a mutex try_unlock_upgrade_and_lock_for() operation.
/// Equivalent to "return true;"
template <typename Rep, typename Period>
bool try_unlock_upgrade_and_lock_for(chrono::duration<Rep, Period> const &)
{
return true;
}
#endif
/// Simulates unlock_upgrade_and_lock_shared().
/// Empty function.
void unlock_upgrade_and_lock_shared()
{
}
};
} //namespace Boost {
#endif