////////////////////////////////////////////////////////////////////////////// // // (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