Squashed 'boost/' content from commit b4feb19f2

git-subtree-dir: boost
git-subtree-split: b4feb19f287ee92d87a9624b5d36b7cf46aeadeb

boost/interprocess/sync/detail/common_algorithms.hpp

@@ -0,0 +1,81 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2013. 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_SYNC_DETAIL_COMMON_ALGORITHMS_HPP
+#define BOOST_INTERPROCESS_SYNC_DETAIL_COMMON_ALGORITHMS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/sync/spin/wait.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+template<class MutexType>
+bool try_based_timed_lock(MutexType &m, const boost::posix_time::ptime &abs_time)
+{
+   //Same as lock()
+   if(abs_time == boost::posix_time::pos_infin){
+      m.lock();
+      return true;
+   }
+   //Always try to lock to achieve POSIX guarantees:
+   // "Under no circumstance shall the function fail with a timeout if the mutex
+   //  can be locked immediately. The validity of the abs_timeout parameter need not
+   //  be checked if the mutex can be locked immediately."
+   else if(m.try_lock()){
+      return true;
+   }
+   else{
+      spin_wait swait;
+      while(microsec_clock::universal_time() < abs_time){
+         if(m.try_lock()){
+            return true;
+         }
+         swait.yield();
+      }
+      return false;
+   }
+}
+
+template<class MutexType>
+void try_based_lock(MutexType &m)
+{
+   if(!m.try_lock()){
+      spin_wait swait;
+      do{
+         if(m.try_lock()){
+            break;
+         }
+         else{
+            swait.yield();
+         }
+      }
+      while(1);
+   }
+}
+
+}  //namespace ipcdetail
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_SYNC_DETAIL_COMMON_ALGORITHMS_HPP

boost/interprocess/sync/detail/locks.hpp

@@ -0,0 +1,101 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-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_DETAIL_LOCKS_HPP
+#define BOOST_INTERPROCESS_DETAIL_LOCKS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+template<class Lock>
+class internal_mutex_lock
+{
+   typedef void (internal_mutex_lock::*unspecified_bool_type)();
+   public:
+
+   typedef typename Lock::mutex_type::internal_mutex_type  mutex_type;
+
+
+   internal_mutex_lock(Lock &l)
+      : l_(l)
+   {}
+
+   mutex_type* mutex() const
+   {  return l_ ? &l_.mutex()->internal_mutex() : 0;  }
+
+   void lock()    { l_.lock(); }
+
+   void unlock()  { l_.unlock(); }
+
+   operator unspecified_bool_type() const
+   {  return l_ ? &internal_mutex_lock::lock : 0;  }
+
+   private:
+   Lock &l_;
+};
+
+template <class Lock>
+class lock_inverter
+{
+   Lock &l_;
+   public:
+   lock_inverter(Lock &l)
+      :  l_(l)
+   {}
+   void lock()    {   l_.unlock();   }
+   void unlock()  {   l_.lock();     }
+};
+
+template <class Lock>
+class lock_to_sharable
+{
+   Lock &l_;
+
+   public:
+   explicit lock_to_sharable(Lock &l)
+      :  l_(l)
+   {}
+   void lock()    {  l_.lock_sharable();     }
+   bool try_lock(){  return l_.try_lock_sharable(); }
+   void unlock()  {  l_.unlock_sharable();   }
+};
+
+template <class Lock>
+class lock_to_wait
+{
+   Lock &l_;
+
+   public:
+   explicit lock_to_wait(Lock &l)
+      :  l_(l)
+   {}
+   void lock()    {  l_.wait();     }
+   bool try_lock(){  return l_.try_wait(); }
+};
+
+}  //namespace ipcdetail
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_LOCKS_HPP