(file) Return to HashTable.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/HashTable.cpp between version 1.1 and 1.2

version 1.1, 2001/04/27 00:01:00 version 1.2, 2001/04/27 01:05:03
Line 48 
Line 48 
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // HashTableBase::BucketBase  // _HashTableBase::_BucketBase
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 BucketBase::~BucketBase()  _BucketBase::~_BucketBase()
 { {
  
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // HashTableIteratorBase  // _HashTableIteratorBase
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 HashTableIteratorBase HashTableIteratorBase::operator++(int)  _HashTableIteratorBase _HashTableIteratorBase::operator++(int)
 { {
     HashTableIteratorBase tmp = *this;      _HashTableIteratorBase tmp = *this;
     operator++();     operator++();
     return tmp;     return tmp;
 } }
  
 HashTableIteratorBase& HashTableIteratorBase::operator++()  _HashTableIteratorBase& _HashTableIteratorBase::operator++()
 { {
     // At the end?     // At the end?
  
Line 100 
Line 100 
     return *this;     return *this;
 } }
  
 HashTableIteratorBase::HashTableIteratorBase(  _HashTableIteratorBase::_HashTableIteratorBase(
     BucketBase** first,      _BucketBase** first,
     BucketBase** last) : _first(first), _last(last)      _BucketBase** last) : _first(first), _last(last)
 { {
     while (_first != last)     while (_first != last)
     {     {
Line 118 
Line 118 
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // HashTableBase  // _HashTableBase
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 HashTableBase::HashTableBase(Uint32 numChains) : _size(0), _numChains(numChains)  _HashTableBase::_HashTableBase(Uint32 numChains) : _size(0), _numChains(numChains)
 { {
     if (numChains < 8)     if (numChains < 8)
         numChains = 8;         numChains = 8;
  
     _chains = new BucketBase*[_numChains];      _chains = new _BucketBase*[_numChains];
     memset(_chains, 0, sizeof(BucketBase*) * _numChains);      memset(_chains, 0, sizeof(_BucketBase*) * _numChains);
 } }
  
 HashTableBase::~HashTableBase()  _HashTableBase::_HashTableBase(const _HashTableBase& x)
 { {
       _size = 0;
       _numChains = 0;
       _chains = 0;
       operator=(x);
   }
   
   _HashTableBase::~_HashTableBase()
   {
       clear();
       delete [] _chains;
   }
   
   _HashTableBase& _HashTableBase::operator=(const _HashTableBase& x)
   {
       if (this == &x)
           return *this;
   
       // Destroy the old representation:
   
     clear();     clear();
   
       if (_chains)
           delete [] _chains;
   
       // Create chain array:
   
       _chains = new _BucketBase*[_numChains = x._numChains];
       memset(_chains, 0, sizeof(_BucketBase*) * _numChains);
       _size = x._size;
   
       // Copy over the buckets:
   
       for (Uint32 i = 0; i < _numChains; i++)
       {
           if (x._chains[i])
           {
               _chains[i] = x._chains[i]->clone();
   
               _BucketBase* curr = _chains[i];
               _BucketBase* next = x._chains[i]->next;
   
               for (; next; next = next->next)
               {
                   curr->next = next->clone();
                   curr = curr->next;
               }
           }
 } }
  
 void HashTableBase::clear()      return *this;
   }
   
   void _HashTableBase::clear()
 { {
     for (Uint32 i = 0; i < _numChains; i++)     for (Uint32 i = 0; i < _numChains; i++)
     {     {
         for (BucketBase* bucket = _chains[i]; bucket; )          for (_BucketBase* bucket = _chains[i]; bucket; )
         {         {
             BucketBase* next = bucket->next;              _BucketBase* next = bucket->next;
             delete bucket;             delete bucket;
             bucket = next;             bucket = next;
         }         }
     }     }
  
     _size = 0;     _size = 0;
     memset(_chains, 0, sizeof(BucketBase*) * _numChains);  
       if (_numChains)
           memset(_chains, 0, sizeof(_BucketBase*) * _numChains);
 } }
  
 Boolean HashTableBase::insert(  Boolean _HashTableBase::insert(
     Uint32 hashCode,     Uint32 hashCode,
     BucketBase* bucket,      _BucketBase* bucket,
     const void* key)     const void* key)
 { {
     // Check for duplicate entry with same key:     // Check for duplicate entry with same key:
  
     Uint32 i = hashCode % _numChains;     Uint32 i = hashCode % _numChains;
     BucketBase* last = 0;      _BucketBase* last = 0;
  
     for (BucketBase* bucket = _chains[i]; bucket; bucket = bucket->next)      for (_BucketBase* bucket = _chains[i]; bucket; bucket = bucket->next)
     {     {
         if (bucket->equal(key))         if (bucket->equal(key))
         {         {
Line 186 
Line 237 
     return true;     return true;
 } }
  
 const BucketBase* HashTableBase::lookup(  const _BucketBase* _HashTableBase::lookup(
     Uint32 hashCode,     Uint32 hashCode,
     const void* key)     const void* key)
 { {
     Uint32 i = hashCode % _numChains;     Uint32 i = hashCode % _numChains;
  
     for (BucketBase* bucket = _chains[i]; bucket; bucket = bucket->next)      for (_BucketBase* bucket = _chains[i]; bucket; bucket = bucket->next)
     {     {
         if (bucket->equal(key))         if (bucket->equal(key))
             return bucket;             return bucket;
Line 202 
Line 253 
     return 0;     return 0;
 } }
  
 Boolean HashTableBase::remove(Uint32 hashCode, const void* key)  Boolean _HashTableBase::remove(Uint32 hashCode, const void* key)
 { {
     for (Uint32 i = 0; i < _numChains; i++)     for (Uint32 i = 0; i < _numChains; i++)
     {     {
         BucketBase* prev = 0;          _BucketBase* prev = 0;
  
         for (BucketBase* bucket = _chains[i]; bucket; bucket = bucket->next)          for (_BucketBase* bucket = _chains[i]; bucket; bucket = bucket->next)
         {         {
             if (bucket->equal(key))             if (bucket->equal(key))
             {             {

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2