|
111
|
1 /* A hash map traits.
|
|
131
|
2 Copyright (C) 2015-2018 Free Software Foundation, Inc.
|
|
111
|
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;
|
|
131
|
35 static const bool maybe_mx = true;
|
|
111
|
36 static inline hashval_t hash (const key_type &);
|
|
|
37 static inline bool equal_keys (const key_type &, const key_type &);
|
|
|
38 template <typename T> static inline void remove (T &);
|
|
|
39 template <typename T> static inline bool is_empty (const T &);
|
|
|
40 template <typename T> static inline bool is_deleted (const T &);
|
|
|
41 template <typename T> static inline void mark_empty (T &);
|
|
|
42 template <typename T> static inline void mark_deleted (T &);
|
|
|
43 };
|
|
|
44
|
|
|
45 template <typename H, typename Value>
|
|
|
46 inline hashval_t
|
|
|
47 simple_hashmap_traits <H, Value>::hash (const key_type &h)
|
|
|
48 {
|
|
|
49 return H::hash (h);
|
|
|
50 }
|
|
|
51
|
|
|
52 template <typename H, typename Value>
|
|
|
53 inline bool
|
|
|
54 simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
|
|
|
55 const key_type &k2)
|
|
|
56 {
|
|
|
57 return H::equal (k1, k2);
|
|
|
58 }
|
|
|
59
|
|
|
60 template <typename H, typename Value>
|
|
|
61 template <typename T>
|
|
|
62 inline void
|
|
|
63 simple_hashmap_traits <H, Value>::remove (T &entry)
|
|
|
64 {
|
|
|
65 H::remove (entry.m_key);
|
|
|
66 entry.m_value.~Value ();
|
|
|
67 }
|
|
|
68
|
|
|
69 template <typename H, typename Value>
|
|
|
70 template <typename T>
|
|
|
71 inline bool
|
|
|
72 simple_hashmap_traits <H, Value>::is_empty (const T &entry)
|
|
|
73 {
|
|
|
74 return H::is_empty (entry.m_key);
|
|
|
75 }
|
|
|
76
|
|
|
77 template <typename H, typename Value>
|
|
|
78 template <typename T>
|
|
|
79 inline bool
|
|
|
80 simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
|
|
|
81 {
|
|
|
82 return H::is_deleted (entry.m_key);
|
|
|
83 }
|
|
|
84
|
|
|
85 template <typename H, typename Value>
|
|
|
86 template <typename T>
|
|
|
87 inline void
|
|
|
88 simple_hashmap_traits <H, Value>::mark_empty (T &entry)
|
|
|
89 {
|
|
|
90 H::mark_empty (entry.m_key);
|
|
|
91 }
|
|
|
92
|
|
|
93 template <typename H, typename Value>
|
|
|
94 template <typename T>
|
|
|
95 inline void
|
|
|
96 simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
|
|
|
97 {
|
|
|
98 H::mark_deleted (entry.m_key);
|
|
|
99 }
|
|
|
100
|
|
131
|
101 template <typename H, typename Value>
|
|
|
102 struct simple_cache_map_traits: public simple_hashmap_traits<H,Value>
|
|
|
103 {
|
|
|
104 static const bool maybe_mx = false;
|
|
|
105 };
|
|
|
106
|
|
111
|
107 /* Implement traits for a hash_map with values of type Value for cases
|
|
|
108 in which the key cannot represent empty and deleted slots. Instead
|
|
|
109 record empty and deleted entries in Value. Derived classes must
|
|
|
110 implement the hash and equal_keys functions. */
|
|
|
111
|
|
|
112 template <typename Value>
|
|
|
113 struct unbounded_hashmap_traits
|
|
|
114 {
|
|
|
115 template <typename T> static inline void remove (T &);
|
|
|
116 template <typename T> static inline bool is_empty (const T &);
|
|
|
117 template <typename T> static inline bool is_deleted (const T &);
|
|
|
118 template <typename T> static inline void mark_empty (T &);
|
|
|
119 template <typename T> static inline void mark_deleted (T &);
|
|
|
120 };
|
|
|
121
|
|
|
122 template <typename Value>
|
|
|
123 template <typename T>
|
|
|
124 inline void
|
|
|
125 unbounded_hashmap_traits <Value>::remove (T &entry)
|
|
|
126 {
|
|
|
127 default_hash_traits <Value>::remove (entry.m_value);
|
|
|
128 }
|
|
|
129
|
|
|
130 template <typename Value>
|
|
|
131 template <typename T>
|
|
|
132 inline bool
|
|
|
133 unbounded_hashmap_traits <Value>::is_empty (const T &entry)
|
|
|
134 {
|
|
|
135 return default_hash_traits <Value>::is_empty (entry.m_value);
|
|
|
136 }
|
|
|
137
|
|
|
138 template <typename Value>
|
|
|
139 template <typename T>
|
|
|
140 inline bool
|
|
|
141 unbounded_hashmap_traits <Value>::is_deleted (const T &entry)
|
|
|
142 {
|
|
|
143 return default_hash_traits <Value>::is_deleted (entry.m_value);
|
|
|
144 }
|
|
|
145
|
|
|
146 template <typename Value>
|
|
|
147 template <typename T>
|
|
|
148 inline void
|
|
|
149 unbounded_hashmap_traits <Value>::mark_empty (T &entry)
|
|
|
150 {
|
|
|
151 default_hash_traits <Value>::mark_empty (entry.m_value);
|
|
|
152 }
|
|
|
153
|
|
|
154 template <typename Value>
|
|
|
155 template <typename T>
|
|
|
156 inline void
|
|
|
157 unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
|
|
|
158 {
|
|
|
159 default_hash_traits <Value>::mark_deleted (entry.m_value);
|
|
|
160 }
|
|
|
161
|
|
|
162 /* Implement traits for a hash_map from integer type Key to Value in
|
|
|
163 cases where Key has no spare values for recording empty and deleted
|
|
|
164 slots. */
|
|
|
165
|
|
|
166 template <typename Key, typename Value>
|
|
|
167 struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
|
|
|
168 {
|
|
|
169 typedef Key key_type;
|
|
|
170 static inline hashval_t hash (Key);
|
|
|
171 static inline bool equal_keys (Key, Key);
|
|
|
172 };
|
|
|
173
|
|
|
174 template <typename Key, typename Value>
|
|
|
175 inline hashval_t
|
|
|
176 unbounded_int_hashmap_traits <Key, Value>::hash (Key k)
|
|
|
177 {
|
|
|
178 return k;
|
|
|
179 }
|
|
|
180
|
|
|
181 template <typename Key, typename Value>
|
|
|
182 inline bool
|
|
|
183 unbounded_int_hashmap_traits <Key, Value>::equal_keys (Key k1, Key k2)
|
|
|
184 {
|
|
|
185 return k1 == k2;
|
|
|
186 }
|
|
|
187
|
|
|
188 #endif // HASH_MAP_TRAITS_H
|
