| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2005-2009. 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/interprocess for documentation. |
| // |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_INTERPROCESS_NULL_MUTEX_HPP |
| #define BOOST_INTERPROCESS_NULL_MUTEX_HPP |
| |
| #if (defined _MSC_VER) && (_MSC_VER >= 1200) |
| # pragma once |
| #endif |
| |
| #include <boost/interprocess/detail/config_begin.hpp> |
| #include <boost/interprocess/detail/workaround.hpp> |
| |
| |
| //!\file |
| //!Describes null_mutex classes |
| |
| namespace boost { |
| |
| namespace posix_time |
| { class ptime; } |
| |
| namespace interprocess { |
| |
| //!Implements a mutex that simulates a mutex without doing any operation and |
| //!simulates a successful operation. |
| class null_mutex |
| { |
| /// @cond |
| null_mutex(const null_mutex&); |
| null_mutex &operator= (const null_mutex&); |
| /// @endcond |
| public: |
| |
| //!Constructor. |
| //!Empty. |
| null_mutex(){} |
| |
| //!Destructor. |
| //!Empty. |
| ~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 timed_lock() operation. |
| //!Equivalent to "return true;" |
| bool timed_lock(const boost::posix_time::ptime &) |
| { return true; } |
| |
| //!Simulates a mutex unlock() operation. |
| //!Empty function. |
| void unlock(){} |
| |
| //!Simulates a mutex lock_sharable() operation. |
| //!Empty function. |
| void lock_sharable(){} |
| |
| //!Simulates a mutex try_lock_sharable() operation. |
| //!Equivalent to "return true;" |
| bool try_lock_sharable() |
| { return true; } |
| |
| //!Simulates a mutex timed_lock_sharable() operation. |
| //!Equivalent to "return true;" |
| bool timed_lock_sharable(const boost::posix_time::ptime &) |
| { return true; } |
| |
| //!Simulates a mutex unlock_sharable() operation. |
| //!Empty function. |
| void unlock_sharable(){} |
| |
| //!Simulates a mutex lock_upgradable() operation. |
| //!Empty function. |
| void lock_upgradable(){} |
| |
| //!Simulates a mutex try_lock_upgradable() operation. |
| //!Equivalent to "return true;" |
| bool try_lock_upgradable() |
| { return true; } |
| |
| //!Simulates a mutex timed_lock_upgradable() operation. |
| //!Equivalent to "return true;" |
| bool timed_lock_upgradable(const boost::posix_time::ptime &) |
| { return true; } |
| |
| //!Simulates a mutex unlock_upgradable() operation. |
| //!Empty function. |
| void unlock_upgradable(){} |
| |
| //!Simulates unlock_and_lock_upgradable(). |
| //!Empty function. |
| void unlock_and_lock_upgradable(){} |
| |
| //!Simulates unlock_and_lock_sharable(). |
| //!Empty function. |
| void unlock_and_lock_sharable(){} |
| |
| //!Simulates unlock_upgradable_and_lock_sharable(). |
| //!Empty function. |
| void unlock_upgradable_and_lock_sharable(){} |
| |
| //Promotions |
| |
| //!Simulates unlock_upgradable_and_lock(). |
| //!Empty function. |
| void unlock_upgradable_and_lock(){} |
| |
| //!Simulates try_unlock_upgradable_and_lock(). |
| //!Equivalent to "return true;" |
| bool try_unlock_upgradable_and_lock() |
| { return true; } |
| |
| //!Simulates timed_unlock_upgradable_and_lock(). |
| //!Equivalent to "return true;" |
| bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &) |
| { return true; } |
| |
| //!Simulates try_unlock_sharable_and_lock(). |
| //!Equivalent to "return true;" |
| bool try_unlock_sharable_and_lock() |
| { return true; } |
| |
| //!Simulates try_unlock_sharable_and_lock_upgradable(). |
| //!Equivalent to "return true;" |
| bool try_unlock_sharable_and_lock_upgradable() |
| { return true; } |
| }; |
| |
| } //namespace interprocess { |
| } //namespace boost { |
| |
| #include <boost/interprocess/detail/config_end.hpp> |
| |
| #endif //BOOST_INTERPROCESS_NULL_MUTEX_HPP |