Imported Upstream version 1.57.0upstream/1.57.0

7 files changed, 305 insertions, 294 deletions

diff --git a/boost/interprocess/sync/shm/named_condition.hpp b/boost/interprocess/sync/shm/named_condition.hpp
index 9d7cd77e11..e2ff280b7b 100644
--- a/boost/interprocess/sync/shm/named_condition.hpp
+++ b/boost/interprocess/sync/shm/named_condition.hpp
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2011. Distributed under the Boost
+// (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)
 //
@@ -11,7 +11,7 @@
 #ifndef BOOST_INTERPROCESS_SHM_NAMED_CONDITION_HPP
 #define BOOST_INTERPROCESS_SHM_NAMED_CONDITION_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
 #  pragma once
 #endif
 
@@ -29,8 +29,11 @@
 #include <boost/interprocess/sync/named_mutex.hpp>
 #include <boost/interprocess/permissions.hpp>
 #if defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
-#include <boost/interprocess/sync/interprocess_mutex.hpp>
-#include <boost/interprocess/sync/scoped_lock.hpp>
+   #include <boost/interprocess/sync/interprocess_mutex.hpp>
+   #include <boost/interprocess/sync/scoped_lock.hpp>
+   #include <boost/interprocess/sync/detail/condition_any_algorithm.hpp>
+#else
+   #include <boost/interprocess/sync/detail/locks.hpp>
 #endif
 
 
@@ -41,21 +44,21 @@ namespace boost {
 namespace interprocess {
 namespace ipcdetail {
 
-/// @cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 class interprocess_tester;
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 //! A global condition variable that can be created by name.
 //! This condition variable is designed to work with named_mutex and
 //! can't be placed in shared memory or memory mapped files.
 class shm_named_condition
 {
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    //Non-copyable
    shm_named_condition();
    shm_named_condition(const shm_named_condition &);
    shm_named_condition &operator=(const shm_named_condition &);
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
    public:
    //!Creates a global condition with a name.
    //!If the condition can't be created throws interprocess_exception
@@ -119,113 +122,44 @@ class shm_named_condition
    //!Returns false on error. Never throws.
    static bool remove(const char *name);
 
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    private:
 
-   struct condition_holder
+   #if defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
+   class internal_condition_members
    {
-      interprocess_condition cond_;
-      //If named_mutex is implemented using semaphores
-      //we need to store an additional mutex
-      #if defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
-      interprocess_mutex mutex_;
-      #endif
-   };
+      public:
+      typedef interprocess_mutex       mutex_type;
+      typedef interprocess_condition   condvar_type;
 
-   interprocess_condition *condition() const
-   {  return &static_cast<condition_holder*>(m_shmem.get_user_address())->cond_; }
+      condvar_type&  get_condvar() {  return m_cond;  }
+      mutex_type&    get_mutex()   {  return m_mtx; }
 
-   template <class Lock>
-   class lock_inverter
-   {
-      Lock &l_;
-      public:
-      lock_inverter(Lock &l)
-         :  l_(l)
-      {}
-      void lock()    {   l_.unlock();   }
-      void unlock()  {   l_.lock();     }
+      private:
+      mutex_type     m_mtx;
+      condvar_type   m_cond;
    };
 
-   //If named mutex uses POSIX semaphores, then the shm based condition variable
-   //must use it's internal lock to wait, as sem_t does not store a pthread_mutex_t
-   //instance needed by pthread_mutex_cond_t
-   #if defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
-      interprocess_mutex *mutex() const
-      {  return &static_cast<condition_holder*>(m_shmem.get_user_address())->mutex_; }
-
-      template <class Lock>
-      void do_wait(Lock& lock)
-      {
-         //shm_named_condition only works with named_mutex
-         BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
-        
-         //lock internal before unlocking external to avoid race with a notifier
-         scoped_lock<interprocess_mutex>     internal_lock(*this->mutex());
-         lock_inverter<Lock> inverted_lock(lock);
-         scoped_lock<lock_inverter<Lock> >   external_unlock(inverted_lock);
-
-         //unlock internal first to avoid deadlock with near simultaneous waits
-         scoped_lock<interprocess_mutex>     internal_unlock;
-         internal_lock.swap(internal_unlock);
-         this->condition()->wait(internal_unlock);
-      }
-
-      template <class Lock>
-      bool do_timed_wait(Lock& lock, const boost::posix_time::ptime &abs_time)
-      {
-         //shm_named_condition only works with named_mutex
-         BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
-         //lock internal before unlocking external to avoid race with a notifier 
-         scoped_lock<interprocess_mutex>     internal_lock(*this->mutex(), abs_time); 
-         if(!internal_lock) return false;
-         lock_inverter<Lock> inverted_lock(lock); 
-         scoped_lock<lock_inverter<Lock> >   external_unlock(inverted_lock); 
-
-         //unlock internal first to avoid deadlock with near simultaneous waits 
-         scoped_lock<interprocess_mutex>     internal_unlock; 
-         internal_lock.swap(internal_unlock); 
-         return this->condition()->timed_wait(internal_unlock, abs_time); 
-      }
-   #else //defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
-      template<class Lock>
-      class lock_wrapper
-      {
-         typedef void (lock_wrapper::*unspecified_bool_type)();
-         public:
-
-         typedef interprocess_mutex mutex_type;
-
-         lock_wrapper(Lock &l)
-            : l_(l)
-         {}
-
-         mutex_type* mutex() const
-         {  return l_.mutex()->mutex();  }
-
-         void lock()    { l_.lock(); }
-
-         void unlock()  { l_.unlock(); }
-
-         operator unspecified_bool_type() const
-         {  return l_ ? &lock_wrapper::lock : 0;  }
-
-         private:
-         Lock &l_;
-      };
+   typedef ipcdetail::condition_any_wrapper<internal_condition_members> internal_condition;
+   #else    //defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
+   typedef interprocess_condition internal_condition;
    #endif   //defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
 
+   internal_condition &internal_cond()
+   {  return *static_cast<internal_condition*>(m_shmem.get_user_address()); }
+
    friend class boost::interprocess::ipcdetail::interprocess_tester;
    void dont_close_on_destruction();
 
-   managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::managed_open_or_create_impl<shared_memory_object, 0, true, false> open_create_impl_t;
+   open_create_impl_t m_shmem;
 
    template <class T, class Arg> friend class boost::interprocess::ipcdetail::named_creation_functor;
-   typedef boost::interprocess::ipcdetail::named_creation_functor<condition_holder> construct_func_t;
-   /// @endcond
+   typedef boost::interprocess::ipcdetail::named_creation_functor<internal_condition> construct_func_t;
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 
-/// @cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
 inline shm_named_condition::~shm_named_condition()
 {}
@@ -233,9 +167,8 @@ inline shm_named_condition::~shm_named_condition()
 inline shm_named_condition::shm_named_condition(create_only_t, const char *name, const permissions &perm)
    :  m_shmem  (create_only
                ,name
-               ,sizeof(condition_holder) +
-                  managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+               ,sizeof(internal_condition) +
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(DoCreate)
@@ -245,9 +178,8 @@ inline shm_named_condition::shm_named_condition(create_only_t, const char *name,
 inline shm_named_condition::shm_named_condition(open_or_create_t, const char *name, const permissions &perm)
    :  m_shmem  (open_or_create
                ,name
-               ,sizeof(condition_holder) +
-                  managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+               ,sizeof(internal_condition) +
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(DoOpenOrCreate)
@@ -265,113 +197,34 @@ inline shm_named_condition::shm_named_condition(open_only_t, const char *name)
 inline void shm_named_condition::dont_close_on_destruction()
 {  interprocess_tester::dont_close_on_destruction(m_shmem);  }
 
-#if defined(BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
-
 inline void shm_named_condition::notify_one()
-{
-   scoped_lock<interprocess_mutex> internal_lock(*this->mutex());
-   this->condition()->notify_one();
-}
+{  this->internal_cond().notify_one(); }
 
 inline void shm_named_condition::notify_all()
-{
-   scoped_lock<interprocess_mutex> internal_lock(*this->mutex());
-   this->condition()->notify_all();
-}
+{  this->internal_cond().notify_all(); }
 
 template <typename L>
 inline void shm_named_condition::wait(L& lock)
-{
-   if (!lock)
-      throw lock_exception();
-   this->do_wait(lock);
-}
+{  this->internal_cond().wait(lock); }
 
 template <typename L, typename Pr>
 inline void shm_named_condition::wait(L& lock, Pr pred)
-{
-   if (!lock)
-      throw lock_exception();
-   while (!pred())
-      this->do_wait(lock);
-}
+{  this->internal_cond().wait(lock, pred); }
 
 template <typename L>
 inline bool shm_named_condition::timed_wait
    (L& lock, const boost::posix_time::ptime &abs_time)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->wait(lock);
-      return true;
-   }
-   if (!lock)
-      throw lock_exception();
-   return this->do_timed_wait(lock, abs_time);
-}
+{  return this->internal_cond().timed_wait(lock, abs_time); }
 
 template <typename L, typename Pr>
 inline bool shm_named_condition::timed_wait
    (L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->wait(lock, pred);
-      return true;
-   }
-   if (!lock)
-      throw lock_exception();
-
-   while (!pred()){
-      if(!this->do_timed_wait(lock, abs_time)){
-         return pred();
-      }
-   }
-   return true;
-}
-
-#else
-
-inline void shm_named_condition::notify_one()
-{  this->condition()->notify_one();  }
-
-inline void shm_named_condition::notify_all()
-{  this->condition()->notify_all();  }
-
-template <typename L>
-inline void shm_named_condition::wait(L& lock)
-{
-   lock_wrapper<L> newlock(lock);
-   this->condition()->wait(newlock);
-}
-
-template <typename L, typename Pr>
-inline void shm_named_condition::wait(L& lock, Pr pred)
-{
-   lock_wrapper<L> newlock(lock);
-   this->condition()->wait(newlock, pred);
-}
-
-template <typename L>
-inline bool shm_named_condition::timed_wait
-   (L& lock, const boost::posix_time::ptime &abs_time)
-{
-   lock_wrapper<L> newlock(lock);
-   return this->condition()->timed_wait(newlock, abs_time);
-}
-
-template <typename L, typename Pr>
-inline bool shm_named_condition::timed_wait
-   (L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
-{
-   lock_wrapper<L> newlock(lock);
-   return this->condition()->timed_wait(newlock, abs_time, pred);
-}
-
-#endif
+{  return this->internal_cond().timed_wait(lock, abs_time, pred); }
 
 inline bool shm_named_condition::remove(const char *name)
 {  return shared_memory_object::remove(name); }
 
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 }  //namespace ipcdetail
 }  //namespace interprocess
diff --git a/boost/interprocess/sync/shm/named_condition_any.hpp b/boost/interprocess/sync/shm/named_condition_any.hpp
new file mode 100644
index 0000000000..46bca92e45
--- /dev/null
+++ b/boost/interprocess/sync/shm/named_condition_any.hpp
@@ -0,0 +1,191 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_SHM_NAMED_CONDITION_ANY_HPP
+#define BOOST_INTERPROCESS_SHM_NAMED_CONDITION_ANY_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/sync/interprocess_condition.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/shm/named_creation_functor.hpp>
+#include <boost/interprocess/sync/named_mutex.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/sync/detail/condition_any_algorithm.hpp>
+
+//!\file
+//!Describes process-shared variables interprocess_condition class
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+class interprocess_tester;
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+
+//! A global condition variable that can be created by name.
+//! This condition variable is designed to work with named_mutex and
+//! can't be placed in shared memory or memory mapped files.
+class shm_named_condition_any
+{
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+   //Non-copyable
+   shm_named_condition_any();
+   shm_named_condition_any(const shm_named_condition_any &);
+   shm_named_condition_any &operator=(const shm_named_condition_any &);
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   public:
+   //!Creates a global condition with a name.
+   //!If the condition can't be created throws interprocess_exception
+   shm_named_condition_any(create_only_t create_only, const char *name, const permissions &perm = permissions())
+      :  m_shmem  (create_only
+                  ,name
+                  ,sizeof(internal_condition) +
+                     open_create_impl_t::ManagedOpenOrCreateUserOffset
+                  ,read_write
+                  ,0
+                  ,construct_func_t(DoCreate)
+                  ,perm)
+   {}
+
+   //!Opens or creates a global condition with a name.
+   //!If the condition is created, this call is equivalent to
+   //!shm_named_condition_any(create_only_t, ... )
+   //!If the condition is already created, this call is equivalent
+   //!shm_named_condition_any(open_only_t, ... )
+   //!Does not throw
+   shm_named_condition_any(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions())
+      :  m_shmem  (open_or_create
+                  ,name
+                  ,sizeof(internal_condition) +
+                     open_create_impl_t::ManagedOpenOrCreateUserOffset
+                  ,read_write
+                  ,0
+                  ,construct_func_t(DoOpenOrCreate)
+                  ,perm)
+   {}
+
+   //!Opens a global condition with a name if that condition is previously
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   shm_named_condition_any(open_only_t open_only, const char *name)
+      :  m_shmem  (open_only
+                  ,name
+                  ,read_write
+                  ,0
+                  ,construct_func_t(DoOpen))
+   {}
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~shm_named_condition_any()
+   {}
+
+   //!If there is a thread waiting on *this, change that
+   //!thread's state to ready. Otherwise there is no effect.*/
+   void notify_one()
+   {  m_cond.notify_one(); }
+
+   //!Change the state of all threads waiting on *this to ready.
+   //!If there are no waiting threads, notify_all() has no effect.
+   void notify_all()
+   {  m_cond.notify_all(); }
+
+   //!Releases the lock on the named_mutex object associated with lock, blocks
+   //!the current thread of execution until readied by a call to
+   //!this->notify_one() or this->notify_all(), and then reacquires the lock.
+   template <typename L>
+   void wait(L& lock)
+   {  m_cond.wait(lock); }
+
+   //!The same as:
+   //!while (!pred()) wait(lock)
+   template <typename L, typename Pr>
+   void wait(L& lock, Pr pred)
+   {  m_cond.wait(lock, pred); }
+
+   //!Releases the lock on the named_mutex object associated with lock, blocks
+   //!the current thread of execution until readied by a call to
+   //!this->notify_one() or this->notify_all(), or until time abs_time is reached,
+   //!and then reacquires the lock.
+   //!Returns: false if time abs_time is reached, otherwise true.
+   template <typename L>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time)
+   {  return m_cond.timed_wait(lock, abs_time); }
+
+   //!The same as:   while (!pred()) {
+   //!                  if (!timed_wait(lock, abs_time)) return pred();
+   //!               } return true;
+   template <typename L, typename Pr>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+   {  return m_cond.timed_wait(lock, abs_time, pred); }
+
+   //!Erases a named condition from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name)
+   {  return shared_memory_object::remove(name); }
+
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+   private:
+
+   class internal_condition_members
+   {
+      public:
+      typedef interprocess_mutex       mutex_type;
+      typedef interprocess_condition   condvar_type;
+
+      condvar_type&  get_condvar() {  return m_cond;  }
+      mutex_type&    get_mutex()   {  return m_mtx; }
+
+      private:
+      mutex_type     m_mtx;
+      condvar_type   m_cond;
+   };
+
+   typedef ipcdetail::condition_any_wrapper<internal_condition_members> internal_condition;
+
+   internal_condition m_cond;
+
+   friend class boost::interprocess::ipcdetail::interprocess_tester;
+   void dont_close_on_destruction()
+   {  interprocess_tester::dont_close_on_destruction(m_shmem);  }
+
+   typedef ipcdetail::managed_open_or_create_impl<shared_memory_object, 0, true, false> open_create_impl_t;
+   open_create_impl_t m_shmem;
+
+   template <class T, class Arg> friend class boost::interprocess::ipcdetail::named_creation_functor;
+   typedef boost::interprocess::ipcdetail::named_creation_functor<internal_condition> construct_func_t;
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+};
+
+}  //namespace ipcdetail
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_SHM_NAMED_CONDITION_ANY_HPP
diff --git a/boost/interprocess/sync/shm/named_creation_functor.hpp b/boost/interprocess/sync/shm/named_creation_functor.hpp
index 9d752c837a..234e072aac 100644
--- a/boost/interprocess/sync/shm/named_creation_functor.hpp
+++ b/boost/interprocess/sync/shm/named_creation_functor.hpp
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2007-2011. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2007-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)
 //
@@ -11,6 +11,10 @@
 #ifndef BOOST_INTERPROCESS_SYNC_NAMED_CREATION_FUNCTOR_HPP
 #define BOOST_INTERPROCESS_SYNC_NAMED_CREATION_FUNCTOR_HPP
 
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
 #include <boost/interprocess/creation_tags.hpp>
 #include <boost/interprocess/detail/type_traits.hpp>
 #include <boost/interprocess/detail/mpl.hpp>
@@ -38,7 +42,7 @@ class named_creation_functor
    {  new(address)T(m_arg); }
 
    bool operator()(void *address, std::size_t, bool created) const
-   {  
+   {
       switch(m_creation_type){
          case DoOpen:
             return true;
@@ -56,6 +60,10 @@ class named_creation_functor
          break;
       }
    }
+
+   std::size_t get_min_size() const
+   {  return sizeof(T);  }
+
    private:
    create_enum_t m_creation_type;
    Arg m_arg;
diff --git a/boost/interprocess/sync/shm/named_mutex.hpp b/boost/interprocess/sync/shm/named_mutex.hpp
index f32fa70044..fc66f3a704 100644
--- a/boost/interprocess/sync/shm/named_mutex.hpp
+++ b/boost/interprocess/sync/shm/named_mutex.hpp
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2011. Distributed under the Boost
+// (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)
 //
@@ -11,7 +11,7 @@
 #ifndef BOOST_INTERPROCESS_SHM_NAMED_MUTEX_HPP
 #define BOOST_INTERPROCESS_SHM_NAMED_MUTEX_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
 #  pragma once
 #endif
 
@@ -42,14 +42,14 @@ class named_condition;
 //!each process should have it's own named mutex.
 class shm_named_mutex
 {
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
    //Non-copyable
    shm_named_mutex();
    shm_named_mutex(const shm_named_mutex &);
    shm_named_mutex &operator=(const shm_named_mutex &);
    friend class named_condition;
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    public:
    //!Creates a global interprocess_mutex with a name.
@@ -99,20 +99,21 @@ class shm_named_mutex
    //!Returns false on error. Never throws.
    static bool remove(const char *name);
 
-   /// @cond
-   interprocess_mutex *mutex() const
-   {  return static_cast<interprocess_mutex*>(m_shmem.get_user_address()); }
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+   typedef interprocess_mutex internal_mutex_type;
+   interprocess_mutex &internal_mutex()
+   {  return *static_cast<interprocess_mutex*>(m_shmem.get_user_address()); }
 
    private:
    friend class ipcdetail::interprocess_tester;
    void dont_close_on_destruction();
-
-   ipcdetail::managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::managed_open_or_create_impl<shared_memory_object, 0, true, false> open_create_impl_t;
+   open_create_impl_t m_shmem;
    typedef ipcdetail::named_creation_functor<interprocess_mutex> construct_func_t;
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 
-/// @cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
 inline void shm_named_mutex::dont_close_on_destruction()
 {  ipcdetail::interprocess_tester::dont_close_on_destruction(m_shmem);  }
@@ -124,8 +125,7 @@ inline shm_named_mutex::shm_named_mutex(create_only_t, const char *name, const p
    :  m_shmem  (create_only
                ,name
                ,sizeof(interprocess_mutex) +
-                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(ipcdetail::DoCreate)
@@ -136,8 +136,7 @@ inline shm_named_mutex::shm_named_mutex(open_or_create_t, const char *name, cons
    :  m_shmem  (open_or_create
                ,name
                ,sizeof(interprocess_mutex) +
-                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(ipcdetail::DoOpenOrCreate)
@@ -153,27 +152,21 @@ inline shm_named_mutex::shm_named_mutex(open_only_t, const char *name)
 {}
 
 inline void shm_named_mutex::lock()
-{  this->mutex()->lock();  }
+{  this->internal_mutex().lock();  }
 
 inline void shm_named_mutex::unlock()
-{  this->mutex()->unlock();  }
+{  this->internal_mutex().unlock();  }
 
 inline bool shm_named_mutex::try_lock()
-{  return this->mutex()->try_lock();  }
+{  return this->internal_mutex().try_lock();  }
 
 inline bool shm_named_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->lock();
-      return true;
-   }
-   return this->mutex()->timed_lock(abs_time);
-}
+{  return this->internal_mutex().timed_lock(abs_time);   }
 
 inline bool shm_named_mutex::remove(const char *name)
 {  return shared_memory_object::remove(name); }
 
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 }  //namespace ipcdetail {
 }  //namespace interprocess {
diff --git a/boost/interprocess/sync/shm/named_recursive_mutex.hpp b/boost/interprocess/sync/shm/named_recursive_mutex.hpp
index 7235571254..988ef66315 100644
--- a/boost/interprocess/sync/shm/named_recursive_mutex.hpp
+++ b/boost/interprocess/sync/shm/named_recursive_mutex.hpp
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2011. Distributed under the Boost
+// (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)
 //
@@ -11,7 +11,7 @@
 #ifndef BOOST_INTERPROCESS_SHM_NAMED_RECURSIVE_MUTEX_HPP
 #define BOOST_INTERPROCESS_SHM_NAMED_RECURSIVE_MUTEX_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
 #  pragma once
 #endif
 
@@ -33,18 +33,18 @@ namespace boost {
 namespace interprocess {
 namespace ipcdetail {
 
-/// @cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 class interprocess_tester;
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 class shm_named_recursive_mutex
 {
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    //Non-copyable
    shm_named_recursive_mutex();
    shm_named_recursive_mutex(const shm_named_recursive_mutex &);
    shm_named_recursive_mutex &operator=(const shm_named_recursive_mutex &);
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
    public:
 
    //!Creates a global recursive_mutex with a name.
@@ -94,17 +94,17 @@ class shm_named_recursive_mutex
    //!from the system
    static bool remove(const char *name);
 
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    private:
    friend class interprocess_tester;
    void dont_close_on_destruction();
 
    interprocess_recursive_mutex *mutex() const
    {  return static_cast<interprocess_recursive_mutex*>(m_shmem.get_user_address()); }
-
-   managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::managed_open_or_create_impl<shared_memory_object, 0, true, false> open_create_impl_t;
+   open_create_impl_t m_shmem;
    typedef named_creation_functor<interprocess_recursive_mutex> construct_func_t;
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 
 inline shm_named_recursive_mutex::~shm_named_recursive_mutex()
@@ -117,8 +117,7 @@ inline shm_named_recursive_mutex::shm_named_recursive_mutex(create_only_t, const
    :  m_shmem  (create_only
                ,name
                ,sizeof(interprocess_recursive_mutex) +
-                  managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(DoCreate)
@@ -129,8 +128,7 @@ inline shm_named_recursive_mutex::shm_named_recursive_mutex(open_or_create_t, co
    :  m_shmem  (open_or_create
                ,name
                ,sizeof(interprocess_recursive_mutex) +
-                  managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(DoOpenOrCreate)
@@ -155,13 +153,7 @@ inline bool shm_named_recursive_mutex::try_lock()
 {  return this->mutex()->try_lock();  }
 
 inline bool shm_named_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->lock();
-      return true;
-   }
-   return this->mutex()->timed_lock(abs_time);
-}
+{  return this->mutex()->timed_lock(abs_time);  }
 
 inline bool shm_named_recursive_mutex::remove(const char *name)
 {  return shared_memory_object::remove(name); }
diff --git a/boost/interprocess/sync/shm/named_semaphore.hpp b/boost/interprocess/sync/shm/named_semaphore.hpp
index c6d3830db5..d952d12e14 100644
--- a/boost/interprocess/sync/shm/named_semaphore.hpp
+++ b/boost/interprocess/sync/shm/named_semaphore.hpp
@@ -1,6 +1,6 @@
  //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2011. Distributed under the Boost
+// (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)
 //
@@ -11,7 +11,7 @@
 #ifndef BOOST_INTERPROCESS_SHM_NAMED_SEMAPHORE_HPP
 #define BOOST_INTERPROCESS_SHM_NAMED_SEMAPHORE_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
 #  pragma once
 #endif
 
@@ -33,13 +33,13 @@ namespace ipcdetail {
 
 class shm_named_semaphore
 {
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
    //Non-copyable
    shm_named_semaphore();
    shm_named_semaphore(const shm_named_semaphore &);
    shm_named_semaphore &operator=(const shm_named_semaphore &);
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    public:
    shm_named_semaphore(create_only_t, const char *name, unsigned int initialCount, const permissions &perm = permissions());
@@ -57,7 +57,7 @@ class shm_named_semaphore
 
    static bool remove(const char *name);
 
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    private:
    friend class interprocess_tester;
    void dont_close_on_destruction();
@@ -65,9 +65,10 @@ class shm_named_semaphore
    interprocess_semaphore *semaphore() const
    {  return static_cast<interprocess_semaphore*>(m_shmem.get_user_address()); }
 
-   managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::managed_open_or_create_impl<shared_memory_object, 0, true, false> open_create_impl_t;
+   open_create_impl_t m_shmem;
    typedef named_creation_functor<interprocess_semaphore, int> construct_func_t;
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 
 inline shm_named_semaphore::~shm_named_semaphore()
@@ -81,8 +82,7 @@ inline shm_named_semaphore::shm_named_semaphore
    :  m_shmem  (create_only
                ,name
                ,sizeof(interprocess_semaphore) +
-                  managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(DoCreate, initialCount)
@@ -94,8 +94,7 @@ inline shm_named_semaphore::shm_named_semaphore
    :  m_shmem  (open_or_create
                ,name
                ,sizeof(interprocess_semaphore) +
-                  managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(DoOpenOrCreate, initialCount)
@@ -121,13 +120,7 @@ inline bool shm_named_semaphore::try_wait()
 {  return semaphore()->try_wait();   }
 
 inline bool shm_named_semaphore::timed_wait(const boost::posix_time::ptime &abs_time)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->wait();
-      return true;
-   }
-   return semaphore()->timed_wait(abs_time);
-}
+{  return semaphore()->timed_wait(abs_time); }
 
 inline bool shm_named_semaphore::remove(const char *name)
 {  return shared_memory_object::remove(name); }
diff --git a/boost/interprocess/sync/shm/named_upgradable_mutex.hpp b/boost/interprocess/sync/shm/named_upgradable_mutex.hpp
index 0975a6ed2b..4c397927fb 100644
--- a/boost/interprocess/sync/shm/named_upgradable_mutex.hpp
+++ b/boost/interprocess/sync/shm/named_upgradable_mutex.hpp
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2011. Distributed under the Boost
+// (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)
 //
@@ -11,7 +11,7 @@
 #ifndef BOOST_INTERPROCESS_NAMED_UPGRADABLE_MUTEX_HPP
 #define BOOST_INTERPROCESS_NAMED_UPGRADABLE_MUTEX_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
 #  pragma once
 #endif
 
@@ -32,9 +32,9 @@
 namespace boost {
 namespace interprocess {
 
-/// @cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 namespace ipcdetail{ class interprocess_tester; }
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 class named_condition;
 
@@ -43,13 +43,13 @@ class named_condition;
 //!each process should have it's own named upgradable mutex.
 class named_upgradable_mutex
 {
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    //Non-copyable
    named_upgradable_mutex();
    named_upgradable_mutex(const named_upgradable_mutex &);
    named_upgradable_mutex &operator=(const named_upgradable_mutex &);
    friend class named_condition;
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
    public:
 
    //!Creates a global upgradable mutex with a name.
@@ -221,7 +221,7 @@ class named_upgradable_mutex
    //!Returns false on error. Never throws.
    static bool remove(const char *name);
 
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    private:
    friend class ipcdetail::interprocess_tester;
    void dont_close_on_destruction();
@@ -229,12 +229,13 @@ class named_upgradable_mutex
    interprocess_upgradable_mutex *mutex() const
    {  return static_cast<interprocess_upgradable_mutex*>(m_shmem.get_user_address()); }
 
-   ipcdetail::managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::managed_open_or_create_impl<shared_memory_object, 0, true, false> open_create_impl_t;
+   open_create_impl_t m_shmem;
    typedef ipcdetail::named_creation_functor<interprocess_upgradable_mutex> construct_func_t;
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 
-/// @cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
 inline named_upgradable_mutex::~named_upgradable_mutex()
 {}
@@ -244,8 +245,7 @@ inline named_upgradable_mutex::named_upgradable_mutex
    :  m_shmem  (create_only
                ,name
                ,sizeof(interprocess_upgradable_mutex) +
-                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(ipcdetail::DoCreate)
@@ -257,8 +257,7 @@ inline named_upgradable_mutex::named_upgradable_mutex
    :  m_shmem  (open_or_create
                ,name
                ,sizeof(interprocess_upgradable_mutex) +
-                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
-                     ManagedOpenOrCreateUserOffset
+                  open_create_impl_t::ManagedOpenOrCreateUserOffset
                ,read_write
                ,0
                ,construct_func_t(ipcdetail::DoOpenOrCreate)
@@ -288,13 +287,7 @@ inline bool named_upgradable_mutex::try_lock()
 
 inline bool named_upgradable_mutex::timed_lock
    (const boost::posix_time::ptime &abs_time)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->lock();
-      return true;
-   }
-   return this->mutex()->timed_lock(abs_time);
-}
+{  return this->mutex()->timed_lock(abs_time);  }
 
 inline void named_upgradable_mutex::lock_upgradable()
 {  this->mutex()->lock_upgradable();  }
@@ -307,13 +300,7 @@ inline bool named_upgradable_mutex::try_lock_upgradable()
 
 inline bool named_upgradable_mutex::timed_lock_upgradable
    (const boost::posix_time::ptime &abs_time)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->lock_upgradable();
-      return true;
-   }
-   return this->mutex()->timed_lock_upgradable(abs_time);
-}
+{  return this->mutex()->timed_lock_upgradable(abs_time);   }
 
 inline void named_upgradable_mutex::lock_sharable()
 {  this->mutex()->lock_sharable();  }
@@ -326,13 +313,7 @@ inline bool named_upgradable_mutex::try_lock_sharable()
 
 inline bool named_upgradable_mutex::timed_lock_sharable
    (const boost::posix_time::ptime &abs_time)
-{
-   if(abs_time == boost::posix_time::pos_infin){
-      this->lock_sharable();
-      return true;
-   }
-   return this->mutex()->timed_lock_sharable(abs_time);
-}
+{  return this->mutex()->timed_lock_sharable(abs_time);  }
 
 inline void named_upgradable_mutex::unlock_and_lock_upgradable()
 {  this->mutex()->unlock_and_lock_upgradable();  }
@@ -362,7 +343,7 @@ inline bool named_upgradable_mutex::try_unlock_sharable_and_lock_upgradable()
 inline bool named_upgradable_mutex::remove(const char *name)
 {  return shared_memory_object::remove(name); }
 
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 }  //namespace interprocess {
 }  //namespace boost {