cUID.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cUID_H
#define _INC_cUID_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cDebugAssert.h"
 
namespace GrayLib
{
        typedef HASHCODE32_t UID_t;                             
 
        class cUID
        {
 
        protected:
                UID_t m_nUIDValue;
 
        public:
                static const UID_t k_CLEAR = ((UID_t)0);                        
                static const UID_t k_BAD = ((UID_t)UINT_MAX);           
 
                static const UID_t k_ROOT = ((UID_t)0x80000000);        
                static const UID_t k_CONTEXT = ((UID_t)0);                      
 
#define cUID_PREFIX "#0"                
#define cUID_FORMAT "#0%x"              
 
                cUID(UID_t u) noexcept
                        : m_nUIDValue(u)
                {
                }
 
                static inline bool IsValidUID(UID_t uid) noexcept
                {
                        return (uid != k_CLEAR) && (uid != k_BAD) ;
                }
                bool isValidUID() const noexcept
                {
                        return IsValidUID(m_nUIDValue);
                }
                UID_t get_HashCode() const noexcept
                {
                        return m_nUIDValue;
                }
                UID_t get_UIDValue() const noexcept
                {
                        return m_nUIDValue;
                }
                operator UID_t() const noexcept
                {
                        return m_nUIDValue;
                }
        };
 
        typedef int UIDINDEX_t; 
 
        class GRAYLIB_LINK cUIDRangeMask
        {
 
        public:
                UID_t m_nUIDMaskType;                   
                UID_t m_nUIDMaskIndex;                  
                UIDINDEX_t m_nIndexStart;               
 
        public:
                cUIDRangeMask(UID_t nUIDMaskType = 0x80000000, UID_t nUIDMaskIndex = 0x7FFFFFFF, UIDINDEX_t dwIndexStart = 1)
                        : m_nUIDMaskType(nUIDMaskType) // high bits.
                        , m_nUIDMaskIndex(nUIDMaskIndex) // index mask ex. 0xFFFF
                        , m_nIndexStart(dwIndexStart)   // don't allow 0 to be a valid index normally.
                {
                        ASSERT(isValidRangeMask());
                        ASSERT(IsValidIndex(m_nIndexStart));
                }
                void InitRangeMask(UID_t nUIDMaskType, UID_t nUIDMaskIndex, UIDINDEX_t dwIndexStart = 1)
                {
                        m_nUIDMaskType = nUIDMaskType;
                        m_nUIDMaskIndex = nUIDMaskIndex;
                        m_nIndexStart = dwIndexStart;
                        ASSERT(isValidRangeMask());
                        ASSERT(IsValidIndex(m_nIndexStart));
                }
                bool isValidRangeMask() const noexcept
                {
                        if ((m_nUIDMaskType & m_nUIDMaskIndex) != k_HASHCODE_CLEAR) // bits must not overlap.
                        {
                                return false;
                        }
                        return true;
                }
                bool IsValidQty(UIDINDEX_t index) const noexcept
                {
                        if (((UID_t)index) > (UID_t)(m_nUIDMaskIndex - m_nIndexStart))
                                return false;
                        return true;
                }
                bool IsValidIndex(UIDINDEX_t index) const noexcept
                {
                        if (index < m_nIndexStart)
                                return false;
                        if (((UID_t)index) >= m_nUIDMaskIndex)  // NOT allowed to equal mask!
                                return false;
                        return true;
                }
                bool IsValidUID(UID_t uid) const noexcept
                {
                        if ((uid & ~m_nUIDMaskIndex) != m_nUIDMaskType)
                                return false;
                        // Check index range as well ?
                        return IsValidIndex(U2I_NoCheck(uid));
                }
                UIDINDEX_t U2I_NoCheck(UID_t uid) const noexcept
                {
                        return((UIDINDEX_t)(uid & m_nUIDMaskIndex));
                }
                UIDINDEX_t U2I(UID_t uid) const
                {
                        ASSERT(IsValidUID(uid));
                        return U2I_NoCheck(uid);
                }
 
                UID_t I2U(UIDINDEX_t index) const
                {
                        ASSERT(IsValidIndex(index));
                        return(((UID_t)index) | m_nUIDMaskType);
                }
        };
}
 
#endif // _INC_cUID_H