cLocker.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cLocker_H
#define _INC_cLocker_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cPtrFacade.h"
 
namespace Gray
{
        class GRAYCORE_LINK cLockableBase
        {
        private:
                LONG m_nLockCount;      
 
        protected:
                cLockableBase() noexcept
                        : m_nLockCount(0)
                {
                }
                ~cLockableBase()
                {
                        ASSERT(m_nLockCount == 0);
                }
                inline LONG get_LockCount() const
                {
                        ASSERT(m_nLockCount >= 0);
                        return m_nLockCount;
                }
                inline bool isLocked() const
                {
                        ASSERT(m_nLockCount >= 0);
                        return(m_nLockCount != 0);
                }
 
                inline void IncLockCount()
                {
                        ++m_nLockCount;
                        ASSERT(m_nLockCount >= 0);
                }
                inline LONG DecLockCount()
                {
                        --m_nLockCount;
                        ASSERT(m_nLockCount >= 0);
                        return m_nLockCount;
                }
                inline void Lock()
                {
                        // For template support. cLockerT
                        IncLockCount();
                }
                inline LONG Unlock()
                {
                        // For template support. cLockerT
                        return DecLockCount();
                }
        };
 
        template<class TYPE = cLockableBase>
        class cLockerT : public cPtrFacade < TYPE >
        {
                //
        public:
                explicit cLockerT(TYPE* pLock, bool bLockSuccess) noexcept
                        : cPtrFacade<TYPE>(bLockSuccess ? pLock : nullptr)
                {
                        // The lock may not always work ! this->m_p == nullptr
                }
                explicit cLockerT(TYPE& rLock)
                        : cPtrFacade<TYPE>(&rLock)
                {
                        ASSERT(this->m_p == &rLock && this->m_p != nullptr);
                        rLock.Lock();
                }
                ~cLockerT()
                {
                        if (this->m_p != nullptr)
                        {
                                this->m_p->Unlock();
                        }
                }
        };
}
 
#endif