OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [tr1/] [functional_hash.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
// TR1 functional_hash.h header -*- C++ -*-
2
 
3
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4
//
5
// This file is part of the GNU ISO C++ Library.  This library is free
6
// software; you can redistribute it and/or modify it under the
7
// terms of the GNU General Public License as published by the
8
// Free Software Foundation; either version 3, or (at your option)
9
// any later version.
10
 
11
// This library is distributed in the hope that it will be useful,
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
// GNU General Public License for more details.
15
 
16
// Under Section 7 of GPL version 3, you are granted additional
17
// permissions described in the GCC Runtime Library Exception, version
18
// 3.1, as published by the Free Software Foundation.
19
 
20
// You should have received a copy of the GNU General Public License and
21
// a copy of the GCC Runtime Library Exception along with this program;
22
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23
// <http://www.gnu.org/licenses/>.
24
 
25
/** @file tr1/functional_hash.h
26
 *  This is an internal header file, included by other library headers.
27
 *  Do not attempt to use it directly. @headername{tr1/functional}
28
 */
29
 
30
#ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H
31
#define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1
32
 
33
#pragma GCC system_header
34
 
35
namespace std _GLIBCXX_VISIBILITY(default)
36
{
37
namespace tr1
38
{
39
_GLIBCXX_BEGIN_NAMESPACE_VERSION
40
 
41
  /// Class template hash.
42
  // Declaration of default hash functor std::tr1::hash.  The types for
43
  // which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
44
  template<typename _Tp>
45
    struct hash : public std::unary_function<_Tp, size_t>
46
    {
47
      size_t
48
      operator()(_Tp __val) const;
49
    };
50
 
51
  /// Partial specializations for pointer types.
52
  template<typename _Tp>
53
    struct hash<_Tp*> : public std::unary_function<_Tp*, size_t>
54
    {
55
      size_t
56
      operator()(_Tp* __p) const
57
      { return reinterpret_cast<size_t>(__p); }
58
    };
59
 
60
  /// Explicit specializations for integer types.
61
#define _TR1_hashtable_define_trivial_hash(_Tp)         \
62
  template<>                                            \
63
    inline size_t                                       \
64
    hash<_Tp>::operator()(_Tp __val) const              \
65
    { return static_cast<size_t>(__val); }
66
 
67
  _TR1_hashtable_define_trivial_hash(bool);
68
  _TR1_hashtable_define_trivial_hash(char);
69
  _TR1_hashtable_define_trivial_hash(signed char);
70
  _TR1_hashtable_define_trivial_hash(unsigned char);
71
  _TR1_hashtable_define_trivial_hash(wchar_t);
72
  _TR1_hashtable_define_trivial_hash(short);
73
  _TR1_hashtable_define_trivial_hash(int);
74
  _TR1_hashtable_define_trivial_hash(long);
75
  _TR1_hashtable_define_trivial_hash(long long);
76
  _TR1_hashtable_define_trivial_hash(unsigned short);
77
  _TR1_hashtable_define_trivial_hash(unsigned int);
78
  _TR1_hashtable_define_trivial_hash(unsigned long);
79
  _TR1_hashtable_define_trivial_hash(unsigned long long);
80
 
81
#undef _TR1_hashtable_define_trivial_hash
82
 
83
  // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
84
  // (Used by the next specializations of std::tr1::hash.)
85
 
86
  /// Dummy generic implementation (for sizeof(size_t) != 4, 8).
87
  template<size_t>
88
    struct _Fnv_hash_base
89
    {
90
      template<typename _Tp>
91
        static size_t
92
        hash(const _Tp* __ptr, size_t __clength)
93
        {
94
          size_t __result = 0;
95
          const char* __cptr = reinterpret_cast<const char*>(__ptr);
96
          for (; __clength; --__clength)
97
            __result = (__result * 131) + *__cptr++;
98
          return __result;
99
        }
100
    };
101
 
102
  template<>
103
    struct _Fnv_hash_base<4>
104
    {
105
      template<typename _Tp>
106
        static size_t
107
        hash(const _Tp* __ptr, size_t __clength)
108
        {
109
          size_t __result = static_cast<size_t>(2166136261UL);
110
          const char* __cptr = reinterpret_cast<const char*>(__ptr);
111
          for (; __clength; --__clength)
112
            {
113
              __result ^= static_cast<size_t>(*__cptr++);
114
              __result *= static_cast<size_t>(16777619UL);
115
            }
116
          return __result;
117
        }
118
    };
119
 
120
  template<>
121
    struct _Fnv_hash_base<8>
122
    {
123
      template<typename _Tp>
124
        static size_t
125
        hash(const _Tp* __ptr, size_t __clength)
126
        {
127
          size_t __result
128
            = static_cast<size_t>(14695981039346656037ULL);
129
          const char* __cptr = reinterpret_cast<const char*>(__ptr);
130
          for (; __clength; --__clength)
131
            {
132
              __result ^= static_cast<size_t>(*__cptr++);
133
              __result *= static_cast<size_t>(1099511628211ULL);
134
            }
135
          return __result;
136
        }
137
    };
138
 
139
  struct _Fnv_hash
140
  : public _Fnv_hash_base<sizeof(size_t)>
141
  {
142
    using _Fnv_hash_base<sizeof(size_t)>::hash;
143
 
144
    template<typename _Tp>
145
      static size_t
146
      hash(const _Tp& __val)
147
      { return hash(&__val, sizeof(__val)); }
148
  };
149
 
150
  /// Explicit specializations for float.
151
  template<>
152
    inline size_t
153
    hash<float>::operator()(float __val) const
154
    {
155
      // 0 and -0 both hash to zero.
156
      return __val != 0.0f ? std::tr1::_Fnv_hash::hash(__val) : 0;
157
    }
158
 
159
  /// Explicit specializations for double.
160
  template<>
161
    inline size_t
162
    hash<double>::operator()(double __val) const
163
    {
164
      // 0 and -0 both hash to zero.
165
      return __val != 0.0 ? std::tr1::_Fnv_hash::hash(__val) : 0;
166
    }
167
 
168
  /// Explicit specializations for long double.
169
  template<>
170
    _GLIBCXX_PURE size_t
171
    hash<long double>::operator()(long double __val) const;
172
 
173
  /// Explicit specialization of member operator for non-builtin types.
174
  template<>
175
    _GLIBCXX_PURE size_t
176
    hash<string>::operator()(string) const;
177
 
178
  template<>
179
    _GLIBCXX_PURE size_t
180
    hash<const string&>::operator()(const string&) const;
181
 
182
#ifdef _GLIBCXX_USE_WCHAR_T
183
  template<>
184
    _GLIBCXX_PURE size_t
185
    hash<wstring>::operator()(wstring) const;
186
 
187
  template<>
188
    _GLIBCXX_PURE size_t
189
    hash<const wstring&>::operator()(const wstring&) const;
190
#endif
191
 
192
_GLIBCXX_END_NAMESPACE_VERSION
193
}
194
}
195
 
196
#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.