GxHashMap.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxHashMap : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxHashMap, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxHashMap)
 
    
    static constexpr u32 DEFAULT_SPLIT_COUNT = 32;
    static constexpr u32 BUFFER_SIZE = GxMath::VALUE_2M;
 
    class GxPair : public GxClassBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_CLASS(GxPair, GxClassBase)
        // GxClassBase継承クラス用禁止宣言
        GX_PROHIBIT_CLASS_BASE(GxPair)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GxPair(void) : _key(nullptr), _pObject(nullptr) {}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        constexpr void set(GX_CSTR key, void* pObject) { _key = key; _pObject = pObject; }
        constexpr GX_CSTR getKey(void) const { return _key; }
        constexpr void* getObject(void) const { return _pObject; }
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        GX_CSTR _key;   
        void* _pObject; 
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxHashMap(void);
    GxHashMap(u32 splitCount, u32 keySize = 0, b32 useKeyBuffer = true, u32 keyBufferSize = BUFFER_SIZE);
    ~GxHashMap(void) override;
private:
    void initialize(b32 useKeyBuffer = true, u32 keyBufferSize = BUFFER_SIZE);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void* find(GX_CSTR key) const;
    void* findFromAddress(void* pKeyAddress) const;
    GX_CSTR findKey(void* pObject) const;
    GX_CSTR findKeyFromString(GX_CSTR pText) const;
    void insert(GX_CSTR key, void* pObject);
    void insertFromAddress(void* pKeyAddress, void* pObject);
    void setObject(GX_CSTR key, void* pObject);
    void setObjectFromAddress(void* pKeyAddress, void* pObject);
    void erase(GX_CSTR key);
    void eraseFromAddress(void* pKeyAddress);
    void erase(const void* pObject);
    void eraseAll(void);
 
private:
    GX_FORCE_INLINE const u32 getHashValue(GX_CSTR key) const { return (_keySize > 0 ? GxMath::getHash32((void*)key, _keySize) : GxMath::getHash32(key)) % _splitCount; }
    GX_FORCE_INLINE u32 getHashValueFromAddress(void* pKeyAddress) const { return GxMath::getHash32(pKeyAddress, sizeof(void*)) % _splitCount; }
    GxPair* findPair(GX_CSTR key) const;
    GxPair* findPairFromAddress(void* pKeyAddress) const;
    GxPair* allocatePair(GX_CSTR key, void* pObject);
    void freePair(GxPair* pPair);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void* operator[](GX_CSTR key);
    void* operator[](u32 index);
    u32 getCount(void) const;
    constexpr u32 getSplitCount(void) const { return _splitCount; }
    constexpr u32 getKeySize(void) const { return _keySize; }
    GX_FORCE_INLINE const GxArrayClassBase& getPairArray(void) const { return _pairArray; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxArrayClassBase    _hashArray;         
    GxArrayClassBase    _pairArray;         
    GxArrayClassBase    _pairFreeArray;     
    GxArrayClassBase    _pairBufferArray;   
    GxMemoryStream      _keyStream;         
    u32                 _splitCount;        
    u32                 _keySize;           
 
};
 
//===========================================================================
//===========================================================================
class GxHashMapW : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxHashMapW, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxHashMapW)
 
    
    static constexpr u32 DEFAULT_SPLIT_COUNT = 32;
private:
    class GxPair : public GxClassBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_CLASS(GxPair, GxClassBase)
        // GxClassBase継承クラス用禁止宣言
        GX_PROHIBIT_CLASS_BASE(GxPair)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        GxPair(void) : _key(nullptr), _pObject(nullptr){}
    public:
        GxPair(GX_CWSTR key, void* pObject) : _key(key), _pObject(pObject){}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GX_CWSTR _key;  
        void* _pObject; 
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxHashMapW(void);
    GxHashMapW(u32 splitCount);
    ~GxHashMapW(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void* find(GX_CWSTR key) const;
    void insert(GX_CWSTR key, void* pObject);
    void erase(GX_CWSTR key);
    void erase(const void* pObject);
    void eraseAll(void);
 
private:
    GX_FORCE_INLINE u32 getHashValue(GX_CWSTR key) const { return GxMath::getHash32(key) % _splitCount; }
    GxListClassBase::GxNodeClassBase* findNode(GX_CWSTR key) const;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void* operator[](GX_CWSTR key);
    GX_FORCE_INLINE u32 getCount(void) const { return _pPairList->getCount(); }
    constexpr u32 getSplitCount(void) const { return _splitCount; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxArrayClassBase _hashArray;    
    GxListClassBase* _pPairList;    
    u32 _splitCount;                
 
};
 
GX_CORE_NAMESPACE_END()