Merge pull request #184 from maierlars/feature/transparent-hash-map-set

Transparent Hash for Map and Sets

Author: arximboldi

immer/detail/rbts/rrbtree.hpp

@@ -19,6 +19,7 @@
 #include <stdexcept>
 #include <memory>
 #include <numeric>
+#include <limits>
 
 namespace immer {
 namespace detail {

immer/map.hpp

@@ -114,7 +114,8 @@ class map
     {
         auto operator()(const value_t& v) { return Hash{}(v.first); }
 
-        auto operator()(const K& v) { return Hash{}(v); }
+        template<typename Key>
+        auto operator()(const Key& v) { return Hash{}(v); }
     };
 
     struct equal_key
@@ -124,7 +125,8 @@ class map
             return Equal{}(a.first, b.first);
         }
 
-        auto operator()(const value_t& a, const K& b)
+        template<typename Key>
+        auto operator()(const value_t& a, const Key& b)
         {
             return Equal{}(a.first, b);
         }
@@ -192,6 +194,21 @@ class map
      */
     IMMER_NODISCARD bool empty() const { return impl_.size == 0; }
 
+    /*!
+     * Returns `1` when the key `k` is contained in the map or `0`
+     * otherwise. It won't allocate memory and its complexity is
+     * *effectively* @f$ O(1) @f$.
+     *
+     * This overload participates in overload resolution only if
+     * `Hash::is_transparent` is valid and denotes a type.
+     */
+    template<typename Key, typename U = Hash, typename = typename U::is_transparent>
+    IMMER_NODISCARD size_type count(const Key& k) const
+    {
+        return impl_.template get<detail::constantly<size_type, 1>,
+                                  detail::constantly<size_type, 0>>(k);
+    }
+
     /*!
      * Returns `1` when the key `k` is contained in the map or `0`
      * otherwise. It won't allocate memory and its complexity is
@@ -203,6 +220,21 @@ class map
                                   detail::constantly<size_type, 0>>(k);
     }
 
+    /*!
+     * Returns a `const` reference to the values associated to the key
+     * `k`.  If the key is not contained in the map, it returns a
+     * default constructed value.  It does not allocate memory and its
+     * complexity is *effectively* @f$ O(1) @f$.
+     *
+     * This overload participates in overload resolution only if
+     * `Hash::is_transparent` is valid and denotes a type.
+     */
+    template<typename Key, typename U = Hash, typename = typename U::is_transparent>
+    IMMER_NODISCARD const T& operator[](const Key& k) const
+    {
+        return impl_.template get<project_value, default_value>(k);
+    }
+
     /*!
      * Returns a `const` reference to the values associated to the key
      * `k`.  If the key is not contained in the map, it returns a
@@ -220,6 +252,21 @@ class map
      * `std::out_of_range` error.  It does not allocate memory and its
      * complexity is *effectively* @f$ O(1) @f$.
      */
+    template<typename Key, typename U = Hash, typename = typename U::is_transparent>
+    const T& at(const Key& k) const
+    {
+        return impl_.template get<project_value, error_value>(k);
+    }
+
+    /*!
+     * Returns a `const` reference to the values associated to the key
+     * `k`.  If the key is not contained in the map, throws an
+     * `std::out_of_range` error.  It does not allocate memory and its
+     * complexity is *effectively* @f$ O(1) @f$.
+     *
+     * This overload participates in overload resolution only if
+     * `Hash::is_transparent` is valid and denotes a type.
+     */
     const T& at(const K& k) const
     {
         return impl_.template get<project_value, error_value>(k);
@@ -260,6 +307,23 @@ class map
                                   detail::constantly<const T*, nullptr>>(k);
     }
 
+
+    /*!
+     * Returns a pointer to the value associated with the key `k`.  If
+     * the key is not contained in the map, a `nullptr` is returned.
+     * It does not allocate memory and its complexity is *effectively*
+     * @f$ O(1) @f$.
+     *
+     * This overload participates in overload resolution only if
+     * `Hash::is_transparent` is valid and denotes a type.
+     */
+    template<typename Key, typename U = Hash, typename = typename U::is_transparent>
+    IMMER_NODISCARD const T* find(const Key& k) const
+    {
+        return impl_.template get<project_value_ptr,
+                                  detail::constantly<const T*, nullptr>>(k);
+    }
+
     /*!
      * Returns whether the sets are equal.
      */

immer/set.hpp

@@ -117,6 +117,21 @@ class set
      */
     IMMER_NODISCARD bool empty() const { return impl_.size == 0; }
 
+    /*!
+     * Returns `1` when `value` is contained in the set or `0`
+     * otherwise. It won't allocate memory and its complexity is
+     * *effectively* @f$ O(1) @f$.
+     *
+     * This overload participates in overload resolution only if
+     * `Hash::is_transparent` is valid and denotes a type.
+     */
+    template<typename K, typename U = Hash, typename = typename U::is_transparent>
+    IMMER_NODISCARD size_type count(const K& value) const
+    {
+        return impl_.template get<detail::constantly<size_type, 1>,
+                                  detail::constantly<size_type, 0>>(value);
+    }
+
     /*!
      * Returns `1` when `value` is contained in the set or `0`
      * otherwise. It won't allocate memory and its complexity is
@@ -140,6 +155,22 @@ class set
                                   detail::constantly<const T*, nullptr>>(value);
     }
 
+    /*!
+     * Returns a pointer to the value if `value` is contained in the
+     * set, or nullptr otherwise.
+     * It does not allocate memory and its complexity is *effectively*
+     * @f$ O(1) @f$.
+     *
+     * This overload participates in overload resolution only if
+     * `Hash::is_transparent` is valid and denotes a type.
+     */
+    template<typename K, typename U = Hash, typename = typename U::is_transparent>
+    IMMER_NODISCARD const T* find(const K& value) const
+    {
+        return impl_.template get<project_value_ptr,
+                                  detail::constantly<const T*, nullptr>>(value);
+    }
+
     /*!
      * Returns whether the sets are equal.
      */

test/map/generic.ipp

@@ -275,6 +275,50 @@ TEST_CASE("exception safety")
     }
 }
 
+namespace {
+struct KeyType {
+    explicit KeyType(unsigned v) : value(v) {}
+    unsigned value;
+};
+
+struct LookupType {
+    explicit LookupType(unsigned v) : value(v) {}
+    unsigned value;
+};
+
+struct TransparentHash
+{
+    using hash_type = std::hash<unsigned>;
+    using is_transparent = void;
+
+    size_t operator()(KeyType const& k) const { return hash_type{}(k.value); }
+    size_t operator()(LookupType const& k) const
+    {
+        return hash_type{}(k.value);
+    }
+};
+
+bool operator==(KeyType const& k, KeyType const& l) {
+    return k.value == l.value;
+}
+bool operator==(KeyType const& k, LookupType const& l) {
+    return k.value == l.value;
+}
+}
+
+TEST_CASE("lookup with transparent hash")
+{
+    SECTION("default")
+    {
+        auto m = MAP_T<KeyType, int, TransparentHash, std::equal_to<>>{};
+        m = m.insert({KeyType{1}, 12});
+
+        auto const& v = m.at(LookupType{1});
+        CHECK(v == 12);
+    }
+}
+
+
 namespace {
 
 class KElem

test/set/generic.ipp

@@ -457,3 +457,47 @@ TEST_CASE("exception safety")
         IMMER_TRACE_E(d.happenings);
     }
 }
+
+
+namespace {
+struct KeyType {
+    explicit KeyType(unsigned v) : value(v) {}
+    unsigned value;
+};
+
+struct LookupType {
+    explicit LookupType(unsigned v) : value(v) {}
+    unsigned value;
+};
+
+struct TransparentHash
+{
+    using hash_type = std::hash<unsigned>;
+    using is_transparent = void;
+
+    size_t operator()(KeyType const& k) const { return hash_type{}(k.value); }
+    size_t operator()(LookupType const& k) const
+    {
+        return hash_type{}(k.value);
+    }
+};
+
+bool operator==(KeyType const& k, KeyType const& l) {
+    return k.value == l.value;
+}
+bool operator==(KeyType const& k, LookupType const& l) {
+    return k.value == l.value;
+}
+}
+
+TEST_CASE("lookup with transparent hash")
+{
+    SECTION("default")
+    {
+        auto m = SET_T<KeyType, TransparentHash, std::equal_to<>>{};
+        m = m.insert(KeyType{1});
+
+        CHECK(m.count(LookupType{1}) == 1);
+        CHECK(m.count(LookupType{2}) == 0);
+    }
+}