init commit

hc

2023-02-13 e440ec23c5a540cdd3f7464e8779219be6fd3d95

1
2
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
// -*- C++ -*-
//===------------------------- hash_set ------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
 
#ifndef _LIBCPP_EXT_HASH
#define _LIBCPP_EXT_HASH
 
#pragma GCC system_header
 
#include <string>
#include <cstring>
 
namespace __gnu_cxx {
using namespace std;
 
template <typename _Tp> struct _LIBCPP_TEMPLATE_VIS hash { };
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<const char*>
    : public unary_function<const char*, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(const char *__c) const _NOEXCEPT
    {
        return __do_string_hash(__c, __c + strlen(__c));
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<char *>
    : public unary_function<char*, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(char *__c) const _NOEXCEPT
    {
        return __do_string_hash<const char *>(__c, __c + strlen(__c));
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<char>
    : public unary_function<char, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(char __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<signed char>
    : public unary_function<signed char, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(signed char __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
    : public unary_function<unsigned char, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(unsigned char __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<short>
    : public unary_function<short, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(short __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
    : public unary_function<unsigned short, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(unsigned short __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<int>
    : public unary_function<int, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(int __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
    : public unary_function<unsigned int, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(unsigned int __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<long>
    : public unary_function<long, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(long __c) const _NOEXCEPT
    {
        return __c;
    }
};
 
template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
    : public unary_function<unsigned long, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(unsigned long __c) const _NOEXCEPT
    {
        return __c;
    }
};
}
 
#endif  // _LIBCPP_EXT_HASH