|
111
|
1 /* A hash map traits.
|
|
|
2 Copyright (C) 2015-2017 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of GCC.
|
|
|
5
|
|
|
6 GCC is free software; you can redistribute it and/or modify it under
|
|
|
7 the terms of the GNU General Public License as published by the Free
|
|
|
8 Software Foundation; either version 3, or (at your option) any later
|
|
|
9 version.
|
|
|
10
|
|
|
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with GCC; see the file COPYING3. If not see
|
|
|
18 <http://www.gnu.org/licenses/>. */
|
|
|
19
|
|
|
20 #ifndef HASH_MAP_TRAITS_H
|
|
|
21 #define HASH_MAP_TRAITS_H
|
|
|
22
|
|
|
23 /* Bacause mem-stats.h uses default hashmap traits, we have to
|
|
|
24 put the class to this separate header file. */
|
|
|
25
|
|
|
26 #include "hash-traits.h"
|
|
|
27
|
|
|
28 /* Implement hash_map traits for a key with hash traits H. Empty and
|
|
|
29 deleted map entries are represented as empty and deleted keys. */
|
|
|
30
|
|
|
31 template <typename H, typename Value>
|
|
|
32 struct simple_hashmap_traits
|
|
|
33 {
|
|
|
34 typedef typename H::value_type key_type;
|
|
|
35 static inline hashval_t hash (const key_type &);
|
|
|
36 static inline bool equal_keys (const key_type &, const key_type &);
|
|
|
37 template <typename T> static inline void remove (T &);
|
|
|
38 template <typename T> static inline bool is_empty (const T &);
|
|
|
39 template <typename T> static inline bool is_deleted (const T &);
|
|
|
40 template <typename T> static inline void mark_empty (T &);
|
|
|
41 template <typename T> static inline void mark_deleted (T &);
|
|
|
42 };
|
|
|
43
|
|
|
44 template <typename H, typename Value>
|
|
|
45 inline hashval_t
|
|
|
46 simple_hashmap_traits <H, Value>::hash (const key_type &h)
|
|
|
47 {
|
|
|
48 return H::hash (h);
|
|
|
49 }
|
|
|
50
|
|
|
51 template <typename H, typename Value>
|
|
|
52 inline bool
|
|
|
53 simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
|
|
|
54 const key_type &k2)
|
|
|
55 {
|
|
|
56 return H::equal (k1, k2);
|
|
|
57 }
|
|
|
58
|
|
|
59 template <typename H, typename Value>
|
|
|
60 template <typename T>
|
|
|
61 inline void
|
|
|
62 simple_hashmap_traits <H, Value>::remove (T &entry)
|
|
|
63 {
|
|
|
64 H::remove (entry.m_key);
|
|
|
65 entry.m_value.~Value ();
|
|
|
66 }
|
|
|
67
|
|
|
68 template <typename H, typename Value>
|
|
|
69 template <typename T>
|
|
|
70 inline bool
|
|
|
71 simple_hashmap_traits <H, Value>::is_empty (const T &entry)
|
|
|
72 {
|
|
|
73 return H::is_empty (entry.m_key);
|
|
|
74 }
|
|
|
75
|
|
|
76 template <typename H, typename Value>
|
|
|
77 template <typename T>
|
|
|
78 inline bool
|
|
|
79 simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
|
|
|
80 {
|
|
|
81 return H::is_deleted (entry.m_key);
|
|
|
82 }
|
|
|
83
|
|
|
84 template <typename H, typename Value>
|
|
|
85 template <typename T>
|
|
|
86 inline void
|
|
|
87 simple_hashmap_traits <H, Value>::mark_empty (T &entry)
|
|
|
88 {
|
|
|
89 H::mark_empty (entry.m_key);
|
|
|
90 }
|
|
|
91
|
|
|
92 template <typename H, typename Value>
|
|
|
93 template <typename T>
|
|
|
94 inline void
|
|
|
95 simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
|
|
|
96 {
|
|
|
97 H::mark_deleted (entry.m_key);
|
|
|
98 }
|
|
|
99
|
|
|
100 /* Implement traits for a hash_map with values of type Value for cases
|
|
|
101 in which the key cannot represent empty and deleted slots. Instead
|
|
|
102 record empty and deleted entries in Value. Derived classes must
|
|
|
103 implement the hash and equal_keys functions. */
|
|
|
104
|
|
|
105 template <typename Value>
|
|
|
106 struct unbounded_hashmap_traits
|
|
|
107 {
|
|
|
108 template <typename T> static inline void remove (T &);
|
|
|
109 template <typename T> static inline bool is_empty (const T &);
|
|
|
110 template <typename T> static inline bool is_deleted (const T &);
|
|
|
111 template <typename T> static inline void mark_empty (T &);
|
|
|
112 template <typename T> static inline void mark_deleted (T &);
|
|
|
113 };
|
|
|
114
|
|
|
115 template <typename Value>
|
|
|
116 template <typename T>
|
|
|
117 inline void
|
|
|
118 unbounded_hashmap_traits <Value>::remove (T &entry)
|
|
|
119 {
|
|
|
120 default_hash_traits <Value>::remove (entry.m_value);
|
|
|
121 }
|
|
|
122
|
|
|
123 template <typename Value>
|
|
|
124 template <typename T>
|
|
|
125 inline bool
|
|
|
126 unbounded_hashmap_traits <Value>::is_empty (const T &entry)
|
|
|
127 {
|
|
|
128 return default_hash_traits <Value>::is_empty (entry.m_value);
|
|
|
129 }
|
|
|
130
|
|
|
131 template <typename Value>
|
|
|
132 template <typename T>
|
|
|
133 inline bool
|
|
|
134 unbounded_hashmap_traits <Value>::is_deleted (const T &entry)
|
|
|
135 {
|
|
|
136 return default_hash_traits <Value>::is_deleted (entry.m_value);
|
|
|
137 }
|
|
|
138
|
|
|
139 template <typename Value>
|
|
|
140 template <typename T>
|
|
|
141 inline void
|
|
|
142 unbounded_hashmap_traits <Value>::mark_empty (T &entry)
|
|
|
143 {
|
|
|
144 default_hash_traits <Value>::mark_empty (entry.m_value);
|
|
|
145 }
|
|
|
146
|
|
|
147 template <typename Value>
|
|
|
148 template <typename T>
|
|
|
149 inline void
|
|
|
150 unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
|
|
|
151 {
|
|
|
152 default_hash_traits <Value>::mark_deleted (entry.m_value);
|
|
|
153 }
|
|
|
154
|
|
|
155 /* Implement traits for a hash_map from integer type Key to Value in
|
|
|
156 cases where Key has no spare values for recording empty and deleted
|
|
|
157 slots. */
|
|
|
158
|
|
|
159 template <typename Key, typename Value>
|
|
|
160 struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
|
|
|
161 {
|
|
|
162 typedef Key key_type;
|
|
|
163 static inline hashval_t hash (Key);
|
|
|
164 static inline bool equal_keys (Key, Key);
|
|
|
165 };
|
|
|
166
|
|
|
167 template <typename Key, typename Value>
|
|
|
168 inline hashval_t
|
|
|
169 unbounded_int_hashmap_traits <Key, Value>::hash (Key k)
|
|
|
170 {
|
|
|
171 return k;
|
|
|
172 }
|
|
|
173
|
|
|
174 template <typename Key, typename Value>
|
|
|
175 inline bool
|
|
|
176 unbounded_int_hashmap_traits <Key, Value>::equal_keys (Key k1, Key k2)
|
|
|
177 {
|
|
|
178 return k1 == k2;
|
|
|
179 }
|
|
|
180
|
|
|
181 #endif // HASH_MAP_TRAITS_H
|
