(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.3 and 1.22

version 1.3, 2001/04/27 18:46:20 version 1.22, 2006/01/30 16:17:04
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // 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  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
 // //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // DEALINGS IN THE SOFTWARE.  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 30 
Line 41 
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/String.h> #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/CIMObjectPath.h>
   #include <Pegasus/Common/Linkage.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 41 
Line 54 
 { {
 }; };
  
 template<> struct PEGASUS_COMMON_LINKAGE HashFunc<String>  PEGASUS_TEMPLATE_SPECIALIZATION struct PEGASUS_COMMON_LINKAGE HashFunc<String>
 { {
     static Uint32 hash(const String& str);     static Uint32 hash(const String& str);
 }; };
  
 template<> struct HashFunc<Uint32>  PEGASUS_TEMPLATE_SPECIALIZATION struct HashFunc<Uint32>
 { {
     static Uint32 hash(Uint32 x) { return x + 13; }     static Uint32 hash(Uint32 x) { return x + 13; }
 }; };
  
   PEGASUS_TEMPLATE_SPECIALIZATION struct HashFunc <CIMObjectPath>
   {
       static Uint32 hash (const CIMObjectPath & path)
       {
           return path.makeHashCode ();
       }
   };
   
   //
   // 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".
   //
   struct PEGASUS_COMMON_LINKAGE HashLowerCaseFunc
   {
       static Uint32 hash(const String& str);
   };
   
 /*  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
     the default implementation. Others may be defined and passed in the     the default implementation. Others may be defined and passed in the
     template argument list to perform other kinds of comparisons.     template argument list to perform other kinds of comparisons.
Line 64 
Line 94 
     }     }
 }; };
  
   PEGASUS_TEMPLATE_SPECIALIZATION struct EqualFunc <CIMObjectPath>
   {
       static Boolean equal (const CIMObjectPath & x, const CIMObjectPath & y)
       {
           return x.identical (y);
       }
   };
   
   /*
       Equal function object that can be used by HashTable to compare keys that
       should be treated as case insensitive.
   
       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,
       system names).
   
       Note: this function compares Strings based on the process locale.
   */
   struct EqualNoCaseFunc
   {
       static Boolean equal (const String & x, const String & y)
       {
           return (0 == String::compareNoCase (x, y));
       }
   };
   
 /*  Representation for a bucket. The HashTable class derives from this /*  Representation for a bucket. The HashTable class derives from this
     bucket to append a key and value. This base class just defines     bucket to append a key and value. This base class just defines
     the pointer to the next bucket in the chain.     the pointer to the next bucket in the chain.
Line 101 
Line 157 
  
     _HashTableIteratorBase() : _first(0), _last(0), _bucket(0) { }     _HashTableIteratorBase() : _first(0), _last(0), _bucket(0) { }
  
     operator Boolean() const { return _bucket != 0; }      operator int() const { return _bucket != 0; }
  
     _HashTableIteratorBase operator++(int);     _HashTableIteratorBase operator++(int);
  
Line 114 
Line 170 
     _BucketBase** _first;     _BucketBase** _first;
     _BucketBase** _last;     _BucketBase** _last;
     _BucketBase* _bucket;     _BucketBase* _bucket;
     friend _HashTableRep;      friend class _HashTableRep;
 }; };
  
 // ATTN: reorganization not supported yet. // ATTN: reorganization not supported yet.
Line 156 
Line 212 
     _HashTableRep& operator=(const _HashTableRep& x);     _HashTableRep& operator=(const _HashTableRep& x);
  
     /*- Returns the size of this hash table (the number of entries). */     /*- Returns the size of this hash table (the number of entries). */
     Uint32 getSize() const { return _size; }      Uint32 size() const { return _size; }
  
     /*- Clears the contents of this hash table. After this is called, the     /*- Clears the contents of this hash table. After this is called, the
         getSize() method returns zero.          size() method returns zero.
     */     */
     void clear();     void clear();
  
Line 178 
Line 234 
         @param key void pointer to key.         @param key void pointer to key.
         @return pointer to bucket with that key or zero otherwise.         @return pointer to bucket with that key or zero otherwise.
     */     */
     const _BucketBase* lookup(Uint32 hashCode, const void* key);      const _BucketBase* lookup(Uint32 hashCode, const void* key) const;
  
     /*- Removes the bucket with the given key. This method uses the     /*- Removes the bucket with the given key. This method uses the
         _BucketBase::equal() method to compare keys.         _BucketBase::equal() method to compare keys.
Line 358 
Line 414 
         }         }
         </pre>         </pre>
  
     Note that only forward iteration is supported (no backwards iteration).      Note that only forward iteration is supported (no backwards iteration),
       AND that the hashtable MUST NOT be modified during the iteration!!!
  
     Equality of keys is determined using the EqualFunc class which is     Equality of keys is determined using the EqualFunc class which is
     the default third argument of the template argument list. A new function     the default third argument of the template argument list. A new function
Line 407 
Line 464 
     the pathalogical case in which all entries are placed in the first     the pathalogical case in which all entries are placed in the first
     chain.     chain.
 */ */
 template<class K, class V, class E = EqualFunc<K>, class H = HashFunc<K> >  template<class K, class V, class E , class H >
 class HashTable class HashTable
 { {
 public: public:
Line 426 
Line 483 
     }     }
  
     /** Copy constructor. */     /** Copy constructor. */
     HashTable(const HashTable& x) : _rep(x._rep)      HashTable(const HashTable<K,V,E,H>& x) : _rep(x._rep)
     {     {
  
     }     }
  
     /** Assignment operator. */     /** Assignment operator. */
     HashTable& operator=(const HashTable& x)      HashTable<K,V,E,H>& operator=(const HashTable<K,V,E,H>& x)
     {     {
         if (this != &x)         if (this != &x)
             _rep = x._rep;             _rep = x._rep;
Line 440 
Line 497 
     }     }
  
     /** Returns the size of this hash table (the number of entries). */     /** Returns the size of this hash table (the number of entries). */
     Uint32 getSize() const { return _rep.getSize(); }      Uint32 size() const { return _rep.size(); }
  
     /** Clears the contents of this hash table. After this is called, the     /** Clears the contents of this hash table. After this is called, the
         getSize() method returns zero.          size() method returns zero.
     */     */
     void clear() { _rep.clear(); }     void clear() { _rep.clear(); }
  
Line 458 
Line 515 
             H::hash(key), new _Bucket<K, V, E>(key, value), &key);             H::hash(key), new _Bucket<K, V, E>(key, value), &key);
     }     }
  
       /** Checks to see if hash table contains an entry with the given key.
           @param key key to be searched for
           @return true if hash table contains an entry with the given key.
       */
       Boolean contains(const K& key) const
       {
           V value;
           return lookup(key, value);
       }
   
     /** Looks up the entry with the given key.     /** Looks up the entry with the given key.
         @param key key of entry to be located.         @param key key of entry to be located.
         @param value output value.         @param value output value.
         @return true if found; false otherwise.         @return true if found; false otherwise.
     */     */
     Boolean lookup(const K& key, V& value);      Boolean lookup(const K& key, V& value) const;
  
     /** 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.
Line 487 
Line 554 
 }; };
  
 template<class K, class V, class E, class H> template<class K, class V, class E, class H>
 inline Boolean HashTable<K, V, E, H>::lookup(const K& key, V& value)  inline Boolean HashTable<K, V, E, H>::lookup(const K& key, V& value) const
 { {
     _Bucket<K, V, E>* bucket     _Bucket<K, V, E>* bucket
         = (_Bucket<K, V, E>*)_rep.lookup(H::hash(key), &key);         = (_Bucket<K, V, E>*)_rep.lookup(H::hash(key), &key);

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