comparison DEPENDENCIES/generic/include/boost/interprocess/sync/null_mutex.hpp @ 16:2665513ce2d3

Add boost headers

+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-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/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