/home/mhx/git/github/libmoost/include/moost/thread/token_mutex.hpp

Go to the documentation of this file.

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

#include <set>
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>

namespace moost { namespace thread {

template<typename T>
class token_mutex
{
private:

   boost::mutex m_mutex;
   boost::condition m_cond;
   std::set<T> m_tokens;
   bool m_full_lock;

public:
   class scoped_promote_lock;

   class scoped_lock
   {
   private:
      token_mutex<T>& m_token_mutex;
      T m_token;

      friend class scoped_promote_lock;
   public:
      scoped_lock( token_mutex<T> & token_mutex,
                   const T & token )
         : m_token_mutex(token_mutex),
         m_token(token)
      {
         m_token_mutex.lock(m_token);
      }
      ~scoped_lock()
      {
         m_token_mutex.unlock(m_token);
      }
   };

  class scoped_try_lock
  {
  private:
     token_mutex<T>& m_token_mutex;
     T m_token;
     bool m_got_lock;
  public:
     scoped_try_lock( token_mutex<T> & token_mutex,
                      const T & token )
        : m_token_mutex(token_mutex),
        m_token(token)
     {
        m_got_lock = m_token_mutex.trylock(m_token);
     }
     operator bool () const { return m_got_lock; }
     bool operator ! () const { return !m_got_lock; }
     ~scoped_try_lock()
     {
        if (m_got_lock)
           m_token_mutex.unlock(m_token);
     }
  };

  class scoped_full_lock
  {
  private:
     token_mutex<T>& m_token_mutex;
  public:
     scoped_full_lock(token_mutex<T> & token_mutex)
        : m_token_mutex(token_mutex)
     {
        m_token_mutex.full_lock();
     }
     ~scoped_full_lock()
     {
        m_token_mutex.full_unlock();
     }
  };

  class scoped_promote_lock
  {
  private:
     token_mutex<T>& m_token_mutex;
  public:
     scoped_promote_lock(scoped_lock& lock)
        : m_token_mutex(lock.m_token_mutex)
     {
        m_token_mutex.unlock(lock.m_token);
        m_token_mutex.full_lock();
     }

     ~scoped_promote_lock()
     {
        m_token_mutex.full_unlock();
     }
  };

  token_mutex() : m_full_lock(false) {}

  void lock(const T& token)
  {
     boost::mutex::scoped_lock lock(m_mutex);
     while (m_tokens.find(token) != m_tokens.end() || m_full_lock)
        m_cond.wait(lock);
     m_tokens.insert(token);
  }

  void unlock(const T& token)
  {
     boost::mutex::scoped_lock lock(m_mutex);
     m_tokens.erase(token);
     m_cond.notify_all();
  }

  void full_lock()
  {
     boost::mutex::scoped_lock lock(m_mutex);
     m_full_lock = true;
     while (!m_tokens.empty())
        m_cond.wait(lock);
  }

  void full_unlock()
  {
     boost::mutex::scoped_lock lock(m_mutex);
     m_full_lock = false;
     m_cond.notify_all();
  }

  bool trylock(const T& token)
  {
     boost::mutex::scoped_lock lock(m_mutex);
     if (m_tokens.find(token) == m_tokens.end() && !m_full_lock)
     {
        m_tokens.insert(token);
        return true;
     }
     return false;
  }
};

}} // moost::thread

#endif // MOOST_THREAD_TOKEN_MUTEX_H__