Hash.h

Go to the documentation of this file.

// $Id: Hash.h,v 1.6 2007/05/23 18:05:15 marcocle Exp $
// ============================================================================
#ifndef GAUDIKERNEL_HASH_H
#define GAUDIKERNEL_HASH_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <functional>
// ============================================================================
// Boost
// ============================================================================
#include "boost/functional/hash.hpp"
// ============================================================================
namespace GaudiUtils
{
  //  To enable the generic hash for a user defined class, it is enough to add
  //  few lines to the .cpp files that needs them
  //  @code
  //  #include "GaudiKernel/Hash.h"
  //  class MyType;
  //  namespace GaudiUtils {
  //    template <>
  //    struct Hash<MyType>: public GenericHash<MyType> {};
  //  }
  //  @endcode
  template <class T>
  struct GenericHash : public std::unary_function<T,std::size_t>
  {
    // ========================================================================
    inline std::size_t operator() ( const T& key ) const {
      std::size_t res = 0 ;
      std::size_t len = sizeof(T) ;
      const char* p = reinterpret_cast<const char*>( &key );
      while( len-- ) { res = ( res << 1 ) ^ *p; ++p; }
      return res;
    }
    // ========================================================================
  };

  // ==========================================================================
  template <class T>
  struct Hash : public std::unary_function<T,std::size_t>
  {
    // ========================================================================
    inline std::size_t operator() ( const T& key ) const;
    // ========================================================================
  };
  // ==========================================================================
  template <class T>
  struct Hash<T*> : public std::unary_function<const T*,std::size_t>
  {
    // ========================================================================
    inline std::size_t operator() ( const T* key ) const;
    // ========================================================================
  };
  // ==========================================================================
  template <class T, unsigned N>
  struct Hash<T(&)[N]> : public std::unary_function<T(&)[N],std::size_t>
  {
    // ========================================================================
    inline std::size_t operator() ( T (&key) [N] ) const
    { return boost::hash_range ( key , key + N ) ; }
    // ========================================================================
  } ;
  template <class T, unsigned N>
  struct Hash<const T(&)[N]> : public std::unary_function<const T(&)[N],std::size_t>
  {
    // ========================================================================
    inline std::size_t operator() ( const T (&key) [N] ) const
    { return boost::hash_range ( key , key + N ) ; }
    // ========================================================================
  } ;
  // ==========================================================================
  template<class T>
  struct Hash<const T>  : public Hash<T>  {} ;
  template<class T>
  struct Hash<const T*> : public Hash<T*> {} ;
  template<class T>
  struct Hash<T&>       : public Hash<T>  {} ;
  template<class T>
  struct Hash<const T&> : public Hash<T>  {} ;
  // ==========================================================================
  template <class T>
  inline std::size_t Hash<T>::operator() ( const T& key ) const
  {
    using namespace boost ;
    return hash_value ( key ) ;
  }
  template <class T>
  inline std::size_t Hash<T*>::operator() ( const T* key ) const
  {
    using namespace boost ;
    return hash_value ( key ) ;
  }
  template <>
  inline std::size_t Hash<char*>::operator() ( const char* key ) const
  {
    std::size_t seed = 0 ;
    while ( key ) { boost::hash_combine ( seed , *key ) ; ++key ; }
    return seed ;
  }

  // ==========================================================================
} // end of namespace GaudiUtils
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_HASH_H
// ============================================================================