pegasus/src/Pegasus/Common/HashTable.h - diff

Return to HashTable.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/HashTable.h between version 1.6 and 1.19

version 1.6, 2001/05/20 20:34:00

version 1.19, 2005/02/05 22:59:23

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%2005////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software 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)

// Modified By:

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

Line 30

Line 39

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/String.h>

#include <Pegasus/Common/Linkage.h>

PEGASUS_NAMESPACE_BEGIN

Line 51

Line 61

static Uint32 hash(Uint32 x) { return x + 13; }

};

Hash function object that converts to lowercase.

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 converts to lower case based on the process locale.

struct HashLowerCaseFunc

{

static Uint32 hash (const String & str)

{

String cpy (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

the default implementation. Others may be defined and passed in the

template argument list to perform other kinds of comparisons.

Line 64

Line 96

}

};

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

bucket to append a key and value. This base class just defines

the pointer to the next bucket in the chain.

Line 114

Line 164

_BucketBase** _first;

_BucketBase** _last;

_BucketBase* _bucket;

friend _HashTableRep;

friend class _HashTableRep;

};

// ATTN: reorganization not supported yet.

Line 178

Line 228

@param key void pointer to key.

@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

_BucketBase::equal() method to compare keys.

Line 358

Line 408

}

</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

the default third argument of the template argument list. A new function

Line 462

Line 513

@param key key to be searched for

@return true if hash table contains an entry with the given key.

Boolean contains(const K& key)

Boolean contains(const K& key) const

{

V value;

return lookup(key, value);

Line 473

Line 524

@param value output value.

@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.

@param key key of entry to be removed.

Line 497

Line 548

};

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>*)_rep.lookup(H::hash(key), &key);

Legend:

Removed from v.1.6
changed lines
	Added in v.1.19

No CVS admin address has been configured