[Boost-commit] svn:boost r55213 - sandbox/fmhess/boost/generic_ptr

Subject: [Boost-commit] svn:boost r55213 - sandbox/fmhess/boost/generic_ptr
From: fmhess_at_[hidden]
Date: 2009-07-30 14:43:36

Author: fmhess
Date: 2009-07-27 16:58:37 EDT (Mon, 27 Jul 2009)
New Revision: 55213
URL: http://svn.boost.org/trac/boost/changeset/55213

Log:
First pass a monitor lock classes, based on libpoet code.  Completely untested.

Added:
   sandbox/fmhess/boost/generic_ptr/monitor_locks.hpp   (contents, props changed)

Added: sandbox/fmhess/boost/generic_ptr/monitor_locks.hpp
==============================================================================
--- (empty file)
+++ sandbox/fmhess/boost/generic_ptr/monitor_locks.hpp	2009-07-27 16:58:37 EDT (Mon, 27 Jul 2009)
@@ -0,0 +1,562 @@
+// Extensions of Boost.Thread lock classes, which add support for
+// operator->() and operator*().  Used in conjunction with
+// boost::generic_ptr::monitor.
+
+// Copyright Frank Mori Hess <fmhess_at_[hidden]>  2007, 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)
+
+#ifndef BOOST_GENERIC_PTR_MONITOR_LOCKS_HPP_INCLUDED
+#define BOOST_GENERIC_PTR_MONITOR_LOCKS_HPP_INCLUDED
+
+#include <boost/bind.hpp>
+#include <boost/config.hpp>
+#include <boost/function.hpp>
+#include <boost/generic_ptr/pointer_traits.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/utillity/addressof.hpp>
+#include <boost/utillity/swap.hpp>
+
+namespace boost
+{
+  namespace generic_ptr
+  {
+    namespace detail
+    {
+      template<typename MonitorPtr, typename Lock>
+      class lock_wrapper
+      {
+      public:
+        typedef typename pointer_traits<MonitorPtr>::value_type value_type;
+        typedef MonitorPtr pointer;
+        typedef typename pointer_traits<MonitorPtr>::reference reference;
+
+        lock_wrapper()
+        {}
+        explicit lock_wrapper(MonitorPtr &mon):
+          _mon(mon),
+          _lock(_mon.get_mutex_ref())
+        {}
+        template<typename U>
+        lock_wrapper(MonitorPtr &mon, const U &arg):
+          _mon(mon),
+          _lock(_mon.get_mutex_ref(), arg)
+        {}
+#ifdef BOOST_NO_RVALUE_REFERENCES
+        template<typename OtherLock>
+        lock_wrapper(boost::detail::thread_move_t<OtherLock> other):
+          _mon(other->_mon), _lock(other->_lock.move())
+        {}
+#else // BOOST_NO_RVALUE_REFERENCES
+        template<typename OtherLock>
+        lock_wrapper(OtherLock && other):
+          _mon(std::move(other._mon)), _lock(std::move(other._lock))
+        {}
+#endif // BOOST_NO_RVALUE_REFERENCES
+        // unique/shared_lock interface
+        void swap(lock_wrapper &other)
+        {
+          boost::swap(_mon, other._mon);
+          boost::swap(_lock, other._lock);
+        }
+        void lock()
+        {
+          _lock.lock();
+        }
+        bool try_lock()
+        {
+          return _lock.try_lock();
+        }
+        template<typename Timeout>
+        bool timed_lock(const Timeout &timeout)
+        {
+          return _lock.timed_lock(timeout);
+        }
+        void unlock()
+        {
+          _lock.unlock();
+        }
+        bool owns_lock() const
+        {
+          return _lock.owns_lock();
+        }
+        bool locked() const // backwards compatibility
+        {
+          return owns_lock();
+        }
+        // safe bool idiom, somewhat safer than providing conversion to bool operator
+        typedef Lock * Lock::* unspecified_bool_type;
+        operator unspecified_bool_type() const
+        {
+          return !_lock ? 0 : &_lock;
+        }
+        bool operator!() const
+        {
+          return !_lock;
+        }
+        MonitorPtr* mutex() const
+        {
+          if(!_mon) return 0;
+          return addressof(*_mon);
+        }
+        MonitorPtr* release()
+        {
+          if(!_mon) return 0;
+          MonitorPtr * result = addressof(_mon);
+          _mon.reset();
+          _lock.release();
+          return result;
+        }
+
+        // monitor extensions to lock interface
+        pointer_traits<MonitorPtr>::pointer operator->() const
+        {
+          if(owns_lock() == false)
+          {
+            throw boost::lock_error();
+          }
+          return _mon.get();
+        }
+        reference operator*() const
+        {
+          if(owns_lock() == false)
+          {
+            throw boost::lock_error();
+          }
+          return *_mon;
+        }
+  #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+      protected:
+  #endif // BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+        pointer _mon;
+        typedef typename rebind
+        <
+          typename MonitorPtr::pointer,
+          const typename MonitorPtr::value_type
+        >::other const_wrapped_pointer_type;
+  #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+      private:
+        template<typename Lockable>
+        friend class monitor_shared_lock;
+        template<typename Lockable>
+        friend class monitor_upgrade_lock;
+        template<typename UpgradeLock>
+        friend class monitor_upgrade_to_unique_lock;
+        template<typename M, typename MH, typename L>
+        friend class lock_wrapper;
+  #endif // BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+        // non-copyable
+        lock_wrapper(lock_wrapper &);
+        lock_wrapper& operator=(lock_wrapper&);
+
+        Lock _lock;
+      };
+    }
+
+    template<typename MonitorPtr>
+    class monitor_unique_lock: public detail::lock_wrapper<MonitorPtr,
+      boost::unique_lock<typename MonitorPtr::mutex_type> >
+    {
+      typedef detail::lock_wrapper
+      <
+        MonitorPtr,
+        boost::unique_lock<typename MonitorPtr::mutex_type>
+      > base_class;
+    public:
+      monitor_unique_lock()
+      {}
+      explicit monitor_unique_lock(MonitorPtr &mon): base_class(mon)
+      {}
+      template<typename U>
+      monitor_unique_lock(MonitorPtr &mon, const U &arg):
+        base_class(mon, arg)
+      {}
+      // move constructors
+#ifdef BOOST_NO_RVALUE_REFERENCES
+      monitor_unique_lock(boost::detail::thread_move_t<monitor_unique_lock> other):
+        base_class(other)
+      {}
+      monitor_unique_lock(boost::detail::thread_move_t<monitor_upgrade_lock<MonitorPtr> > other):
+        base_class(other)
+      {}
+
+      // move emulation
+      boost::detail::thread_move_t<monitor_unique_lock> move()
+      {
+        return boost::detail::thread_move_t<monitor_unique_lock>(*this);
+      }
+      template<typename Lock>
+      monitor_unique_lock& operator=(boost::detail::thread_move_t<Lock> other)
+      {
+        monitor_unique_lock(other).swap(*this);
+        return *this;
+      }
+      operator boost::detail::thread_move_t<monitor_unique_lock>()
+      {
+        return move();
+      }
+#else // BOOST_NO_RVALUE_REFERENCES
+      monitor_unique_lock(monitor_unique_lock && other):
+        base_class(std::move(other))
+      {}
+      monitor_unique_lock(monitor_upgrade_lock<MonitorPtr> && other):
+        base_class(std::move(other))
+      {}
+
+      monitor_unique_lock&& move()
+      {
+        return std::move(*this);
+      }
+      template<typename Lock>
+      monitor_unique_lock& operator=(Lock && other)
+      {
+        monitor_unique_lock(std::move(other)).swap(*this);
+        return *this;
+      }
+#endif // BOOST_NO_RVALUE_REFERENCES
+    };
+
+    template<typename MonitorPtr>
+    void swap(monitor_unique_lock<MonitorPtr> &lockA, monitor_unique_lock<MonitorPtr> &lockB)
+    {
+      lockA.swap(lockB);
+    }
+
+    template<typename MonitorPtr>
+    class monitor_shared_lock:
+      public detail::lock_wrapper
+      <
+        MonitorPtr,
+        boost::shared_lock<typename MonitorPtr::mutex_type>
+      >
+    {
+      typedef detail::lock_wrapper
+      <
+        MonitorPtr,
+        boost::shared_lock<typename MonitorPtr::mutex_type>
+      > base_class;
+    public:
+      monitor_shared_lock()
+      {}
+      explicit monitor_shared_lock(MonitorPtr &mon): base_class(mon)
+      {}
+      template<typename U>
+      monitor_shared_lock(MonitorPtr &mon, const U &arg):
+        base_class(mon, arg)
+      {}
+      // move constructors
+#ifdef BOOST_NO_RVALUE_REFERENCES
+      monitor_shared_lock(boost::detail::thread_move_t<monitor_shared_lock> other):
+        base_class(other)
+      {}
+      monitor_shared_lock(boost::detail::thread_move_t<monitor_upgrade_lock<MonitorPtr> > other):
+        base_class(other)
+      {}
+      monitor_shared_lock(boost::detail::thread_move_t<monitor_unique_lock<MonitorPtr> > other):
+        base_class(other)
+      {}
+#else // BOOST_NO_RVALUE_REFERENCES
+      monitor_shared_lock(monitor_shared_lock && other):
+        base_class(std::move(other))
+      {}
+      monitor_shared_lock(monitor_upgrade_lock<MonitorPtr> && other):
+        base_class(std::move(other))
+      {}
+      monitor_shared_lock(monitor_unique_lock<MonitorPtr> && other):
+        base_class(std::move(other))
+      {}
+#endif // BOOST_NO_RVALUE_REFERENCES
+
+      // monitor extensions to lock interface, only allow pointer to const access for shared_lock
+      typename base_class::const_wrapped_pointer_type operator->() const
+      {
+        if(this->owns_lock() == false)
+        {
+          throw boost::lock_error();
+        }
+        return this->_mon.get();
+      }
+      typename pointer_traits<typename base_class::const_wrapped_pointer_type>::reference operator*() const
+      {
+        if(this->owns_lock() == false)
+        {
+          throw boost::lock_error();
+        }
+        return *this->_mon.get();
+      }
+
+      // move emulation
+#ifdef BOOST_NO_RVALUE_REFERENCES
+      boost::detail::thread_move_t<monitor_shared_lock> move()
+      {
+        return boost::detail::thread_move_t<monitor_shared_lock>(*this);
+      }
+      template<typename Lock>
+      monitor_shared_lock& operator=(boost::detail::thread_move_t<Lock> other)
+      {
+        monitor_shared_lock(other).swap(*this);
+        return *this;
+      }
+      operator boost::detail::thread_move_t<monitor_shared_lock>()
+      {
+        return move();
+      }
+#else // BOOST_NO_RVALUE_REFERENCES
+      monitor_shared_lock && move()
+      {
+        return std::move(*this);
+      }
+      template<typename Lock>
+      monitor_shared_lock& operator=(Lock && other)
+      {
+        monitor_shared_lock(std::move(other)).swap(*this);
+        return *this;
+      }
+#endif // BOOST_NO_RVALUE_REFERENCES
+    };
+
+    template<typename MonitorPtr>
+    void swap(monitor_shared_lock<MonitorPtr> &lockA, monitor_shared_lock<MonitorPtr> &lockB)
+    {
+      lockA.swap(lockB);
+    }
+
+    template<typename MonitorPtr>
+    class monitor_upgrade_lock: public detail::lock_wrapper<MonitorPtr,
+      boost::upgrade_lock<typename MonitorPtr::mutex_type> >
+    {
+      typedef detail::lock_wrapper
+      <
+        MonitorPtr,
+        boost::upgrade_lock<typename MonitorPtr::mutex_type>
+      > base_class;
+    public:
+      monitor_upgrade_lock()
+      {}
+      explicit monitor_upgrade_lock(MonitorPtr &mon): base_class(mon)
+      {}
+      template<typename U>
+      monitor_upgrade_lock(MonitorPtr &mon, const U &arg):
+        base_class(mon, arg)
+      {}
+      // move constructors
+#ifdef BOOST_NO_RVALUE_REFERENCES
+      monitor_upgrade_lock(boost::detail::thread_move_t<monitor_upgrade_lock> other):
+        base_class(other)
+      {}
+      monitor_upgrade_lock(boost::detail::thread_move_t<monitor_unique_lock<MonitorPtr> > other):
+        base_class(other)
+      {}
+#else // BOOST_NO_RVALUE_REFERENCES
+      monitor_upgrade_lock(monitor_upgrade_lock && other):
+        base_class(std::move(other))
+      {}
+      monitor_upgrade_lock(monitor_unique_lock<MonitorPtr> && other):
+        base_class(std::move(other))
+      {}
+#endif // BOOST_NO_RVALUE_REFERENCES
+
+      // monitor extensions to lock interface, only allow pointer to const access for upgrade_lock
+      typename base_class::const_wrapped_pointer_type operator->() const
+      {
+        if(this->owns_lock() == false)
+        {
+          throw boost::lock_error();
+        }
+        return this->_mon.get();
+      }
+      const typename pointer_traits<typename base_class::const_wrapped_pointer_type>::reference operator*() const
+      {
+        if(this->owns_lock() == false)
+        {
+          throw boost::lock_error();
+        }
+        return *this->_mon.get();
+      }
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
+      // move emulation
+      boost::detail::thread_move_t<monitor_upgrade_lock> move()
+      {
+        return boost::detail::thread_move_t<monitor_upgrade_lock>(*this);
+      }
+      template<typename Lock>
+      monitor_upgrade_lock& operator=(boost::detail::thread_move_t<Lock> other)
+      {
+        monitor_upgrade_lock(other).swap(*this);
+        return *this;
+      }
+      operator boost::detail::thread_move_t<monitor_upgrade_lock>()
+      {
+        return move();
+      }
+#else // BOOST_NO_RVALUE_REFERENCES
+      monitor_upgrade_lock && move()
+      {
+        return std::move(*this);
+      }
+      template<typename Lock>
+      monitor_upgrade_lock& operator=(Lock && other)
+      {
+        monitor_upgrade_lock(std::move(other)).swap(*this);
+        return *this;
+      }
+#endif // BOOST_NO_RVALUE_REFERENCES
+    };
+
+    template<typename MonitorPtr>
+    void swap(monitor_upgrade_lock<MonitorPtr> &lockA, monitor_upgrade_lock<MonitorPtr> &lockB)
+    {
+      lockA.swap(lockB);
+    }
+
+    template<typename MonitorPtr>
+    class monitor_upgrade_to_unique_lock
+    {
+      typedef boost::upgrade_to_unique_lock<typename MonitorPtr::mutex_type> wrapped_lock_type;
+    public:
+      typedef MonitorPtr monitor_pointer_type;
+
+      explicit monitor_upgrade_to_unique_lock(monitor_upgrade_lock<MonitorPtr> &upgrade_lock):
+        _mon(upgrade_lock._mon),
+        _lock(upgrade_lock._lock)
+      {}
+      // move constructor
+#ifdef BOOST_NO_RVALUE_REFERENCES
+      monitor_upgrade_to_unique_lock(boost::detail::thread_move_t<monitor_upgrade_to_unique_lock> other):
+        _mon(other->_mon), _lock(boost::detail::thread_move_t<wrapped_lock_type>(other->_lock))
+      {}
+#else // BOOST_NO_RVALUE_REFERENCES
+      monitor_upgrade_to_unique_lock(monitor_upgrade_to_unique_lock && other):
+        _mon(std::move(other._mon)), _lock(std::move(other._lock))
+      {}
+#endif // BOOST_NO_RVALUE_REFERENCES
+
+      void swap(monitor_upgrade_to_unique_lock &other)
+      {
+        boost::swap(_mon, other._mon);
+        boost::swap(_lock, other._lock);
+      }
+      bool operator!()
+      {
+        return !_lock;
+      }
+      // safe bool idiom, somewhat safer than providing conversion to bool operator
+      typedef wrapped_lock_type * wrapped_lock_type::* unspecified_bool_type;
+      operator unspecified_bool_type() const
+      {
+        return !_lock ? 0 : &_lock;
+      }
+      bool owns_lock() const
+      {
+        return _lock.owns_lock();
+      }
+
+      // monitor extensions to lock interface
+      MonitorPtr::pointer operator->() const
+      {
+        if(this->owns_lock() == false)
+        {
+          throw boost::lock_error();
+        }
+        return _mon.get();
+      }
+      MonitorPtr::reference operator*() const
+      {
+        if(this->owns_lock() == false)
+        {
+          throw boost::lock_error();
+        }
+        return *_mon.get();
+      }
+
+      // move emulation
+#ifdef BOOST_NO_RVALUE_REFERENCES
+      boost::detail::thread_move_t<monitor_upgrade_to_unique_lock> move()
+      {
+        return boost::detail::thread_move_t<monitor_upgrade_to_unique_lock>(*this);
+      }
+      monitor_upgrade_to_unique_lock& operator=(boost::detail::thread_move_t<monitor_upgrade_to_unique_lock> other)
+      {
+        monitor_upgrade_to_unique_lock(other).swap(*this);
+        return *this;
+      }
+      operator boost::detail::thread_move_t<monitor_upgrade_to_unique_lock>()
+      {
+        return move();
+      }
+#else // BOOST_NO_RVALUE_REFERENCES
+      monitor_upgrade_to_unique_lock && move()
+      {
+        return std::move(*this);
+      }
+      monitor_upgrade_to_unique_lock& operator=(monitor_upgrade_to_unique_lock && other)
+      {
+        monitor_upgrade_to_unique_lock(std::move(other)).swap(*this);
+        return *this;
+      }
+#endif // BOOST_NO_RVALUE_REFERENCES
+    private:
+      monitor_ptr_type _mon;
+      wrapped_lock_type _lock;
+    };
+
+    template<typename MonitorPtr>
+    void swap(monitor_upgrade_to_unique_lock<MonitorPtr> &lockA, monitor_upgrade_to_unique_lock<MonitorPtr> &lockB)
+    {
+      lockA.swap(lockB);
+    }
+
+  };
+
+  template<typename MonitorPtr>
+#ifdef BOOST_NO_RVALUE_REFERENCES
+  boost::detail::thread_move_t<generic_ptr::monitor_unique_lock<MonitorPtr> >
+#else
+  generic_ptr::monitor_unique_lock<MonitorPtr> &&
+#endif
+    move(generic_ptr::monitor_unique_lock<MonitorPtr> &lock)
+  {
+    return lock.move();
+  }
+
+  template<typename MonitorPtr>
+#ifdef BOOST_NO_RVALUE_REFERENCES
+  boost::detail::thread_move_t<generic_ptr::monitor_shared_lock<MonitorPtr> >
+#else
+  generic_ptr::monitor_shared_lock<MonitorPtr> &&
+#endif
+    move(generic_ptr::monitor_shared_lock<MonitorPtr> &lock)
+  {
+    return lock.move();
+  }
+
+  template<typename MonitorPtr>
+#ifdef BOOST_NO_RVALUE_REFERENCES
+  boost::detail::thread_move_t<generic_ptr::monitor_upgrade_lock<MonitorPtr> >
+#else // BOOST_NO_RVALUE_REFERENCES
+  generic_ptr::monitor_upgrade_lock<MonitorPtr> &&
+#endif // BOOST_NO_RVALUE_REFERENCES
+    move(generic_ptr::monitor_upgrade_lock<MonitorPtr> &lock)
+  {
+    return lock.move();
+  }
+
+  template<typename MonitorPtr>
+#ifdef BOOST_NO_RVALUE_REFERENCES
+  boost::detail::thread_move_t<generic_ptr::monitor_upgrade_to_unique_lock<MonitorPtr> >
+#else // BOOST_NO_RVALUE_REFERENCES
+  generic_ptr::monitor_upgrade_to_unique_lock<MonitorPtr> &&
+#endif // BOOST_NO_RVALUE_REFERENCES
+    move(generic_ptr::monitor_upgrade_to_unique_lock<MonitorPtr> &lock)
+  {
+    return lock.move();
+  }
+} // namespace boost
+
+#endif // BOOST_GENERIC_PTR_MONITOR_LOCKS_HPP_INCLUDED