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.16 and 1.30

version 1.16, 2004/03/25 17:09:26

version 1.30, 2008/12/02 09:00:47

Line 1

//%2003////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// License.

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

// of this software and associated documentation files (the "Software"), to

// copy of this software and associated documentation files (the "Software"),

// deal in the Software without restriction, including without limitation the

// to deal in the Software without restriction, including without limitation

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// sell copies of the Software, and to permit persons to whom the Software is

// and/or sell copies of the Software, and to permit persons to whom the

// furnished to do so, subject to the following conditions:

// Software is furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// The above copyright notice and this permission notice shall be included

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// in all copies or substantial portions of the Software.

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

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

//==============================================================================

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 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: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

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

Line 35

Line 34

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/String.h>

#include <Pegasus/Common/CIMObjectPath.h>

#include <Pegasus/Common/Linkage.h>

PEGASUS_NAMESPACE_BEGIN

Line 57

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

};

PEGASUS_TEMPLATE_SPECIALIZATION struct HashFunc <CIMObjectPath>

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)

static Uint32 hash (const CIMObjectPath & path)

{

String cpy (str);

return path.makeHashCode ();

cpy.toLower ();

Uint32 h = 0;

for (Uint32 i = 0, n = cpy.size (); i < n; i++)

h = 5 * h + cpy [i];

return h;

}

};

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

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

template argument list to perform other kinds of comparisons.

Line 92

Line 87

}

};

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.

Line 138

Line 141

_BucketBase* next;

};

class _HashTableRep;

/* This class implements a simple hash table forward iterator. */

class PEGASUS_COMMON_LINKAGE _HashTableIteratorBase

{

public:

_HashTableIteratorBase() : _first(0), _last(0), _bucket(0) { }

_HashTableIteratorBase(_BucketBase** first, _BucketBase** last);

operator int() const { return _bucket != 0; }

_HashTableIteratorBase operator++(int);

void operator++();

_HashTableIteratorBase& operator++();

void operator++(int)

{

_HashTableIteratorBase(_BucketBase** first, _BucketBase** last);

operator++();

}

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** _last;

_BucketBase* _bucket;

friend class _HashTableRep;

};

// ATTN: reorganization not supported yet.

Line 294

Line 300

{

public:

_HashTableIterator()

: _HashTableIteratorBase() { }

_HashTableIterator(_BucketBase** first, _BucketBase** last)

: _HashTableIteratorBase(first, last) { }

Line 368

Line 371

(which by the way has exactly the same effect).

<pre>

typedef HashTable<String, Uint32, EqualFunc<String>, HashFunc<String>> HT;

typedef HashTable<String, Uint32,

EqualFunc<String>, HashFunc<String>> HT;

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

Line 404

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 521

Line 526

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.

@param key key of entry to be removed.

@return true on success; false otherwise.

Line 557

Line 571

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

#endif /* Pegasus_HashTable_h */

Legend:

Removed from v.1.16
changed lines
	Added in v.1.30

No CVS admin address has been configured