(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.20 and 1.28

version 1.20, 2005/08/10 19:42:49 version 1.28, 2008/11/12 21:27:05
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
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 70 
Line 67 
     }     }
 }; };
  
 /*  //
     Hash function object that converts to lowercase.  // Computes a hash code for a string without regard to case. For example, it
   // yields the same hash code for "AB", "ab", "Ab", and "aB".
     This function can be used for hash table keys constructed from strings that  //
     should be treated as case insensitive (e.g. class names, namespace names,  struct PEGASUS_COMMON_LINKAGE HashLowerCaseFunc
     system names).  
   
     Note: this function converts to lower case based on the process locale.  
 */  
 struct HashLowerCaseFunc  
 {  
     static Uint32 hash (const String & str)  
     {     {
         String cpy (str);      static Uint32 hash(const String& str);
         cpy.toLower ();  
         Uint32 h = 0;  
         for (Uint32 i = 0, n = cpy.size (); i < n; i++)  
             h = 5 * h + cpy [i];  
         return h;  
     }  
 }; };
  
 /*  This is a function object used by the HashTable to compare keys. This is /*  This is a function object used by the HashTable to compare keys. This is
Line 159 
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++();  
  
     _HashTableIteratorBase(_BucketBase** first, _BucketBase** last);      void operator++(int)
       {
           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 315 
Line 302 
 { {
 public: public:
  
     _HashTableIterator()  
         : _HashTableIteratorBase() { }  
   
     _HashTableIterator(_BucketBase** first, _BucketBase** last)     _HashTableIterator(_BucketBase** first, _BucketBase** last)
         : _HashTableIteratorBase(first, last) { }         : _HashTableIteratorBase(first, last) { }
  
Line 389 
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 543 
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 579 
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.20  
changed lines
  Added in v.1.28
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2