hash.h

Go to the documentation of this file.

#ifndef hash_HEADER
#define hash_HEADER

/***************************************************************************
 * Benoit Hudson (C) 2007.
 ***************************************************************************/

#include <boost/static_assert.hpp>

#include "hash_set.h"
#include "hash_map.h"
#include "hash_by_call.h"
#include "hash_by_cast.h"
#include "details/hash.h"

namespace hudson {

  /**** Hashing a single word or word-sized item at a time. */
  inline size_t hashWord(size_t a) {
    return details::hash_single<sizeof(size_t)> :: hash(a);
  }

  template <class Int> struct HashWord {
    size_t operator() (const Int& i) const { return hashWord(i); }
  };

  template <class T>
  size_t hashPointer(const T *p) {
    return details::hash_single<sizeof(size_t)> :: hash((size_t)p);
  }

  template <class T> struct HashPointer {
    size_t operator() (const T* p) const { return hashPointer(p); }
  };

  /**** Hashing multiple values at once. */

  inline size_t hashWords(size_t a, size_t b) {
    // choose the best implementation
    return details::hash_pair<sizeof(size_t)>::hash(a, b);
  }

  inline size_t hashWords(size_t a, size_t b, size_t c) {
    // probably can't do better than jenkin's 3-at-a-time
    return details::mixer<sizeof(size_t)>::final(a, b, c);
  }

  inline size_t hashWords(size_t a, size_t b, size_t c, size_t d) {
    // only mix, don't need final, for the first three; then, we
    // hashPair them to get all our properties.
    typedef details::mixer<sizeof(size_t)> M;
    M::word aa = a, bb = b, cc = c;
    M::mix(aa, bb, cc);
    return hashWords(cc, d);
  }

  template <class iterator, class hasher>
  size_t hashItems(const iterator& begin, const iterator& end, const hasher& h) {
    BOOST_STATIC_ASSERT(sizeof(h(*begin)) == sizeof(size_t));
    return details::hash_range<sizeof(size_t)>::hash(begin, end, h);
  }

}

namespace hashers {
  template <> struct hash<std::string> {
    unsigned long operator() (const std::string& s) const {
      // TODO: use jenkin's hash
      return hash<const char*>()(s.c_str());
    }
  };
}

#endif

---