cThreadLocal.h

Go to the documentation of this file.

//
 
#ifndef _INC_cThreadLocal_H
#define _INC_cThreadLocal_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cThreadMgr.h"
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cThreadLocalSys.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cArraySort.h"
#include "GrayCore/include/cSingleton.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/IUnknown.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cThreadLocal);
 
        template <class TYPE, class TYPE_ARG>
        class cThreadLocalInst
        {
 
                typedef cThreadLocalInst<TYPE, TYPE_ARG> THIS_t;
 
        private:
                // Sorted / searched by this param
                THREADID_t m_nThreadId; 
                TYPE m_Data;                    
 
        public:
                cThreadLocalInst() noexcept
                : m_nThreadId(cThreadId::k_NULL)
                {
                        // used just for arrays.
                }
                cThreadLocalInst(THREADID_t nThreadID) noexcept
                : m_nThreadId(nThreadID)
                {
                        DEBUG_CHECK(nThreadID != cThreadId::k_NULL);
                }
                ~cThreadLocalInst()
                {
                }
                THREADID_t get_HashCode() const noexcept
                {
                        return m_nThreadId;
                }
                TYPE_ARG get_Data() const noexcept
                {
                        return m_Data;
                }
                void put_Data(TYPE_ARG rData)
                {
                        // NOTE: Always use this to prevent problems with M$ constructors from calling destructor in imbalanced way.
                        m_Data = rData;
                }
 
                UNITTEST2_PREDEF(cThreadLocal );
        };
 
        template <class TYPE_INST, class TYPE_ARG>
        class cThreadLocalType
        : public IThreadCloseHandler
        , public IThreadLocal   // must implement this.
        {
 
        public:
                mutable cThreadLockFast m_Lock;
        protected:
                cArraySortStructHash< TYPE_INST, THREADID_t > m_a;              // Track an instance of TYPE_INST for each active thread.
 
        private:
                TYPE_ARG GetDataForX(THREADID_t nThreadID) const
                {
                        ITERATE_t i = m_a.FindIForKey(nThreadID);
                        if (i < 0)
                                return nullptr; // always a pointer!
                        return m_a.GetAt(i).get_Data();
                }
 
        public:
                cThreadLocalType()
                {
                        cThreadMgr::I().Register(this);
                }
                virtual ~cThreadLocalType()
                {
                        if (cThreadMgr::isSingleCreated())
                        {
                                cThreadMgr::I().UnRegister(this);
                        }
                }
                TYPE_ARG GetDataForThreadId(THREADID_t nThreadID) const
                {
                        cThreadGuardFast threadguard(m_Lock);   // thread sync critical section.
                        return GetDataForX(nThreadID);
                }
                TYPE_ARG GetData() const
                {
                        cThreadGuardFast threadguard(m_Lock);   // thread sync critical section.
                        THREADID_t nThreadID = m_Lock.get_ThreadLockOwner();
                        ASSERT(nThreadID == cThreadId::GetCurrentId());
                        return GetDataForX(nThreadID);
                }
                bool PutData(TYPE_ARG Data)
                {
                        cThreadGuardFast threadguard(m_Lock);   // thread sync critical section.
                        THREADID_t nThreadID = m_Lock.get_ThreadLockOwner();
                        ASSERT(nThreadID == cThreadId::GetCurrentId());
                        ITERATE_t i = m_a.FindIForKey(nThreadID);
                        if (i < 0)
                        {
                                i = m_a.Add(TYPE_INST(nThreadID));
                        }
                        // NOTE: Always use this to prevent problems with M$ constructors from calling destructor in imbalanced way.
                        m_a.ElementAt(i).put_Data(Data);
                        return(i >= 0);
                }
 
                virtual void OnThreadClose(THREADID_t nThreadID)
                {
                        cThreadGuardFast threadguard(m_Lock);   // thread sync critical section.
                        m_a.RemoveKey(nThreadID);       // destruct type if needed.
                }
 
                // For debug purposes.
 
                void RemoveAll()
                {
                        cThreadGuardFast threadguard(m_Lock);   // thread sync critical section.
                        m_a.RemoveAll();
                }
                ITERATE_t GetSize() const
                {
                        return m_a.GetSize();
                }
                bool IsEmpty() const
                {
                        cThreadGuardFast threadguard(m_Lock);   // thread sync critical section.
                        return m_a.IsEmpty();
                }
        };
 
        template <class TYPE>
        class cThreadLocalTypeNew : public cThreadLocalType< cThreadLocalInst< cNewPtr2<TYPE>, TYPE*>, TYPE* >
        {
 
        public:
                typedef cThreadLocalInst< cNewPtr2<TYPE>, TYPE*> TYPE_INST;
                typedef cThreadLocalType< TYPE_INST, TYPE* > SUPER_t;
 
                TYPE* GetDataNew() // GetData
                {
                        TYPE* pData = SUPER_t::GetData();
                        if (pData == nullptr)
                        {
                                pData = new TYPE;
                                SUPER_t::PutData(pData);
                        }
                        return pData;
                }
                virtual void* GetDataNewV()
                {
                        return GetDataNew();
                }
        };
 
        template <class TYPE>
        class cThreadLocalTypeSmart : public cThreadLocalType< cThreadLocalInst< cRefPtr<TYPE>, TYPE*>, TYPE* >
        {
        public:
                typedef cThreadLocalInst< cRefPtr<TYPE>, TYPE*> TYPE_INST;
                typedef cThreadLocalType< TYPE_INST, TYPE* > SUPER_t;
 
                TYPE* GetDataNew() // GetData
                {
                        TYPE* pData = SUPER_t::GetData();
                        if (pData == nullptr)
                        {
                                pData = new TYPE;
                                SUPER_t::PutData(pData);
                        }
                        return pData;
                }
                virtual void* GetDataNewV()
                {
                        return GetDataNew();
                }
        };
};
 
#endif // _INC_cThreadLocal_H