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