/home/mhx/git/github/libmoost/include/moost/guarded_ptr.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_GUARDED_PTR_HPP__
#define MOOST_GUARDED_PTR_HPP__

#include <cassert>

#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <boost/thread/locks.hpp>

namespace moost {

template<typename T>
class guarded_ptr : boost::noncopyable
{
public:
   typedef T element_type;
   typedef T value_type;
   typedef T * pointer;
   typedef T const * const_pointer;
   typedef T & reference;
   typedef T const & const_reference;

   class shared_access : boost::noncopyable
   {
   public:
      shared_access(guarded_ptr const & guard)
         : m_gptr(guard)
      {
         m_gptr.m_mutex.lock_shared();
      }

      ~shared_access()
      {
         m_gptr.m_mutex.unlock_shared();
      }

      const_reference operator*() const
      {
         return *(m_gptr.m_ptr);
      }
      const_pointer operator->() const
      {
         return m_gptr.m_ptr.get();
      }

   private:
      guarded_ptr const & m_gptr;
   };

   class exclusive_access : boost::noncopyable
   {
   public:
      exclusive_access(guarded_ptr &guard)
         : m_gptr(guard)
      {
         m_gptr.m_mutex.lock();
      }

      ~exclusive_access()
      {
         m_gptr.m_mutex.unlock();
      }

      reference operator*()
      {
         return *(m_gptr.m_ptr);
      }
      const_reference operator*() const
      {
         return *(m_gptr.m_ptr);
      }
      pointer operator->()
      {
         return m_gptr.m_ptr.get();
      }
      const_pointer operator->() const
      {
         return m_gptr.m_ptr.get();
      }

   private:
      guarded_ptr & m_gptr;
   };

   class upgradable_access : boost::noncopyable
   {
   public:
      upgradable_access(guarded_ptr &guard)
         : m_gptr(guard)
         , m_upgraded(false)
      {
         m_gptr.m_mutex.lock_upgrade();
      }
      ~upgradable_access()
      {
         if (m_upgraded)
         {
            m_gptr.m_mutex.unlock();
         }
         else
         {
            m_gptr.m_mutex.unlock_upgrade();
         }
      }

      const_reference operator*() const
      {
         return *(m_gptr.m_ptr);
      }
      const_pointer operator->() const
      {
         return m_gptr.m_ptr.get();
      }

      class upgrade
      {
      public:
         upgrade(upgradable_access & parent)
            : m_parent(parent)
         {
            parent.m_gptr.m_mutex.unlock_upgrade_and_lock();
            parent.m_upgraded = true;
         }

         reference operator*()
         {
            return *(m_parent.m_gptr.m_ptr);
         }
         const_reference operator*() const
         {
            return *(m_parent.m_gptr.m_ptr);
         }
         pointer operator->()
         {
            return m_parent.m_gptr.m_ptr.get();
         }
         const_pointer operator->() const
         {
            return m_parent.m_gptr.m_ptr.get();
         }

      private:
         upgradable_access & m_parent;
      };

   private:
      guarded_ptr & m_gptr;
      bool m_upgraded;
   };

   guarded_ptr(pointer ptr)
      : m_ptr(assert_not_null(ptr)) // do the assert early during construction
   {
   }

private:
   pointer assert_not_null(pointer ptr)
   {
      assert(ptr);
      return ptr;
   }

   boost::scoped_ptr<element_type> const m_ptr;
   boost::shared_mutex mutable m_mutex;
};

} // namespace moost

#endif // ifndef MOOST_GUARDED_PTR_HPP__