1 ////////////////////////////////////////////////////////////////////////////// 2 // 3 // (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost 4 // Software License, Version 1.0. (See accompanying file 5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 // 7 // See http://www.boost.org/libs/interprocess for documentation. 8 // 9 ////////////////////////////////////////////////////////////////////////////// 10 11 #ifndef BOOST_INTERPROCESS_NULL_MUTEX_HPP 12 #define BOOST_INTERPROCESS_NULL_MUTEX_HPP 13 14 #ifndef BOOST_CONFIG_HPP 15 # include <boost/config.hpp> 16 #endif 17 # 18 #if defined(BOOST_HAS_PRAGMA_ONCE) 19 # pragma once 20 #endif 21 22 #include <boost/interprocess/detail/config_begin.hpp> 23 #include <boost/interprocess/detail/workaround.hpp> 24 25 26 //!\file 27 //!Describes null_mutex classes 28 29 namespace boost { 30 31 #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) 32 33 namespace posix_time 34 { class ptime; } 35 36 #endif //#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) 37 38 namespace interprocess { 39 40 //!Implements a mutex that simulates a mutex without doing any operation and 41 //!simulates a successful operation. 42 class null_mutex 43 { 44 #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) 45 null_mutex(const null_mutex&); 46 null_mutex &operator= (const null_mutex&); 47 #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED 48 public: 49 50 //!Constructor. 51 //!Empty. null_mutex()52 null_mutex(){} 53 54 //!Destructor. 55 //!Empty. ~null_mutex()56 ~null_mutex(){} 57 58 //!Simulates a mutex lock() operation. Empty function. lock()59 void lock(){} 60 61 //!Simulates a mutex try_lock() operation. 62 //!Equivalent to "return true;" try_lock()63 bool try_lock() 64 { return true; } 65 66 //!Simulates a mutex timed_lock() operation. 67 //!Equivalent to "return true;" timed_lock(const boost::posix_time::ptime &)68 bool timed_lock(const boost::posix_time::ptime &) 69 { return true; } 70 71 //!Simulates a mutex unlock() operation. 72 //!Empty function. unlock()73 void unlock(){} 74 75 //!Simulates a mutex lock_sharable() operation. 76 //!Empty function. lock_sharable()77 void lock_sharable(){} 78 79 //!Simulates a mutex try_lock_sharable() operation. 80 //!Equivalent to "return true;" try_lock_sharable()81 bool try_lock_sharable() 82 { return true; } 83 84 //!Simulates a mutex timed_lock_sharable() operation. 85 //!Equivalent to "return true;" timed_lock_sharable(const boost::posix_time::ptime &)86 bool timed_lock_sharable(const boost::posix_time::ptime &) 87 { return true; } 88 89 //!Simulates a mutex unlock_sharable() operation. 90 //!Empty function. unlock_sharable()91 void unlock_sharable(){} 92 93 //!Simulates a mutex lock_upgradable() operation. 94 //!Empty function. lock_upgradable()95 void lock_upgradable(){} 96 97 //!Simulates a mutex try_lock_upgradable() operation. 98 //!Equivalent to "return true;" try_lock_upgradable()99 bool try_lock_upgradable() 100 { return true; } 101 102 //!Simulates a mutex timed_lock_upgradable() operation. 103 //!Equivalent to "return true;" timed_lock_upgradable(const boost::posix_time::ptime &)104 bool timed_lock_upgradable(const boost::posix_time::ptime &) 105 { return true; } 106 107 //!Simulates a mutex unlock_upgradable() operation. 108 //!Empty function. unlock_upgradable()109 void unlock_upgradable(){} 110 111 //!Simulates unlock_and_lock_upgradable(). 112 //!Empty function. unlock_and_lock_upgradable()113 void unlock_and_lock_upgradable(){} 114 115 //!Simulates unlock_and_lock_sharable(). 116 //!Empty function. unlock_and_lock_sharable()117 void unlock_and_lock_sharable(){} 118 119 //!Simulates unlock_upgradable_and_lock_sharable(). 120 //!Empty function. unlock_upgradable_and_lock_sharable()121 void unlock_upgradable_and_lock_sharable(){} 122 123 //Promotions 124 125 //!Simulates unlock_upgradable_and_lock(). 126 //!Empty function. unlock_upgradable_and_lock()127 void unlock_upgradable_and_lock(){} 128 129 //!Simulates try_unlock_upgradable_and_lock(). 130 //!Equivalent to "return true;" try_unlock_upgradable_and_lock()131 bool try_unlock_upgradable_and_lock() 132 { return true; } 133 134 //!Simulates timed_unlock_upgradable_and_lock(). 135 //!Equivalent to "return true;" timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &)136 bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &) 137 { return true; } 138 139 //!Simulates try_unlock_sharable_and_lock(). 140 //!Equivalent to "return true;" try_unlock_sharable_and_lock()141 bool try_unlock_sharable_and_lock() 142 { return true; } 143 144 //!Simulates try_unlock_sharable_and_lock_upgradable(). 145 //!Equivalent to "return true;" try_unlock_sharable_and_lock_upgradable()146 bool try_unlock_sharable_and_lock_upgradable() 147 { return true; } 148 }; 149 150 } //namespace interprocess { 151 } //namespace boost { 152 153 #include <boost/interprocess/detail/config_end.hpp> 154 155 #endif //BOOST_INTERPROCESS_NULL_MUTEX_HPP 156