gcc/hash-map-traits.h

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