GaudiUtils::Hash< T > Class Template Reference

Simple hash function. More...

#include <GaudiKernel/Hash.h>

Inheritance diagram for GaudiUtils::Hash< T >:

[legend]

Collaboration diagram for GaudiUtils::Hash< T >:

[legend]

List of all members.

Public Member Functions
std::size_t	operator() (const T &key) const
	the hash-function
template<>
size_t	operator() (const GaudiAlg::ID &key) const
template<>
std::size_t	operator() (const char *key) const

---

Detailed Description

template<class T>
class GaudiUtils::Hash< T >

Simple hash function.

The default implementation is based on boost::hash

Attention:

There is no generic a'la Stroustrup implementation valid for "any" objects.

See also:

GaudiUtils::GenericHash

Attention:

The hashing of pointers does not rely on hash for objects

The usage *requires* to provide the specialization The default specialization are provided by boost::bash_value for

• all primitive fundamental types
• strings and wide strings
• std::complex
• std::pair
• std::vector, std::list, std::deque
• std::set, std::multiset, std::map, std::multimap
• C-arrays, including C-strings
• generic pointer types

To provide own specialization for type TYPE or TYPE* there are four ways:

• provide the specialization of Gaudi::Utils::Hash<TYPE>::operator() ( const TYPE& val ) const or Gaudi::Utils::Hash<TYPE*>::operator() ( const TYPE* val ) const
• provide the full specialization of Gaudi::Utils::Hash<TYPE>
• provide the function std::size_t hash_value ( const TYPE& val ) ;

The first and the last ways are recommended. The second way can be needed if e.g. TYPE has non trivial properties, e.g. one need to use non-const or non-ref forms of hashing value For the last way the function must reside in the same namespace, where TYPE is defines, therefore if TYPE is in a global namespace it is better to avoid this way. The most natural place for this function is a "friend function" of the class. In this way it can have access to some useful internals of the class. However this is a bit intrusive way. The third way is not recommended, since sooner or later we'll need to migrate from boost::hash to std::tr1::hash.

Comparing the previous Gaudi implementation of GaudiUtils::Hash and boost::bash specializations, one can expect:

• some (tiny?) CPU penalty for floating point types
• some (tiny?) CPU penalty for long-long integer types
• better CPU performance for generic pointer types
• guaranteed coherence of hash for std::string & C-string

Probably the first two items are compensated by better "hashing"-performance

Author:

Marco Clemencic

Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:

2005-10-07

Definition at line 98 of file Hash.h.

---

Member Function Documentation

template<class T>

std::size_t GaudiUtils::Hash< T >::operator()

(

const T &

key

)

const [inline]

the hash-function

the generic implementations of hash-function

Definition at line 152 of file Hash.h.

  {
    using namespace boost ;
    return hash_value ( key ) ;
  }

template<>

size_t GaudiUtils::Hash< GaudiAlg::ID >::operator()

(

const GaudiAlg::ID &

key

)

const [inline]

Definition at line 147 of file GaudiHistoID.h.

{ return key.hash () ; }   

template<>

std::size_t GaudiUtils::Hash< char * >::operator()

(

const char *

key

)

const [inline]

Definition at line 166 of file Hash.h.

  {
    std::size_t seed = 0 ;
    while ( key ) { boost::hash_combine ( seed , *key ) ; ++key ; }
    return seed ;
  }

---

The documentation for this class was generated from the following file:

• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r9/GaudiKernel/GaudiKernel/Hash.h