Hash.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef GAUDIKERNEL_HASH_H
#define GAUDIKERNEL_HASH_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <cstddef>
#include <numeric>
// ============================================================================
// 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 {
    // ========================================================================
    inline std::size_t operator()( const T& key ) const {
      const char* p = reinterpret_cast<const char*>( &key );
      return std::accumulate( p, p + sizeof( T ), std::size_t{ 0 },
                              []( std::size_t res, const char& c ) { return ( res << 1 ) ^ c; } );
    }
    // ========================================================================
  };
 
  // ==========================================================================
  template <class T>
  struct Hash {
    // ========================================================================
    inline std::size_t operator()( const T& key ) const;
    // ========================================================================
  };
  // ==========================================================================
  template <class T>
  struct Hash<T*> {
    // ========================================================================
    inline std::size_t operator()( const T* key ) const;
    // ========================================================================
  };
  // ==========================================================================
  template <class T, unsigned N>
  struct Hash<T ( & )[N]> {
    // ========================================================================
    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]> {
    // ========================================================================
    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