LockedHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_LOCKEDHANDLE
#define GAUDIKERNEL_LOCKEDHANDLE 1

#include <mutex>

// =======================================================================
template <class T, class MutexType=std::mutex>
class LockedHandle {
public:

  LockedHandle(T* ptr, MutexType& mut) : m_ptr(ptr), m_mutex(&mut) {}
  LockedHandle(T* ptr, MutexType* mut) : m_ptr(ptr), m_mutex(mut) {}
  LockedHandle(T* ptr) : m_ptr(ptr), m_mutex(0) {}
  LockedHandle() : m_ptr(nullptr), m_mutex(nullptr) {}

  void set(T* ptr, MutexType* mut) { 
    m_ptr = ptr;
    m_mutex = mut;
  }
    
  void setMutex(MutexType* mut) { m_mutex = mut; }

  T* get() const { return m_ptr; }

  class Guard  {
    Guard(const Guard &a) = delete;
  public:
    Guard(Guard &&a)
      : m_ptr(a.m_ptr),
        m_mutex(a.m_mutex)
    {
      a.m_mutex=nullptr;
    }
    
    Guard(T *ptr,MutexType &mutex)
      : m_ptr(ptr),
        m_mutex(&mutex)
    {
      m_mutex->lock();
    }
    ~Guard()  {
      m_mutex->unlock();
    }
    T &operator*() { return *m_ptr; }
    T *operator->() { return m_ptr; }

    operator T&() {
      return *m_ptr;
    }

  private:
    T *m_ptr {nullptr};
    MutexType *m_mutex {nullptr};
  };
  
  class ConstGuard  {
    ConstGuard(const ConstGuard &a) = delete;
  public:
    ConstGuard(ConstGuard &&a)
      : m_ptr(a.m_ptr),
        m_mutex(a.m_mutex)
    {
      a.m_mutex=nullptr;
    }
    
    ConstGuard(const T *ptr,MutexType &mutex)
      : m_ptr(ptr),
        m_mutex(&mutex)
    {
      m_mutex->lock();
    }
    ~ConstGuard()  {
      m_mutex->unlock();
    }
    const T &operator*() const { return *m_ptr; }
    const T *operator->() const { return m_ptr; }
    
    operator const T&() const {
      return *m_ptr;
    }
    
  private:
    const T *m_ptr;
    MutexType *m_mutex;
  };


  Guard operator*()  { return Guard(m_ptr,*m_mutex); }

  Guard operator->() { return Guard(m_ptr,*m_mutex); }

  ConstGuard operator*()  const { return ConstGuard(m_ptr,*m_mutex); }

  ConstGuard operator->() const { return ConstGuard(m_ptr,*m_mutex); }

  operator bool() const {
    return m_ptr;
  }
private:

  T *m_ptr;
  mutable MutexType *m_mutex;
};



#endif