hash_fun.hxx.in 3.57 KB
Newer Older
1 2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
/*
 * Copyright (c) 1996
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */
#ifndef @KWSYS_NAMESPACE@_hash_fun_hxx
#define @KWSYS_NAMESPACE@_hash_fun_hxx

#include <@KWSYS_NAMESPACE@/Configure.hxx>
32 33

#include <stddef.h> // size_t
Brad King's avatar
Brad King committed
34
#include <string>
35

36
namespace @KWSYS_NAMESPACE@ {
37

38 39 40 41
template <class _Key>
struct hash
{
};
42 43 44 45

inline size_t _stl_hash_string(const char* __s)
{
  unsigned long __h = 0;
46 47
  for (; *__s; ++__s)
    __h = 5 * __h + *__s;
48 49 50 51

  return size_t(__h);
}

52
template <>
53 54
struct hash<char*>
{
55 56 57
  size_t operator()(const char* __s) const { return _stl_hash_string(__s); }
};

58
template <>
59 60
struct hash<const char*>
{
61 62 63
  size_t operator()(const char* __s) const { return _stl_hash_string(__s); }
};

64
template <>
65 66 67 68 69 70
struct hash<std::string>
{
  size_t operator()(const std::string& __s) const
  {
    return _stl_hash_string(__s.c_str());
  }
71 72
};

73
#if !defined(__BORLANDC__)
74
template <>
75 76 77 78 79 80
struct hash<const std::string>
{
  size_t operator()(const std::string& __s) const
  {
    return _stl_hash_string(__s.c_str());
  }
81
};
82
#endif
83

84
template <>
85 86
struct hash<char>
{
87 88 89
  size_t operator()(char __x) const { return __x; }
};

90
template <>
91 92
struct hash<unsigned char>
{
93 94 95
  size_t operator()(unsigned char __x) const { return __x; }
};

96
template <>
97 98
struct hash<signed char>
{
99 100 101
  size_t operator()(unsigned char __x) const { return __x; }
};

102
template <>
103 104
struct hash<short>
{
105 106 107
  size_t operator()(short __x) const { return __x; }
};

108
template <>
109 110
struct hash<unsigned short>
{
111 112 113
  size_t operator()(unsigned short __x) const { return __x; }
};

114
template <>
115 116
struct hash<int>
{
117 118 119
  size_t operator()(int __x) const { return __x; }
};

120
template <>
121 122
struct hash<unsigned int>
{
123 124 125
  size_t operator()(unsigned int __x) const { return __x; }
};

126
template <>
127 128
struct hash<long>
{
129 130 131
  size_t operator()(long __x) const { return __x; }
};

132
template <>
133 134
struct hash<unsigned long>
{
135 136 137
  size_t operator()(unsigned long __x) const { return __x; }
};

138
// use long long or __int64
139
#if @KWSYS_USE_LONG_LONG@
140
template <>
141 142
struct hash<long long>
{
143 144 145
  size_t operator()(long long __x) const { return __x; }
};

146
template <>
147 148
struct hash<unsigned long long>
{
149 150
  size_t operator()(unsigned long long __x) const { return __x; }
};
151
#elif @KWSYS_USE___INT64@
152
template <>
153 154
struct hash<__int64>
{
155 156
  size_t operator()(__int64 __x) const { return __x; }
};
157
template <>
158 159
struct hash<unsigned __int64>
{
160 161
  size_t operator()(unsigned __int64 __x) const { return __x; }
};
162
#endif // use long long or __int64
163

164 165 166
} // namespace @KWSYS_NAMESPACE@

#endif