cUIDManagerArray.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cUIDManagerArray_H
#define _INC_cUIDManagerArray_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cUID.h"
#include "XObject/cXObjDef.h"   // IXObject or IUnkObject ??
 
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cRefPtr.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cUIDManagerArray);
 
        // class GRAYLIB_LINK cXObject;
        // typedef cRefPtr<cXObject> cXObjectPtr;
 
        DECLARE_INTERFACE(IUIDManager)
        {
                // TODO add more
                virtual cXObjectPtr FindUIDObj(UID_t uid) const = 0;
        };
 
        class GRAYLIB_LINK cUIDManagerArray : public cThreadLockCount, public IUIDManager
        {
#define UID_PLACE_HOLDER        ((cXObject*)(INT_PTR)(-1))      // junk pointer
 
        public:
                cUIDManagerArray(const cUIDRangeMask& mask, bool bReUseFreedUIDs = true);
                ~cUIDManagerArray();
 
                UIDINDEX_t get_UIDCount() const noexcept
                {
                        // Get Max UID.
                        return (UIDINDEX_t)m_aUIDs.GetSize();
                }
                virtual cXObjectPtr FindUIDObj(UID_t nUID) const
                {
                        if (nUID == cUID::k_CLEAR)
                                return nullptr;
                        UIDINDEX_t dwIndex = m_UIDRange.U2I(nUID);
                        if (dwIndex == 0 || !m_aUIDs.IsValidIndex(dwIndex))
                                return nullptr;
                        if (m_aUIDs[dwIndex] == UID_PLACE_HOLDER)       // unusable for now. (background save is going on)
                                return nullptr;
                        return m_aUIDs[dwIndex];
                }
                bool isIndexPlaceHolder(UIDINDEX_t dwIndex) const
                {
                        ASSERT(m_UIDRange.IsValidIndex(dwIndex));
                        return m_aUIDs[dwIndex] == UID_PLACE_HOLDER;
                }
                void ClearUIDPlaceHolder(UID_t nUID);
 
                bool FreeUID(UID_t nUID);
                bool FreeUID(cXObject* pObj);
                UID_t LoadUID(cXObject* pObj, UID_t dwIndex);
                UID_t AllocUID(cXObject* pObj);
 
                void FlushFreeUIDs();
                void DisposeAllUIDs();
                void put_ReUseFreeUIDs(bool bReUseFreeUIDs);
 
                UNITTEST_FRIEND(cUIDManagerArray);
 
        protected:
                UIDINDEX_t FindFreeIndex();
 
        public:
                cUIDRangeMask m_UIDRange;                       
 
        private:
                bool m_bReUseFreedUIDs;                         
                UIDINDEX_t m_nIndexLast;                        
 
                cArrayPtr<cXObject> m_aUIDs;    
        };
}
#endif // _INC_cUIDManagerArray_H