DCL 4.1
Loading...
Searching...
No Matches
HashMap< KEY, VALUE, HASH_FUN > Class Template Reference

#include <__HashMapT-GCC.h>

Inheritance diagram for HashMap< KEY, VALUE, HASH_FUN >:
Object Object

Public Member Functions

virtual ~HashMap ()
void initBuckets (size_t _bucketSize)
 HashMap (size_t _bucketSize=21)
 HashMap (const HashMap &_src)
const HashMap & operator= (const HashMap &_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 &_key)
ConstIterator find (const KEY &_key) const
bool lookup (const KEY &_key, VALUE &_rValue) const
VALUE & operator[] (const KEY &_key)
size_t erase (const KEY &_key)
void clear ()
virtual ~HashMap ()
void initBuckets (size_t _bucketSize)
 HashMap (size_t _bucketSize=21)
 HashMap (const HashMap &_src)
const HashMap & operator= (const HashMap &_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 &_key)
ConstIterator find (const KEY &_key) const
bool lookup (const KEY &_key, VALUE &_rValue) const
VALUE & operator[] (const KEY &_key)
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

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 HashMap< KEY, VALUE, HASH_FUN >

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

Constructor & Destructor Documentation

◆ ~HashMap() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::~HashMap ( )
virtual

Definition at line 355 of file __HashMapT-GCC.h.

356{
357 clear();
358}
HashMap::clear
void clear()
Definition __HashMapT-GCC.h:600

◆ HashMap() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::HashMap ( size_t _bucketSize = 21)

Definition at line 361 of file __HashMapT-GCC.h.

362 : __buckets(DCLGetNextPrimNumber(_bucketSize))
363{
364 __size = 0;
365// __buckets.resize(DCLGetNextPrimNumber(_bucketSize));
366}
DCLGetNextPrimNumber
DCLCAPI size_t DCLGetNextPrimNumber(size_t _n)
Definition HashFun.cpp:23
HashMap::__buckets
PointerArray __buckets
Definition __HashMapT-GCC.h:102
HashMap::__size
size_t __size
Definition __HashMapT-GCC.h:101

◆ HashMap() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::HashMap ( const HashMap< KEY, VALUE, HASH_FUN > & _src)

Definition at line 376 of file __HashMapT-GCC.h.

377{
378 *this = _src;
379}

◆ ~HashMap() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
virtual HashMap< KEY, VALUE, HASH_FUN >::~HashMap ( )
virtual

◆ HashMap() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
HashMap< KEY, VALUE, HASH_FUN >::HashMap ( size_t _bucketSize = 21)

◆ HashMap() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
HashMap< KEY, VALUE, HASH_FUN >::HashMap ( const HashMap< KEY, VALUE, HASH_FUN > & _src)

Member Function Documentation

◆ begin() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::Iterator HashMap< KEY, VALUE, HASH_FUN >::begin ( )

Definition at line 425 of file __HashMapT-GCC.h.

426{
427 for(size_t i = 0; i < __buckets.size(); i++)
428 {
429 if (__buckets[i] != NULL)
430 return Iterator((HashNode*)__buckets[i], this);
431 }
432 return Iterator(NULL, this);
433}
HashMap::Iterator
friend class Iterator
Definition __HashMapT-GCC.h:104

◆ begin() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
Iterator HashMap< KEY, VALUE, HASH_FUN >::begin ( )

◆ begin() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::ConstIterator HashMap< KEY, VALUE, HASH_FUN >::begin ( ) const

Definition at line 413 of file __HashMapT-GCC.h.

414{
415 for(size_t i = 0; i < __buckets.size(); i++)
416 {
417 if (__buckets[i] != NULL)
418 return ConstIterator((HashNode*)__buckets[i], this);
419 }
420 return ConstIterator(NULL, this);
421}
HashMap::ConstIterator
friend class ConstIterator
Definition __HashMapT-GCC.h:105

◆ begin() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
ConstIterator HashMap< KEY, VALUE, HASH_FUN >::begin ( ) const

◆ bucketIndex() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
size_t HashMap< KEY, VALUE, HASH_FUN >::bucketIndex ( const KEY & _key) const
inlineprotected

Definition at line 517 of file __HashMapT-GCC.h.

518{
519 return __hashFun.hashKey(_key) % __buckets.size();
520}
HashMap::__hashFun
HASH_FUN __hashFun
Definition __HashMapT-GCC.h:100

◆ bucketIndex() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
size_t HashMap< KEY, VALUE, HASH_FUN >::bucketIndex ( const KEY & _key) const
protected

◆ bucketSize() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
size_t HashMap< KEY, VALUE, HASH_FUN >::bucketSize ( ) const
inline

Definition at line 250 of file __HashMapT-GCC.h.

251{
252 return __buckets.size();
253}

◆ bucketSize() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
size_t HashMap< KEY, VALUE, HASH_FUN >::bucketSize ( ) const

◆ clear() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
void HashMap< KEY, VALUE, HASH_FUN >::clear ( )

Definition at line 600 of file __HashMapT-GCC.h.

601{
602 for(size_t i = 0; i < __buckets.size(); i++)
603 {
604 HashNode* pNode = (HashNode*)__buckets[i];
605 while(pNode)
606 {
607 HashNode* pNext = pNode->pNext;
608 destroyNode(pNode);
609 pNode = pNext;
610 }
611 __buckets[i] = NULL;
612 }
613 __size = 0;
614}
HashMap::destroyNode
void destroyNode(HashNode *_pNode)
Definition __HashMapT-GCC.h:551

◆ clear() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
void HashMap< KEY, VALUE, HASH_FUN >::clear ( )

◆ createNode() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::HashNode * HashMap< KEY, VALUE, HASH_FUN >::createNode ( const KEY & _key)
protected

Definition at line 524 of file __HashMapT-GCC.h.

525{
526 HashNode* pNode = (HashNode*) malloc(sizeof(HashNode));
527 // FIXME!
528 // if (pNode == NULL)
529 // throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
530 __DCL_ASSERT(pNode != NULL);
531
532 memset((void*) pNode, 0, sizeof(HashNode));
533
534#if __DCL_HAVE_ALLOC_DEBUG
535#undef new
536#endif
537
538 new(&(pNode->key)) KEY;
539 new(&(pNode->value)) VALUE;
540
541#if __DCL_HAVE_ALLOC_DEBUG
542#define new __DCL_DEBUG_NEW
543#endif
544
545 pNode->key = _key;
546 return pNode;
547}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371

◆ createNode() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
HashNode * HashMap< KEY, VALUE, HASH_FUN >::createNode ( const KEY & _key)
protected

◆ destroyNode() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
void HashMap< KEY, VALUE, HASH_FUN >::destroyNode ( HashNode * _pNode)
protected

Definition at line 551 of file __HashMapT-GCC.h.

552{
553 _pNode->key.~KEY();
554 _pNode->value.~VALUE();
555 free(_pNode);
556}

◆ destroyNode() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
void HashMap< KEY, VALUE, HASH_FUN >::destroyNode ( HashNode * _pNode)
protected

◆ end() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::Iterator HashMap< KEY, VALUE, HASH_FUN >::end ( )
inline

Definition at line 234 of file __HashMapT-GCC.h.

235{
236 return Iterator(NULL, this);
237}

◆ end() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
Iterator HashMap< KEY, VALUE, HASH_FUN >::end ( )

◆ end() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::ConstIterator HashMap< KEY, VALUE, HASH_FUN >::end ( ) const
inline

Definition at line 242 of file __HashMapT-GCC.h.

243{
244 return ConstIterator(NULL, this);
245}

◆ end() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
ConstIterator HashMap< KEY, VALUE, HASH_FUN >::end ( ) const

◆ erase() [1/3]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
size_t HashMap< KEY, VALUE, HASH_FUN >::erase ( const Iterator & _it)

◆ erase() [2/3]

template<typename KEY, typename VALUE, typename HASH_FUN>
size_t HashMap< KEY, VALUE, HASH_FUN >::erase ( const KEY & _key)

Definition at line 560 of file __HashMapT-GCC.h.

561{
562 size_t nErased = 0;
563 size_t index = bucketIndex(_key);
564 HashNode* pCurrentNode = (HashNode*)__buckets[index];
565 if (pCurrentNode != NULL)
566 {
567 if (pCurrentNode->key == _key) // first
568 {
569 __buckets[index] = pCurrentNode->pNext;
570 destroyNode(pCurrentNode);
571 nErased++;
572 __size--;
573 }
574 else
575 {
576 HashNode* pNextNode = pCurrentNode->pNext;
577 while(pNextNode != NULL)
578 {
579 if (pNextNode->key == _key)
580 {
581 pCurrentNode->pNext = pNextNode->pNext;
582 destroyNode(pNextNode);
583 nErased++;
584 __size--;
585 break;
586 }
587 else
588 {
589 pCurrentNode = pNextNode;
590 pNextNode = pCurrentNode->pNext;
591 }
592 }
593 }
594 }
595 return nErased;
596}
HashMap::bucketIndex
size_t bucketIndex(const KEY &_key) const
Definition __HashMapT-GCC.h:517

◆ erase() [3/3]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
size_t HashMap< KEY, VALUE, HASH_FUN >::erase ( const KEY & _key)

◆ find() [1/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::Iterator HashMap< KEY, VALUE, HASH_FUN >::find ( const KEY & _key)

Definition at line 450 of file __HashMapT-GCC.h.

451{
452 size_t index = bucketIndex(_key);
453 HashNode* pNode = (HashNode*)__buckets[index];
454 while (pNode) {
455 if (pNode->key == _key) {
456 break;
457 }
458 pNode = pNode->pNext;
459 }
460 return Iterator(pNode, this);
461}

◆ find() [2/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
Iterator HashMap< KEY, VALUE, HASH_FUN >::find ( const KEY & _key)

◆ find() [3/4]

template<typename KEY, typename VALUE, typename HASH_FUN>
HashMap< KEY, VALUE, HASH_FUN >::ConstIterator HashMap< KEY, VALUE, HASH_FUN >::find ( const KEY & _key) const

Definition at line 465 of file __HashMapT-GCC.h.

466{
467 size_t index = bucketIndex(_key);
468 const HashNode* pNode = (HashNode*)__buckets[index];
469 while (pNode) {
470 if (pNode->key == _key) {
471 break;
472 }
473 pNode = pNode->pNext;
474 }
475 return ConstIterator(pNode, this);
476}

◆ find() [4/4]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
ConstIterator HashMap< KEY, VALUE, HASH_FUN >::find ( const KEY & _key) const

◆ initBuckets() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
void HashMap< KEY, VALUE, HASH_FUN >::initBuckets ( size_t _bucketSize)

Definition at line 369 of file __HashMapT-GCC.h.

370{
371 clear();
372 __buckets.resize(DCLGetNextPrimNumber(_bucketSize));
373}

◆ initBuckets() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
void HashMap< KEY, VALUE, HASH_FUN >::initBuckets ( size_t _bucketSize)

◆ isEmpty() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
bool HashMap< KEY, VALUE, HASH_FUN >::isEmpty ( ) const
inline

Definition at line 266 of file __HashMapT-GCC.h.

267{
268 return __size == 0;
269}

◆ isEmpty() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
bool HashMap< KEY, VALUE, HASH_FUN >::isEmpty ( ) const

◆ lookup() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
bool HashMap< KEY, VALUE, HASH_FUN >::lookup ( const KEY & _key,
VALUE & _rValue ) const

Definition at line 480 of file __HashMapT-GCC.h.

481{
482 size_t index = bucketIndex(_key);
483 HashNode* pNode = (HashNode*)__buckets[index];
484 while(pNode != NULL) {
485 if (pNode->key == _key) {
486 _rValue = pNode->value;
487 return true;
488 }
489 pNode = pNode->pNext;
490 }
491 return false;
492}

◆ lookup() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
bool HashMap< KEY, VALUE, HASH_FUN >::lookup ( const KEY & _key,
VALUE & _rValue ) const

◆ operator=() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
const HashMap< KEY, VALUE, HASH_FUN > & HashMap< KEY, VALUE, HASH_FUN >::operator= ( const HashMap< KEY, VALUE, HASH_FUN > & _src)

Definition at line 383 of file __HashMapT-GCC.h.

384{
385 if (&_src != this)
386 {
387 clear();
388 __size = _src.__size;
389 __buckets.resize(_src.__buckets.size());
390
391 for(size_t index = 0; index < _src.__buckets.size(); index++)
392 {
393 const HashNode* pNode = (HashNode*) _src.__buckets[index];
394 if (pNode != NULL)
395 {
396 HashNode* pNewNode = createNode(pNode->key);
397 pNewNode->value = pNode->value;
398 __buckets[index] = pNewNode;
399 for(pNode = pNode->pNext; pNode != NULL; pNode = pNode->pNext)
400 {
401 pNewNode->pNext = createNode(pNode->key);
402 pNewNode = pNewNode->pNext;
403 pNewNode->value = pNode->value;
404 }
405 }
406 }
407 }
408 return *this;
409}
HashMap::createNode
HashNode * createNode(const KEY &_key)
Definition __HashMapT-GCC.h:524

◆ operator=() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
const HashMap & HashMap< KEY, VALUE, HASH_FUN >::operator= ( const HashMap< KEY, VALUE, HASH_FUN > & _src)

◆ operator[]() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
VALUE & HashMap< KEY, VALUE, HASH_FUN >::operator[] ( const KEY & _key)

Definition at line 496 of file __HashMapT-GCC.h.

497{
498 size_t index = bucketIndex(_key);
499 HashNode* pFirstNode = (HashNode*)__buckets[index];
500 for(HashNode* pCurrentNode = pFirstNode; pCurrentNode!= NULL;
501 pCurrentNode = pCurrentNode->pNext)
502 {
503 if (pCurrentNode->key == _key)
504 return pCurrentNode->value;
505 }
506
507 HashNode* pNewNode = createNode(_key);
508 pNewNode->pNext = pFirstNode;
509 __buckets[index] = pNewNode;
510 __size++;
511 return pNewNode->value;
512}

◆ operator[]() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
VALUE & HashMap< KEY, VALUE, HASH_FUN >::operator[] ( const KEY & _key)

◆ size() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
size_t HashMap< KEY, VALUE, HASH_FUN >::size ( ) const
inline

Definition at line 258 of file __HashMapT-GCC.h.

259{
260 return __size;
261}

◆ size() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
size_t HashMap< KEY, VALUE, HASH_FUN >::size ( ) const

◆ sizeOfBucket() [1/2]

template<typename KEY, typename VALUE, typename HASH_FUN>
size_t HashMap< KEY, VALUE, HASH_FUN >::sizeOfBucket ( size_t _index) const

Definition at line 437 of file __HashMapT-GCC.h.

438{
439 __DCL_ASSERT(_index < __buckets.size());
440
441 size_t nCount = 0;
442 HashNode* pNode = (HashNode*)__buckets[_index];
443 for(; pNode != NULL; pNode = pNode->pNext)
444 nCount++;
445 return nCount;
446}

◆ sizeOfBucket() [2/2]

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
size_t HashMap< KEY, VALUE, HASH_FUN >::sizeOfBucket ( size_t index) const

◆ ConstIterator

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

Definition at line 105 of file __HashMapT-GCC.h.

◆ Iterator

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

Definition at line 104 of file __HashMapT-GCC.h.

Member Data Documentation

◆ __buckets

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
PointerArray HashMap< KEY, VALUE, HASH_FUN >::__buckets
protected

Definition at line 102 of file __HashMapT-GCC.h.

◆ __hashFun

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
HASH_FUN HashMap< KEY, VALUE, HASH_FUN >::__hashFun
protected

Definition at line 100 of file __HashMapT-GCC.h.

◆ __size

template<typename KEY, typename VALUE, typename HASH_FUN = HashFun<KEY>>
size_t HashMap< KEY, VALUE, HASH_FUN >::__size
protected

Definition at line 101 of file __HashMapT-GCC.h.

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