cThreadLockRef.h

Go to the documentation of this file.

//
 
#ifndef _INC_cThreadLockRef_H
#define _INC_cThreadLockRef_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cThreadLock.h"
#include "cRefPtr.h"
 
namespace Gray
{
        class GRAYCORE_LINK cThreadLockableRef
                : public cRefBase
                , public cThreadLockCount
        {
        public:
                cThreadLockableRef(int iStaticRefCount = 0) noexcept
                        : cRefBase(iStaticRefCount)
                {
                }
                virtual ~cThreadLockableRef() 
                {
                }
                virtual void onThreadLockFail(TIMESYSD_t dwWaitMS)
                {
                        UNREFERENCED_PARAMETER(dwWaitMS);
                }
        };
 
        //****************************************************************************
 
        template<class TYPE = cThreadLockableRef >
        class cThreadLockRef : public cRefPtr < TYPE >
        {
 
                typedef cThreadLockRef<TYPE> THIS_t;
 
#if defined(_MT) || defined(__linux__)
 
        private:
                void SetFirstLockObj(TYPE* p2)
                {
                        if (p2 != nullptr)
                        {
#ifdef _DEBUG
                                ASSERT(DYNPTR_CAST(cThreadLockableRef, p2) != nullptr);
                                ASSERT(DYNPTR_CAST(TYPE, p2) != nullptr);
#endif
                                p2->IncRefCount();
                                p2->Lock();
                        }
                        this->m_p = p2;
                }
                bool SetFirstLockObjTry(TYPE* p2, TIMESYSD_t dwWaitMS)
                {
                        if (p2 != nullptr)
                        {
#ifdef _DEBUG
                                ASSERT(DYNPTR_CAST(cThreadLockableRef, p2) != nullptr);
                                ASSERT(DYNPTR_CAST(TYPE, p2) != nullptr);
#endif
                                p2->IncRefCount();
                                if (!p2->LockTry(dwWaitMS))
                                {
                                        if (dwWaitMS)
                                        {
                                                p2->onThreadLockFail(dwWaitMS);
                                        }
                                        p2->DecRefCount();
                                        this->m_p = nullptr;
                                        return false;
                                }
                        }
                        this->m_p = p2;
                        return true;
                }
 
        public:
                // Construct and destruct
                cThreadLockRef()
                {
                }
                cThreadLockRef(TYPE* p2)
                {
                        SetFirstLockObj(p2);
                }
                cThreadLockRef(TYPE* p2, TIMESYSD_t dwWaitMS)
                {
                        SetFirstLockObjTry(p2, dwWaitMS);
                }
                cThreadLockRef(const THIS_t& ref)
                {
                        SetFirstLockObj(ref.get_Ptr());
                }
                ~cThreadLockRef()
                {
                        ReleasePtr();
                }
 
                void ReleasePtr()
                {
                        TYPE* p2 = this->m_p;   // make local copy
                        if (p2 != nullptr)
                        {
                                this->m_p = nullptr;
#ifdef _DEBUG
                                ASSERT(DYNPTR_CAST(TYPE, p2) != nullptr);
#endif
                                p2->Unlock();
                                p2->DecRefCount();
                        }
                }
 
                operator TYPE* () const
                {
                        return(this->m_p);
                }
                TYPE& operator * () const
                {
                        ASSERT(this->m_p != nullptr); return *(this->m_p);
                }
                TYPE* operator -> () const
                {
                        ASSERT(this->m_p != nullptr); return(this->m_p);
                }
 
                void put_Ptr(TYPE* p2)
                {
                        if (p2 == this->m_p)
                                return;
                        ReleasePtr();
                        SetFirstLockObj(p2);
                }
                bool SetLockObjTry(TYPE* p2, TIMESYSD_t dwWaitMS)
                {
                        if (p2 == this->m_p)
                                return true;
                        ReleasePtr();
                        return SetFirstLockObjTry(p2, dwWaitMS);
                }
 
                // Assignment
                const THIS_t& operator = (TYPE* p2)
                {
                        put_Ptr(p2);
                        return *this;
                }
                const THIS_t& operator = (const THIS_t& ref)
                {
                        put_Ptr(ref.m_p);
                        return *this;
                }
#endif // defined(_MT) || __linux__
        };
 
        typedef cThreadLockRef<cThreadLockableRef> cThreadLockRefX;
}
 
#endif // _INC_cThreadLockRef_H