ListedHashMap< KEY, VALUE, HASH_FUN > Class Template Reference

#include <__ListedHashMapT-GCC.h>

Inheritance diagram for ListedHashMap< KEY, VALUE, HASH_FUN >:

Public Member Functions
virtual	~ListedHashMap ()
void	initBuckets (size_t _bucketSize)
	ListedHashMap (size_t _bucketSize=21)
	ListedHashMap (const ListedHashMap &_src)
const ListedHashMap &	operator= (const ListedHashMap &_src)
ConstIterator	begin () const
ConstIterator	end () const
Iterator	begin ()
Iterator	end ()
ReverseConstIterator	rbegin () const
ReverseConstIterator	rend () const
ReverseIterator	rbegin ()
ReverseIterator	rend ()
size_t	bucketSize () const
size_t	size () const
size_t	sizeOfBucket (size_t index) const
bool	isEmpty () const
Iterator	find (const KEY &_key)
ConstIterator	find (const KEY &_key) const
bool	lookup (const KEY &_key, VALUE &_rValue) const
VALUE &	operator[] (const KEY &_key)
void	put (const KEY &_key, const VALUE &_value, UpdateCallback &_cb)
size_t	erase (const KEY &_key)
size_t	erase (const Iterator &_it)
void	clear ()
virtual	~ListedHashMap ()
void	initBuckets (size_t _bucketSize)
	ListedHashMap (size_t _bucketSize=21)
	ListedHashMap (const ListedHashMap &_src)
const ListedHashMap &	operator= (const ListedHashMap &_src)
ConstIterator	begin () const
ConstIterator	end () const
Iterator	begin ()
Iterator	end ()
ReverseConstIterator	rbegin () const
ReverseConstIterator	rend () const
ReverseIterator	rbegin ()
ReverseIterator	rend ()
size_t	bucketSize () const
size_t	size () const
size_t	sizeOfBucket (size_t index) const
bool	isEmpty () const
Iterator	find (const KEY &_key)
ConstIterator	find (const KEY &_key) const
bool	lookup (const KEY &_key, VALUE &_rValue) const
VALUE &	operator[] (const KEY &_key)
void	put (const KEY &_key, const VALUE &_value, UpdateCallback &_cb)
size_t	erase (const KEY &_key)
size_t	erase (const Iterator &_it)
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 &_key) const
HashNode *	createNode (const KEY &_key)
void	destroyNode (HashNode *_pNode)
size_t	bucketIndex (const KEY &_key) const
HashNode *	createNode (const KEY &_key)
void	destroyNode (HashNode *_pNode)
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Protected Attributes
NodeBase *	__pMasterNode
HASH_FUN	__hashFun
size_t	__size
PointerArray	__buckets

Friends
class	Iterator
class	ConstIterator

Detailed Description

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
class ListedHashMap< KEY, VALUE, HASH_FUN >

Definition at line 14 of file __ListedHashMapT-GCC.h.

Constructor & Destructor Documentation

~ListedHashMap() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::~ListedHashMap ( )

virtual

Definition at line 643 of file __ListedHashMapT-GCC.h.

{
    clear();
    free (__pMasterNode);
}

ListedHashMap() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ListedHashMap

(

size_t

_bucketSize = 21

)

Definition at line 650 of file __ListedHashMapT-GCC.h.

    : __buckets(DCLGetNextPrimNumber(_bucketSize))
{
    __pMasterNode = (NodeBase*) malloc(sizeof(NodeBase));
    // FIXME!
    // if (pNode == NULL)
    //      throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
    __DCL_ASSERT(__pMasterNode != NULL);
 
    __pMasterNode->pPrev = __pMasterNode;
    __pMasterNode->pNext = __pMasterNode;
    __size = 0;
//  __buckets.resize(DCLGetNextPrimNumber(_bucketSize));
}

ListedHashMap() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ListedHashMap

(

const ListedHashMap< KEY, VALUE, HASH_FUN > &

_src

)

Definition at line 674 of file __ListedHashMapT-GCC.h.

{
    __pMasterNode = (NodeBase*) malloc(sizeof(NodeBase));
    // FIXME!
    // if (pNode == NULL)
    //      throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
    __DCL_ASSERT(__pMasterNode != NULL);
 
    __pMasterNode->pPrev = __pMasterNode;
    __pMasterNode->pNext = __pMasterNode;
    __size = 0;
 
    *this = _src;
}

~ListedHashMap() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

virtual ListedHashMap< KEY, VALUE, HASH_FUN >::~ListedHashMap ( )

virtual

ListedHashMap() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ListedHashMap< KEY, VALUE, HASH_FUN >::ListedHashMap

(

size_t

_bucketSize = 21

)

ListedHashMap() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ListedHashMap< KEY, VALUE, HASH_FUN >::ListedHashMap

(

const ListedHashMap< KEY, VALUE, HASH_FUN > &

_src

)

Member Function Documentation

begin() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::Iterator ListedHashMap< KEY, VALUE, HASH_FUN >::begin ( )

inline

Definition at line 546 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode->pNext;
}

begin() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

Iterator ListedHashMap< KEY, VALUE, HASH_FUN >::begin

(

)

begin() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::begin ( ) const

inline

Definition at line 530 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode->pNext;
}

begin() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::begin

(

)

const

bucketIndex() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::bucketIndex ( const KEY & _key ) const

inlineprotected

Definition at line 826 of file __ListedHashMapT-GCC.h.

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

bucketIndex() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::bucketIndex ( const KEY & _key ) const

protected

bucketSize() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::bucketSize ( ) const

inline

Definition at line 596 of file __ListedHashMapT-GCC.h.

{
    return __buckets.size();
}

bucketSize() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::bucketSize

(

)

const

clear() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

void ListedHashMap< KEY, VALUE, HASH_FUN >::clear

(

)

Definition at line 917 of file __ListedHashMapT-GCC.h.

{
    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;
}

clear() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

void ListedHashMap< KEY, VALUE, HASH_FUN >::clear

(

)

createNode() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::HashNode * ListedHashMap< KEY, VALUE, HASH_FUN >::createNode ( const KEY & _key )

protected

Definition at line 833 of file __ListedHashMapT-GCC.h.

{
    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
 
    new(&(pNode->key)) KEY;
    new(&(pNode->value)) VALUE;
 
#if __DCL_HAVE_ALLOC_DEBUG
#define new __DCL_DEBUG_NEW
#endif
 
    ((NodeBase*) pNode)->pPrev = __pMasterNode->pPrev;
    ((NodeBase*) pNode)->pNext = __pMasterNode;
    __pMasterNode->pPrev->pNext = pNode;
    __pMasterNode->pPrev = pNode;
 
    pNode->key = _key;
    return pNode;
}

createNode() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

HashNode * ListedHashMap< KEY, VALUE, HASH_FUN >::createNode ( const KEY & _key )

protected

destroyNode() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

void ListedHashMap< KEY, VALUE, HASH_FUN >::destroyNode ( HashNode * _pNode )

protected

Definition at line 865 of file __ListedHashMapT-GCC.h.

{
    ((NodeBase*) _pNode)->pPrev->pNext = ((NodeBase*) _pNode)->pNext;
    ((NodeBase*) _pNode)->pNext->pPrev = ((NodeBase*) _pNode)->pPrev;
 
    _pNode->key.~KEY();
    _pNode->value.~VALUE();
    free(_pNode);
}

destroyNode() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

void ListedHashMap< KEY, VALUE, HASH_FUN >::destroyNode ( HashNode * _pNode )

protected

end() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::Iterator ListedHashMap< KEY, VALUE, HASH_FUN >::end ( )

inline

Definition at line 554 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode;
}

end() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

Iterator ListedHashMap< KEY, VALUE, HASH_FUN >::end

(

)

end() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::end ( ) const

inline

Definition at line 538 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode;
}

end() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::end

(

)

const

erase() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::erase

(

const Iterator &

_it

)

erase() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::erase

(

const Iterator &

_it

)

erase() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::erase

(

const KEY &

_key

)

Definition at line 877 of file __ListedHashMapT-GCC.h.

{
    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;
}

erase() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::erase

(

const KEY &

_key

)

find() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::Iterator ListedHashMap< KEY, VALUE, HASH_FUN >::find

(

const KEY &

_key

)

Definition at line 734 of file __ListedHashMapT-GCC.h.

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

find() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

Iterator ListedHashMap< KEY, VALUE, HASH_FUN >::find

(

const KEY &

_key

)

find() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::find

(

const KEY &

_key

)

const

Definition at line 749 of file __ListedHashMapT-GCC.h.

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

find() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::find

(

const KEY &

_key

)

const

initBuckets() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

void ListedHashMap< KEY, VALUE, HASH_FUN >::initBuckets

(

size_t

_bucketSize

)

Definition at line 667 of file __ListedHashMapT-GCC.h.

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

initBuckets() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

void ListedHashMap< KEY, VALUE, HASH_FUN >::initBuckets

(

size_t

_bucketSize

)

isEmpty() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

bool ListedHashMap< KEY, VALUE, HASH_FUN >::isEmpty ( ) const

inline

Definition at line 612 of file __ListedHashMapT-GCC.h.

{
    return __size == 0;
}

isEmpty() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

bool ListedHashMap< KEY, VALUE, HASH_FUN >::isEmpty

(

)

const

lookup() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

bool ListedHashMap< KEY, VALUE, HASH_FUN >::lookup	(	const KEY &	_key,
		VALUE &	_rValue ) const

Definition at line 764 of file __ListedHashMapT-GCC.h.

{
    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;
}

lookup() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

bool ListedHashMap< KEY, VALUE, HASH_FUN >::lookup	(	const KEY &	_key,
		VALUE &	_rValue ) const

operator=() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

const ListedHashMap< KEY, VALUE, HASH_FUN > & ListedHashMap< KEY, VALUE, HASH_FUN >::operator=

(

const ListedHashMap< KEY, VALUE, HASH_FUN > &

_src

)

Definition at line 691 of file __ListedHashMapT-GCC.h.

{
    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=() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

const ListedHashMap & ListedHashMap< KEY, VALUE, HASH_FUN >::operator=

(

const ListedHashMap< KEY, VALUE, HASH_FUN > &

_src

)

operator[]() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

VALUE & ListedHashMap< KEY, VALUE, HASH_FUN >::operator[]

(

const KEY &

_key

)

Definition at line 780 of file __ListedHashMapT-GCC.h.

{
    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;
}

operator[]() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

VALUE & ListedHashMap< KEY, VALUE, HASH_FUN >::operator[]

(

const KEY &

_key

)

put() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

void ListedHashMap< KEY, VALUE, HASH_FUN >::put	(	const KEY &	_key,
		const VALUE &	_value,
		UpdateCallback &	_cb )

_key와 동일한 노드가 있으면 _value를 변경하기 전에 _cb를 호출한다.

Definition at line 801 of file __ListedHashMapT-GCC.h.

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

put() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

void ListedHashMap< KEY, VALUE, HASH_FUN >::put	(	const KEY &	_key,
		const VALUE &	_value,
		UpdateCallback &	_cb )

_key와 동일한 노드가 있으면 _value를 변경하기 전에 _cb를 호출한다.

rbegin() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ReverseIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rbegin ( )

inline

Definition at line 578 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode->pPrev;
}

rbegin() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ReverseIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rbegin

(

)

rbegin() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ReverseConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rbegin ( ) const

inline

Definition at line 562 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode->pPrev;
}

rbegin() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ReverseConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rbegin

(

)

const

rend() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ReverseIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rend ( )

inline

Definition at line 586 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode;
}

rend() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ReverseIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rend

(

)

rend() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>

ListedHashMap< KEY, VALUE, HASH_FUN >::ReverseConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rend ( ) const

inline

Definition at line 570 of file __ListedHashMapT-GCC.h.

{
    return __pMasterNode;
}

rend() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ReverseConstIterator ListedHashMap< KEY, VALUE, HASH_FUN >::rend

(

)

const

size() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::size ( ) const

inline

Definition at line 604 of file __ListedHashMapT-GCC.h.

{
    return __size;
}

size() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::size

(

)

const

sizeOfBucket() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::sizeOfBucket

(

size_t

index

)

const

Definition at line 721 of file __ListedHashMapT-GCC.h.

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

sizeOfBucket() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::sizeOfBucket

(

size_t

index

)

const

Friends And Related Symbol Documentation

ConstIterator

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

ConstIterator

friend

Definition at line 162 of file __ListedHashMapT-GCC.h.

Iterator

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

Iterator

friend

Definition at line 161 of file __ListedHashMapT-GCC.h.

Member Data Documentation

__buckets

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

PointerArray ListedHashMap< KEY, VALUE, HASH_FUN >::__buckets

protected

Definition at line 159 of file __ListedHashMapT-GCC.h.

__hashFun

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

HASH_FUN ListedHashMap< KEY, VALUE, HASH_FUN >::__hashFun

protected

Definition at line 157 of file __ListedHashMapT-GCC.h.

__pMasterNode

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

NodeBase * ListedHashMap< KEY, VALUE, HASH_FUN >::__pMasterNode

protected

Definition at line 156 of file __ListedHashMapT-GCC.h.

__size

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>

size_t ListedHashMap< KEY, VALUE, HASH_FUN >::__size

protected

Definition at line 158 of file __ListedHashMapT-GCC.h.

---

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

• __ListedHashMapT-GCC.h
• __ListedHashMapT-MSC.h