HASHMAP_T Class Reference

#include <__HASHMAP.h>

Inheritance diagram for HASHMAP_T:

Classes
struct	Assoc
class	ConstIterator
struct	HashNode
class	Iterator

Public Member Functions
virtual	~HASHMAP_T ()
	HASHMAP_T (size_t _bucketSize=21)
void	initBuckets (size_t _bucketSize)
	HASHMAP_T (const HASHMAP_T &_src)
const HASHMAP_T &	operator= (const HASHMAP_T &_src)
ConstIterator	begin () const
ConstIterator	end () const
Iterator	begin ()
Iterator	end ()
size_t	bucketSize () const
size_t	size () const
size_t	sizeOfBucket (size_t _index) const
bool	isEmpty () const
Iterator	find (const KEY_T &_key)
ConstIterator	find (const KEY_T &_key) const
bool	lookup (const KEY_T &_key, VALUE_T &_rValue) const
VALUE_T &	operator[] (const KEY_T &_key)
size_t	erase (const KEY_T &_key)
void	clear ()
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Protected Member Functions
size_t	bucketIndex (const KEY_T &_key) const
HashNode *	createNode (const KEY_T &_key)
void	destroyNode (HashNode *_pNode)
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Protected Attributes
HASHFUN_T	__hashFun
size_t	__size
PointerArray	__buckets

Friends
class	Iterator
class	ConstIterator

Detailed Description

template class HashMap의 DSO 호환성을 제공한다.

C++의 template class는 해당 코드를 사용하기 전에는 실제 이진 코드를 생성하지 않으므로, DSO(so, DLL)와 DSO, 또는 실행파일에서 객체를 주고받을 수 없다.

이 클래스는 DSO의 이러한 문제를 해결하며, 포함파일은 <dcl/HashMap.h>이다.

이 코드를 사용하는 클래스는 다음과 같다.

• class DCLCAPI StringToStringMap
• class DCLCAPI StringToPointerMap
• class DCLCAPI IntToIntMap

See also

HashMap

Definition at line 55 of file __HASHMAP.h.

Constructor & Destructor Documentation

~HASHMAP_T()

virtual HASHMAP_T::~HASHMAP_T ( )

virtual

HASHMAP_T() [1/2]

HASHMAP_T::HASHMAP_T

(

size_t

_bucketSize = 21

)

Definition at line 127 of file __HASHMAP.cpp.

    : __buckets(DCLGetNextPrimNumber(_bucketSize))
{
    __size = 0;
//  __buckets.resize(DCLGetNextPrimNumber(_bucketSize));
}

HASHMAP_T() [2/2]

HASHMAP_T::HASHMAP_T

(

const HASHMAP_T &

_src

)

Definition at line 140 of file __HASHMAP.cpp.

{
    *this = _src;
}

Member Function Documentation

begin() [1/2]

HASHMAP_T::Iterator HASHMAP_T::begin

(

)

Definition at line 186 of file __HASHMAP.cpp.

{
    for(size_t i = 0; i < __buckets.size(); i++)
    {
        if (__buckets[i] != NULL)
            return Iterator((HashNode*)__buckets[i], this);
    }
    return Iterator(NULL, this);
}

begin() [2/2]

HASHMAP_T::ConstIterator HASHMAP_T::begin

(

)

const

Definition at line 175 of file __HASHMAP.cpp.

{
    for(size_t i = 0; i < __buckets.size(); i++)
    {
        if (__buckets[i] != NULL)
            return ConstIterator((HashNode*)__buckets[i], this);
    }
    return ConstIterator(NULL, this);
}

bucketIndex()

size_t HASHMAP_T::bucketIndex ( const KEY_T & _key ) const

inlineprotected

Definition at line 272 of file __HASHMAP.cpp.

{
    return __hashFun.hashKey(_key) % __buckets.size();
}

bucketSize()

size_t HASHMAP_T::bucketSize ( ) const

inline

Definition at line 278 of file __HASHMAP.h.

{
    return __buckets.size();
}

clear()

void HASHMAP_T::clear

(

)

Definition at line 359 of file __HASHMAP.cpp.

{
    for(size_t i = 0; i < __buckets.size(); i++)
    {
        HashNode* pNode = (HashNode*)__buckets[i];
        while(pNode)
        {
            HashNode* pNext = pNode->pNext;
            destroyNode(pNode);
            pNode = pNext;
        }
        __buckets[i] = NULL;
    }
    __size = 0;
}

createNode()

HASHMAP_T::HashNode * HASHMAP_T::createNode ( const KEY_T & _key )

protected

Definition at line 278 of file __HASHMAP.cpp.

{
    HashNode* pNode = (HashNode*) malloc(sizeof(HashNode));
    // FIXME!
    // if (pNode == NULL)
    //      throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
    __DCL_ASSERT(pNode != NULL);
 
    memset((void*) pNode, 0, sizeof(HashNode));
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef new
#endif
 
#if HAVE_CONSTRUCTOR_KEY
    new(&(pNode->key)) KEY_T;
#endif
#if HAVE_CONSTRUCTOR_VALUE
    new(&(pNode->value)) VALUE_T;
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG
#define new __DCL_DEBUG_NEW
#endif
 
    pNode->key = _key;
    return pNode;
}

destroyNode()

void HASHMAP_T::destroyNode ( HashNode * _pNode )

protected

Definition at line 308 of file __HASHMAP.cpp.

{
#if HAVE_CONSTRUCTOR_KEY
    _pNode->key.~KEY_T();
#endif
#if HAVE_CONSTRUCTOR_VALUE
    _pNode->value.~VALUE_T();
#endif
    free(_pNode);
}

end() [1/2]

HASHMAP_T::Iterator HASHMAP_T::end ( )

inline

Definition at line 264 of file __HASHMAP.h.

{
    return Iterator(NULL, this);
}

end() [2/2]

HASHMAP_T::ConstIterator HASHMAP_T::end ( ) const

inline

Definition at line 271 of file __HASHMAP.h.

{
    return ConstIterator(NULL, this);
}

erase()

size_t HASHMAP_T::erase

(

const KEY_T &

_key

)

Definition at line 320 of file __HASHMAP.cpp.

{
    size_t nErased = 0;
    size_t index = bucketIndex(_key);
    HashNode* pCurrentNode = (HashNode*)__buckets[index];
    if (pCurrentNode != NULL)   
    {
        if (pCurrentNode->key == _key)      // first
        {
            __buckets[index] = pCurrentNode->pNext;
            destroyNode(pCurrentNode);
            nErased++;
            __size--;
        }
        else
        {
            HashNode* pNextNode = pCurrentNode->pNext;
            while(pNextNode != NULL)
            {
                if (pNextNode->key == _key)
                {
                    pCurrentNode->pNext = pNextNode->pNext;
                    destroyNode(pNextNode);
                    nErased++;
                    __size--;
                    break;
                }
                else
                {
                    pCurrentNode = pNextNode;
                    pNextNode = pCurrentNode->pNext;
                }
            }
        }
    }
    return nErased;
}

find() [1/2]

HASHMAP_T::Iterator HASHMAP_T::find

(

const KEY_T &

_key

)

Definition at line 209 of file __HASHMAP.cpp.

{
    size_t index = bucketIndex(_key);
    HashNode* pNode = (HashNode*)__buckets[index];
    while (pNode) {
        if (pNode->key == _key) {
            break;
        }
        pNode = pNode->pNext;
    }
    return Iterator(pNode, this);
}

find() [2/2]

HASHMAP_T::ConstIterator HASHMAP_T::find

(

const KEY_T &

_key

)

const

Definition at line 223 of file __HASHMAP.cpp.

{
    size_t index = bucketIndex(_key);
    const HashNode* pNode = (HashNode*)__buckets[index];
    while (pNode) {
        if (pNode->key == _key) {
            break;
        }
        pNode = pNode->pNext;
    }
    return ConstIterator(pNode, this);
}

initBuckets()

void HASHMAP_T::initBuckets

(

size_t

_bucketSize

)

Definition at line 134 of file __HASHMAP.cpp.

{
    clear();
    __buckets.resize(DCLGetNextPrimNumber(_bucketSize));
}

isEmpty()

bool HASHMAP_T::isEmpty ( ) const

inline

Definition at line 292 of file __HASHMAP.h.

{
    return __size == 0;
}

lookup()

bool HASHMAP_T::lookup	(	const KEY_T &	_key,
		VALUE_T &	_rValue ) const

Definition at line 237 of file __HASHMAP.cpp.

{
    size_t index = bucketIndex(_key);
    HashNode* pNode = (HashNode*)__buckets[index];
    while(pNode != NULL) {
        if (pNode->key == _key) {
            _rValue = pNode->value;
            return true;
        }
        pNode = pNode->pNext;
    }
    return false;
}

operator=()

const HASHMAP_T & HASHMAP_T::operator=

(

const HASHMAP_T &

_src

)

Definition at line 146 of file __HASHMAP.cpp.

{
    if (&_src != this)
    {
        clear();
        __size = _src.__size;
        __buckets.resize(_src.__buckets.size());
 
        for(size_t index = 0; index < _src.__buckets.size(); index++)
        {
            const HashNode* pNode = (HashNode*) _src.__buckets[index];
            if (pNode != NULL)
            {
                HashNode* pNewNode = createNode(pNode->key);
                pNewNode->value = pNode->value;
                __buckets[index] = pNewNode;
                for(pNode = pNode->pNext; pNode != NULL; pNode = pNode->pNext)
                {
                    pNewNode->pNext = createNode(pNode->key);
                    pNewNode = pNewNode->pNext;
                    pNewNode->value = pNode->value;
                }
            }
        }
    }
    return *this;
}

operator[]()

VALUE_T & HASHMAP_T::operator[]

(

const KEY_T &

_key

)

Definition at line 252 of file __HASHMAP.cpp.

{
    size_t index = bucketIndex(_key);
    HashNode* pFirstNode = (HashNode*)__buckets[index];
    for(HashNode* pCurrentNode = pFirstNode; pCurrentNode!= NULL; 
            pCurrentNode = pCurrentNode->pNext)
    {
        if (pCurrentNode->key == _key)
            return pCurrentNode->value;
    }
    
    HashNode* pNewNode = createNode(_key);
    pNewNode->pNext = pFirstNode;
    __buckets[index] = pNewNode;
    __size++;
    return pNewNode->value;
}

size()

size_t HASHMAP_T::size ( ) const

inline

Definition at line 285 of file __HASHMAP.h.

{
    return __size;
}

sizeOfBucket()

size_t HASHMAP_T::sizeOfBucket

(

size_t

_index

)

const

Definition at line 197 of file __HASHMAP.cpp.

{
    __DCL_ASSERT(_index < __buckets.size());
 
    size_t nCount = 0;
    HashNode* pNode = (HashNode*)__buckets[_index];
    for(; pNode != NULL; pNode = pNode->pNext)
        nCount++;
    return nCount;
}

Friends And Related Symbol Documentation

ConstIterator

friend class ConstIterator

friend

Definition at line 148 of file __HASHMAP.h.

Iterator

friend class Iterator

friend

Definition at line 147 of file __HASHMAP.h.

Member Data Documentation

__buckets

PointerArray HASHMAP_T::__buckets

protected

Definition at line 145 of file __HASHMAP.h.

__hashFun

HASHFUN_T HASHMAP_T::__hashFun

protected

Definition at line 143 of file __HASHMAP.h.

__size

size_t HASHMAP_T::__size

protected

Definition at line 144 of file __HASHMAP.h.

---

The documentation for this class was generated from the following files:

• __HASHMAP.h
• __HASHMAP.cpp