/* Bacause mem-stats.h uses default hashmap traits, we have to
put the class to this separate header file. */
-/* implement default behavior for traits when types allow it. */
+#include "hash-traits.h"
-struct default_hashmap_traits
-{
- /* Hashes the passed in key. */
+/* Implement hash_map traits for a key with hash traits H. Empty and
+ deleted map entries are represented as empty and deleted keys. */
- template<typename T>
- static hashval_t
- hash (T *p)
- {
- return uintptr_t (p) >> 3;
- }
+template <typename H>
+struct simple_hashmap_traits
+{
+ typedef typename H::value_type key_type;
+ static inline hashval_t hash (const key_type &);
+ static inline bool equal_keys (const key_type &, const key_type &);
+ template <typename T> static inline void remove (T &);
+ template <typename T> static inline bool is_empty (const T &);
+ template <typename T> static inline bool is_deleted (const T &);
+ template <typename T> static inline void mark_empty (T &);
+ template <typename T> static inline void mark_deleted (T &);
+};
- /* If the value converts to hashval_t just use it. */
+template <typename H>
+inline hashval_t
+simple_hashmap_traits <H>::hash (const key_type &h)
+{
+ return H::hash (h);
+}
- template<typename T> static hashval_t hash (T v) { return v; }
+template <typename H>
+inline bool
+simple_hashmap_traits <H>::equal_keys (const key_type &k1, const key_type &k2)
+{
+ return H::equal (k1, k2);
+}
- /* Return true if the two keys passed as arguments are equal. */
+template <typename H>
+template <typename T>
+inline void
+simple_hashmap_traits <H>::remove (T &entry)
+{
+ H::remove (entry.m_key);
+}
- template<typename T>
- static bool
- equal_keys (const T &a, const T &b)
- {
- return a == b;
- }
+template <typename H>
+template <typename T>
+inline bool
+simple_hashmap_traits <H>::is_empty (const T &entry)
+{
+ return H::is_empty (entry.m_key);
+}
- /* Called to dispose of the key and value before marking the entry as
- deleted. */
+template <typename H>
+template <typename T>
+inline bool
+simple_hashmap_traits <H>::is_deleted (const T &entry)
+{
+ return H::is_deleted (entry.m_key);
+}
- template<typename T> static void remove (T &v) { v.~T (); }
+template <typename H>
+template <typename T>
+inline void
+simple_hashmap_traits <H>::mark_empty (T &entry)
+{
+ H::mark_empty (entry.m_key);
+}
- /* Mark the passed in entry as being deleted. */
+template <typename H>
+template <typename T>
+inline void
+simple_hashmap_traits <H>::mark_deleted (T &entry)
+{
+ H::mark_deleted (entry.m_key);
+}
- template<typename T>
- static void
- mark_deleted (T &e)
- {
- mark_key_deleted (e.m_key);
- }
+/* Implement traits for a hash_map with values of type Value for cases
+ in which the key cannot represent empty and deleted slots. Instead
+ record empty and deleted entries in Value. Derived classes must
+ implement the hash and equal_keys functions. */
- /* Mark the passed in entry as being empty. */
+template <typename Value>
+struct unbounded_hashmap_traits
+{
+ template <typename T> static inline void remove (T &);
+ template <typename T> static inline bool is_empty (const T &);
+ template <typename T> static inline bool is_deleted (const T &);
+ template <typename T> static inline void mark_empty (T &);
+ template <typename T> static inline void mark_deleted (T &);
+};
- template<typename T>
- static void
- mark_empty (T &e)
- {
- mark_key_empty (e.m_key);
- }
+template <typename Value>
+template <typename T>
+inline void
+unbounded_hashmap_traits <Value>::remove (T &entry)
+{
+ default_hash_traits <Value>::remove (entry.m_value);
+}
- /* Return true if the passed in entry is marked as deleted. */
+template <typename Value>
+template <typename T>
+inline bool
+unbounded_hashmap_traits <Value>::is_empty (const T &entry)
+{
+ return default_hash_traits <Value>::is_empty (entry.m_value);
+}
- template<typename T>
- static bool
- is_deleted (T &e)
- {
- return e.m_key == (void *)1;
- }
+template <typename Value>
+template <typename T>
+inline bool
+unbounded_hashmap_traits <Value>::is_deleted (const T &entry)
+{
+ return default_hash_traits <Value>::is_deleted (entry.m_value);
+}
- /* Return true if the passed in entry is marked as empty. */
+template <typename Value>
+template <typename T>
+inline void
+unbounded_hashmap_traits <Value>::mark_empty (T &entry)
+{
+ default_hash_traits <Value>::mark_empty (entry.m_value);
+}
- template<typename T> static bool is_empty (T &e) { return e.m_key == NULL; }
+template <typename Value>
+template <typename T>
+inline void
+unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
+{
+ default_hash_traits <Value>::mark_deleted (entry.m_value);
+}
-private:
- template<typename T>
- static void
- mark_key_deleted (T *&k)
- {
- k = reinterpret_cast<T *> (1);
- }
+/* Implement traits for a hash_map from integer type Key to Value in
+ cases where Key has no spare values for recording empty and deleted
+ slots. */
- template<typename T>
- static void
- mark_key_empty (T *&k)
- {
- k = static_cast<T *> (0);
- }
+template <typename Key, typename Value>
+struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
+{
+ typedef Key key_type;
+ static inline hashval_t hash (Key);
+ static inline bool equal_keys (Key, Key);
};
+template <typename Key, typename Value>
+inline hashval_t
+unbounded_int_hashmap_traits <Key, Value>::hash (Key k)
+{
+ return k;
+}
+
+template <typename Key, typename Value>
+inline bool
+unbounded_int_hashmap_traits <Key, Value>::equal_keys (Key k1, Key k2)
+{
+ return k1 == k2;
+}
+
#endif // HASH_MAP_TRAITS_H