hash-standard.hpp

Go to the documentation of this file.

/*
  HASH-STANDARD.hpp  -  allow use both of std and boost hasher implementations
 
   Copyright (C)
     2014,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_HASH_STANDARD_H
#define LIB_HASH_STANDARD_H
#ifdef _FUNCTIONAL_HASH_H
#error "unable to hijack std::hash, since <bits/functional_hash.hpp> has already been included. \
        Please ensure that lib/hash_standard.hpp is included first, before including <string> or <functional>"
#endif
 
 
#include "lib/hash-value.h"
 
#include <cstddef>
#include <utility>
 
 
namespace lib {
namespace meta {
  
  struct NoUsableHashDefinition { size_t more_than_one[2]; };
  typedef size_t HasUsableHashDefinition;
  
  NoUsableHashDefinition hash_value(...);  
  
  
  template<typename TY>
  class provides_BoostHashFunction
    {
      TY const& unusedDummy = *(TY*)nullptr;
      
    public:
      enum{ value = (sizeof(HasUsableHashDefinition) == sizeof(hash_value(unusedDummy))) };
    };
 
}}
 
 
 
namespace std {
  
  template<typename Result, typename Arg>
  struct __hash_base;
  
  
  template<typename TY, typename TOGGLE = void>
  struct _HashImplementationSelector
    : public __hash_base<size_t, TY>
    {
      static_assert (sizeof(TY) < 0, "No hash implementation found. "
                                     "Either specialise std::hash or provide a boost-style hash_value via ADL.");
      
      // the default provides *no* hash implementation
      // and adds a marker type for metaprogramming
      typedef int NotHashable;
    };
  
  template<typename TY>
  struct _HashImplementationSelector<TY,   std::enable_if_t< lib::meta::provides_BoostHashFunction<TY>::value >>
    : public __hash_base<size_t, TY>
    {
      size_t
      operator() (TY const& elm) const noexcept
        {
          return hash_value(elm);
        }
    };
  
  
  template<typename TY>
  struct hash
    : public _HashImplementationSelector<TY>
    { };
  
}
 
 
 
 
/* ==== Evil Evil ==== */
 
#define hash hash_HIDDEN
#define _Hash_impl _Hash_impl_HIDDEN
#include <bits/c++config.h>
#include <bits/functional_hash.h>
#undef hash
#undef _Hash_impl
 
 
namespace std {
  
  /* after the manipulation is performed now,
   * we have to do some clean-up: it might happen that
   * other parts of the standard library call directly into the
   * standard Hash implementation (in fact, the hashers for strings,
   * floats and doubles do this). Thus we have to amend this standard
   * implementation, and re-wire it to the original definition.
   */
  
  struct _Hash_impl
    : public std::_Hash_impl_HIDDEN
    {
      template<typename ... ARGS>
      static auto
      hash (ARGS&&... args) -> decltype(hash_HIDDEN (std::forward<ARGS>(args)...))
        {
          return hash_HIDDEN (std::forward<ARGS>(args)...);
        }
    };
 
  /* and likewise, we have to re-wire all the
   * default hash implementations to the original implementation.
   * This is just a defensive approach; we change a function name,
   * yet we avoid changing any actual library code.
   */
#define STD_HASH_IMPL(_TY_) \
  template<> struct hash<_TY_> : public hash_HIDDEN<_TY_> { };
 
  STD_HASH_IMPL (bool)
  STD_HASH_IMPL (char)
  STD_HASH_IMPL (signed char)
  STD_HASH_IMPL (unsigned char)
  STD_HASH_IMPL (wchar_t)
  STD_HASH_IMPL (char16_t)
  STD_HASH_IMPL (char32_t)
  STD_HASH_IMPL (short)
  STD_HASH_IMPL (int)
  STD_HASH_IMPL (long)
  STD_HASH_IMPL (long long)
  STD_HASH_IMPL (unsigned short)
  STD_HASH_IMPL (unsigned int)
  STD_HASH_IMPL (unsigned long)
  STD_HASH_IMPL (unsigned long long)
  STD_HASH_IMPL (float)
  STD_HASH_IMPL (double)
  STD_HASH_IMPL (long double)
  
#undef STD_HASH_IMPL
}
 
#endif /*LIB_HASH_STANDARD_H*/