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

Diff for /pegasus/src/Pegasus/Common/HashTable.h between version 1.22 and 1.28

version 1.22, 2006/01/30 16:17:04 version 1.28, 2008/11/12 21:27:05
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company  
 //                  (carolann_graves@hp.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_HashTable_h #ifndef Pegasus_HashTable_h
Line 148 
Line 143 
     _BucketBase* next;     _BucketBase* next;
 }; };
  
 class _HashTableRep;  
   
 /* This class implements a simple hash table forward iterator. */ /* This class implements a simple hash table forward iterator. */
 class PEGASUS_COMMON_LINKAGE _HashTableIteratorBase class PEGASUS_COMMON_LINKAGE _HashTableIteratorBase
 { {
 public: public:
  
     _HashTableIteratorBase() : _first(0), _last(0), _bucket(0) { }      _HashTableIteratorBase(_BucketBase** first, _BucketBase** last);
  
     operator int() const { return _bucket != 0; }     operator int() const { return _bucket != 0; }
  
     _HashTableIteratorBase operator++(int);      void operator++();
  
     _HashTableIteratorBase& operator++();      void operator++(int)
       {
     _HashTableIteratorBase(_BucketBase** first, _BucketBase** last);          operator++();
       }
  
 protected: protected:
  
       // Note:  The default copy constructor/assignment operator is used by the
       // postfix increment operator.  The member pointers may be safely copied
       // because they refer to structures that must not change while the iterator
       // is in scope.
   
     _BucketBase** _first;     _BucketBase** _first;
     _BucketBase** _last;     _BucketBase** _last;
     _BucketBase* _bucket;     _BucketBase* _bucket;
     friend class _HashTableRep;  
 }; };
  
 // ATTN: reorganization not supported yet. // ATTN: reorganization not supported yet.
Line 304 
Line 302 
 { {
 public: public:
  
     _HashTableIterator()  
         : _HashTableIteratorBase() { }  
   
     _HashTableIterator(_BucketBase** first, _BucketBase** last)     _HashTableIterator(_BucketBase** first, _BucketBase** last)
         : _HashTableIteratorBase(first, last) { }         : _HashTableIteratorBase(first, last) { }
  
Line 378 
Line 373 
     (which by the way has exactly the same effect).     (which by the way has exactly the same effect).
  
         <pre>         <pre>
         typedef HashTable&lt;String, Uint32, EqualFunc&lt;String&gt;, HashFunc&lt;String&gt;&gt; HT;          typedef HashTable&lt;String, Uint32,
               EqualFunc&lt;String&gt;, HashFunc&lt;String&gt;&gt; HT;
         </pre>         </pre>
  
     The third and forth arguments are described more in detail later.      The third and fourth arguments are described more in detail later.
  
     Then, entries may be inserted like this:     Then, entries may be inserted like this:
  
Line 532 
Line 528 
     */     */
     Boolean lookup(const K& key, V& value) const;     Boolean lookup(const K& key, V& value) const;
  
       /** Looks up the entry with the given key and returns a pointer to the
           value.  Note that this pointer may become invalid when the HashTable
           is updated.
           @param key key of entry to be located.
           @param value Output pointer to the value.
           @return true if found; false otherwise.
       */
       Boolean lookupReference(const K& key, V*& value);
   
     /** Removes the entry with the given key.     /** Removes the entry with the given key.
         @param key key of entry to be removed.         @param key key of entry to be removed.
         @return true on success; false otherwise.         @return true on success; false otherwise.
Line 568 
Line 573 
     return false;     return false;
 } }
  
   template<class K, class V, class E, class H>
   inline Boolean HashTable<K, V, E, H>::lookupReference(const K& key, V*& value)
   {
       _Bucket<K, V, E>* bucket =
           (_Bucket<K, V, E>*)_rep.lookup(H::hash(key), &key);
   
       if (bucket)
       {
           value = &bucket->getValue();
           return true;
       }
   
       return false;
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif /* Pegasus_HashTable_h */ #endif /* Pegasus_HashTable_h */

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