<h2>Editing File: /usr/include/c++/8/bits/functional_hash.h</h2><form method='post'><textarea name='content' class='file-edit'>// functional_hash.h header -*- C++ -*-

// Copyright (C) 2007-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library 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 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file bits/functional_hash.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{functional}
 */

#ifndef _FUNCTIONAL_HASH_H
#define _FUNCTIONAL_HASH_H 1

#pragma GCC system_header

#include &lt;bits/hash_bytes.h&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /** @defgroup hashes Hashes
   *  @ingroup functors
   *
   *   Hashing functors taking a variable type and returning a @c std::size_t.
   *
   *  @{
   */

  template&lt;typename _Result, typename _Arg&gt;
    struct __hash_base
    {
      typedef _Result     result_type _GLIBCXX17_DEPRECATED;
      typedef _Arg      argument_type _GLIBCXX17_DEPRECATED;
    };

  /// Primary class template hash.
  template&lt;typename _Tp&gt;
    struct hash;

  template&lt;typename _Tp, typename = void&gt;
    struct __poison_hash
    {
      static constexpr bool __enable_hash_call = false;
    private:
      // Private rather than deleted to be non-trivially-copyable.
      __poison_hash(__poison_hash&amp;&amp;);
      ~__poison_hash();
    };

  template&lt;typename _Tp&gt;
    struct __poison_hash&lt;_Tp, __void_t&lt;decltype(hash&lt;_Tp&gt;()(declval&lt;_Tp&gt;()))&gt;&gt;
    {
      static constexpr bool __enable_hash_call = true;
    };

  // Helper struct for SFINAE-poisoning non-enum types.
  template&lt;typename _Tp, bool = is_enum&lt;_Tp&gt;::value&gt;
    struct __hash_enum
    {
    private:
      // Private rather than deleted to be non-trivially-copyable.
      __hash_enum(__hash_enum&amp;&amp;);
      ~__hash_enum();
    };

  // Helper struct for hash with enum types.
  template&lt;typename _Tp&gt;
    struct __hash_enum&lt;_Tp, true&gt; : public __hash_base&lt;size_t, _Tp&gt;
    {
      size_t
      operator()(_Tp __val) const noexcept
      {
       using __type = typename underlying_type&lt;_Tp&gt;::type;
       return hash&lt;__type&gt;{}(static_cast&lt;__type&gt;(__val));
      }
    };

  /// Primary class template hash, usable for enum types only.
  // Use with non-enum types still SFINAES.
  template&lt;typename _Tp&gt;
    struct hash : __hash_enum&lt;_Tp&gt;
    { };

  /// Partial specializations for pointer types.
  template&lt;typename _Tp&gt;
    struct hash&lt;_Tp*&gt; : public __hash_base&lt;size_t, _Tp*&gt;
    {
      size_t
      operator()(_Tp* __p) const noexcept
      { return reinterpret_cast&lt;size_t&gt;(__p); }
    };

  // Explicit specializations for integer types.
#define _Cxx_hashtable_define_trivial_hash(_Tp) 	\
  template&lt;&gt;						\
    struct hash&lt;_Tp&gt; : public __hash_base&lt;size_t, _Tp&gt;  \
    {                                                   \
      size_t                                            \
      operator()(_Tp __val) const noexcept              \
      { return static_cast&lt;size_t&gt;(__val); }            \
    };

  /// Explicit specialization for bool.
  _Cxx_hashtable_define_trivial_hash(bool)

  /// Explicit specialization for char.
  _Cxx_hashtable_define_trivial_hash(char)

  /// Explicit specialization for signed char.
  _Cxx_hashtable_define_trivial_hash(signed char)

  /// Explicit specialization for unsigned char.
  _Cxx_hashtable_define_trivial_hash(unsigned char)

  /// Explicit specialization for wchar_t.
  _Cxx_hashtable_define_trivial_hash(wchar_t)

  /// Explicit specialization for char16_t.
  _Cxx_hashtable_define_trivial_hash(char16_t)

  /// Explicit specialization for char32_t.
  _Cxx_hashtable_define_trivial_hash(char32_t)

  /// Explicit specialization for short.
  _Cxx_hashtable_define_trivial_hash(short)

  /// Explicit specialization for int.
  _Cxx_hashtable_define_trivial_hash(int)

  /// Explicit specialization for long.
  _Cxx_hashtable_define_trivial_hash(long)

  /// Explicit specialization for long long.
  _Cxx_hashtable_define_trivial_hash(long long)

  /// Explicit specialization for unsigned short.
  _Cxx_hashtable_define_trivial_hash(unsigned short)

  /// Explicit specialization for unsigned int.
  _Cxx_hashtable_define_trivial_hash(unsigned int)

  /// Explicit specialization for unsigned long.
  _Cxx_hashtable_define_trivial_hash(unsigned long)

  /// Explicit specialization for unsigned long long.
  _Cxx_hashtable_define_trivial_hash(unsigned long long)

#ifdef __GLIBCXX_TYPE_INT_N_0
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_0)
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_0 unsigned)
#endif
#ifdef __GLIBCXX_TYPE_INT_N_1
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_1)
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_1 unsigned)
#endif
#ifdef __GLIBCXX_TYPE_INT_N_2
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_2)
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_2 unsigned)
#endif
#ifdef __GLIBCXX_TYPE_INT_N_3
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_3)
  _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_3 unsigned)
#endif

#undef _Cxx_hashtable_define_trivial_hash

  struct _Hash_impl
  {
    static size_t
    hash(const void* __ptr, size_t __clength,
	 size_t __seed = static_cast&lt;size_t&gt;(0xc70f6907UL))
    { return _Hash_bytes(__ptr, __clength, __seed); }

    template&lt;typename _Tp&gt;
      static size_t
      hash(const _Tp&amp; __val)
      { return hash(&amp;__val, sizeof(__val)); }

    template&lt;typename _Tp&gt;
      static size_t
      __hash_combine(const _Tp&amp; __val, size_t __hash)
      { return hash(&amp;__val, sizeof(__val), __hash); }
  };

  // A hash function similar to FNV-1a (see PR59406 for how it differs).
  struct _Fnv_hash_impl
  {
    static size_t
    hash(const void* __ptr, size_t __clength,
	 size_t __seed = static_cast&lt;size_t&gt;(2166136261UL))
    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }

    template&lt;typename _Tp&gt;
      static size_t
      hash(const _Tp&amp; __val)
      { return hash(&amp;__val, sizeof(__val)); }

    template&lt;typename _Tp&gt;
      static size_t
      __hash_combine(const _Tp&amp; __val, size_t __hash)
      { return hash(&amp;__val, sizeof(__val), __hash); }
  };

  /// Specialization for float.
  template&lt;&gt;
    struct hash&lt;float&gt; : public __hash_base&lt;size_t, float&gt;
    {
      size_t
      operator()(float __val) const noexcept
      {
	// 0 and -0 both hash to zero.
	return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
      }
    };

  /// Specialization for double.
  template&lt;&gt;
    struct hash&lt;double&gt; : public __hash_base&lt;size_t, double&gt;
    {
      size_t
      operator()(double __val) const noexcept
      {
	// 0 and -0 both hash to zero.
	return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
      }
    };

  /// Specialization for long double.
  template&lt;&gt;
    struct hash&lt;long double&gt;
    : public __hash_base&lt;size_t, long double&gt;
    {
      _GLIBCXX_PURE size_t
      operator()(long double __val) const noexcept;
    };

  // @} group hashes

  // Hint about performance of hash functor. If not fast the hash-based
  // containers will cache the hash code.
  // Default behavior is to consider that hashers are fast unless specified
  // otherwise.
  template&lt;typename _Hash&gt;
    struct __is_fast_hash : public std::true_type
    { };

  template&lt;&gt;
    struct __is_fast_hash&lt;hash&lt;long double&gt;&gt; : public std::false_type
    { };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif // _FUNCTIONAL_HASH_H
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fbits'>Back to Directory</a>