Merge pull request #67 from cmazakas/set-heterogeneous-equal-range

Set Heterogeneous `equal_range()`

include/boost/unordered/unordered_set.hpp

@@ -503,6 +503,19 @@ namespace boost {
       std::pair<const_iterator, const_iterator> equal_range(
         const key_type&) const;
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        std::pair<const_iterator, const_iterator> >::type
+      equal_range(Key const& k) const
+      {
+        node_pointer n = table_.find_node_impl(
+          table::policy::apply_hash(this->hash_function(), k), k,
+          this->key_eq());
+
+        return std::make_pair(
+          const_iterator(n), const_iterator(n ? table::next_node(n) : n));
+      }
+
       // bucket interface
 
       size_type bucket_count() const BOOST_NOEXCEPT

test/unordered/transparent_tests.cpp

@@ -365,7 +365,7 @@ template <class UnorderedSet> void test_set_non_transparent_find()
   }
 }
 
-template <class UnorderedMap> void test_transparent_equal_range()
+template <class UnorderedMap> void test_map_transparent_equal_range()
 {
   count_reset();
 
@@ -493,7 +493,7 @@ template <class UnorderedMap> void test_transparent_equal_range()
   }
 }
 
-template <class UnorderedMap> void test_non_transparent_equal_range()
+template <class UnorderedMap> void test_map_non_transparent_equal_range()
 {
   count_reset();
 
@@ -622,6 +622,263 @@ template <class UnorderedMap> void test_non_transparent_equal_range()
   }
 }
 
+template <class UnorderedSet> void test_set_transparent_equal_range()
+{
+  count_reset();
+
+  UnorderedSet unordered_set;
+
+  // empty tests
+  //
+  // explicitly test `equal_range()` vs `equal_range() const`
+  //
+  {
+    typedef typename UnorderedSet::iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet& set = unordered_set;
+    BOOST_TEST(set.empty());
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+  }
+
+  {
+    typedef typename UnorderedSet::const_iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet const& set = unordered_set;
+    BOOST_TEST(set.empty());
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+  }
+
+  BOOST_TEST_EQ(key::count_, 0);
+
+  unordered_set.insert(0);
+  unordered_set.insert(1);
+  unordered_set.insert(2);
+  unordered_set.insert(0);
+  unordered_set.insert(0);
+  unordered_set.insert(0);
+
+  int const expected_key_count = key::count_;
+
+  // do this so that multiset tests actually test a range with len > 1
+  //
+  int const expected_range_len = static_cast<int>(unordered_set.size() - 2);
+
+  typedef typename UnorderedSet::value_type value_type;
+
+  // explicitly test `equal_range()` vs `equal_range() const`
+  //
+  {
+    typedef typename UnorderedSet::iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet& set = unordered_set;
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin != end);
+    BOOST_TEST(begin != set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), expected_range_len);
+
+    for (iterator pos = begin; pos != end; ++pos) {
+      value_type const& val = *pos;
+      BOOST_TEST_EQ(val, 0);
+    }
+
+    iters = set.equal_range(1337);
+
+    begin = iters.first;
+    end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+
+    BOOST_TEST_EQ(key::count_, expected_key_count);
+  }
+
+  {
+    typedef typename UnorderedSet::const_iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet const& set = unordered_set;
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin != end);
+    BOOST_TEST(begin != set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), expected_range_len);
+
+    for (iterator pos = begin; pos != end; ++pos) {
+      value_type const& val = *begin;
+      BOOST_TEST_EQ(val, 0);
+    }
+
+    iters = set.equal_range(1337);
+
+    begin = iters.first;
+    end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+
+    BOOST_TEST_EQ(key::count_, expected_key_count);
+  }
+}
+
+template <class UnorderedSet> void test_set_non_transparent_equal_range()
+{
+  count_reset();
+
+  UnorderedSet unordered_set;
+
+  // empty tests
+  //
+  // explicitly test `equal_range()` vs `equal_range() const`
+  //
+  {
+    typedef typename UnorderedSet::iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet& set = unordered_set;
+    BOOST_TEST(set.empty());
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+  }
+
+  {
+    typedef typename UnorderedSet::const_iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet const& set = unordered_set;
+    BOOST_TEST(set.empty());
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+  }
+
+  BOOST_TEST_EQ(key::count_, 2);
+
+  unordered_set.insert(0);
+  unordered_set.insert(1);
+  unordered_set.insert(2);
+  unordered_set.insert(0);
+  unordered_set.insert(0);
+  unordered_set.insert(0);
+
+  int key_count = key::count_;
+
+  // do this so that multiset tests actually test a range with len > 1
+  //
+  int const expected_range_len = static_cast<int>(unordered_set.size() - 2);
+
+  typedef typename UnorderedSet::value_type value_type;
+
+  // explicitly test `equal_range()` vs `equal_range() const`
+  //
+  {
+    typedef typename UnorderedSet::iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet& set = unordered_set;
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin != end);
+    BOOST_TEST(begin != set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), expected_range_len);
+
+    for (iterator pos = begin; pos != end; ++pos) {
+      value_type const& val = *begin;
+      BOOST_TEST_EQ(val, 0);
+    }
+
+    iters = set.equal_range(1337);
+
+    begin = iters.first;
+    end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+
+    BOOST_TEST_EQ(key::count_, 2 + key_count);
+    key_count += 2;
+  }
+
+  {
+    typedef typename UnorderedSet::const_iterator iterator;
+    typedef std::pair<iterator, iterator> iterator_pair;
+
+    UnorderedSet const& set = unordered_set;
+
+    iterator_pair iters = set.equal_range(0);
+
+    iterator begin = iters.first;
+    iterator end = iters.second;
+
+    BOOST_TEST(begin != end);
+    BOOST_TEST(begin != set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), expected_range_len);
+
+    for (iterator pos = begin; pos != end; ++pos) {
+      value_type const& val = *pos;
+      BOOST_TEST_EQ(val, 0);
+    }
+
+    iters = set.equal_range(1337);
+
+    begin = iters.first;
+    end = iters.second;
+
+    BOOST_TEST(begin == end);
+    BOOST_TEST(begin == set.end());
+    BOOST_TEST_EQ(std::distance(begin, end), 0);
+
+    BOOST_TEST_EQ(key::count_, 2 + key_count);
+  }
+}
+
 template <class UnorderedMap> struct convertible_to_iterator
 {
   operator typename UnorderedMap::iterator()
@@ -986,7 +1243,7 @@ void test_unordered_map()
 
     test_transparent_count<unordered_map>();
     test_map_transparent_find<unordered_map>();
-    test_transparent_equal_range<unordered_map>();
+    test_map_transparent_equal_range<unordered_map>();
     test_map_transparent_erase<unordered_map>();
     test_transparent_extract<unordered_map>();
   }
@@ -998,7 +1255,7 @@ void test_unordered_map()
 
     test_non_transparent_count<unordered_map>();
     test_map_non_transparent_find<unordered_map>();
-    test_non_transparent_equal_range<unordered_map>();
+    test_map_non_transparent_equal_range<unordered_map>();
     test_map_non_transparent_erase<unordered_map>();
     test_non_transparent_extract<unordered_map>();
   }
@@ -1011,7 +1268,7 @@ void test_unordered_map()
 
     test_non_transparent_count<unordered_map>();
     test_map_non_transparent_find<unordered_map>();
-    test_non_transparent_equal_range<unordered_map>();
+    test_map_non_transparent_equal_range<unordered_map>();
     test_map_non_transparent_erase<unordered_map>();
     test_non_transparent_extract<unordered_map>();
   }
@@ -1024,7 +1281,7 @@ void test_unordered_map()
 
     test_non_transparent_count<unordered_map>();
     test_map_non_transparent_find<unordered_map>();
-    test_non_transparent_equal_range<unordered_map>();
+    test_map_non_transparent_equal_range<unordered_map>();
     test_map_non_transparent_erase<unordered_map>();
     test_non_transparent_extract<unordered_map>();
   }
@@ -1039,7 +1296,7 @@ void test_unordered_multimap()
 
     test_transparent_count<unordered_multimap>();
     test_map_transparent_find<unordered_multimap>();
-    test_transparent_equal_range<unordered_multimap>();
+    test_map_transparent_equal_range<unordered_multimap>();
     test_map_transparent_erase<unordered_multimap>();
     test_transparent_extract<unordered_multimap>();
   }
@@ -1052,7 +1309,7 @@ void test_unordered_multimap()
 
     test_non_transparent_count<unordered_multimap>();
     test_map_non_transparent_find<unordered_multimap>();
-    test_non_transparent_equal_range<unordered_multimap>();
+    test_map_non_transparent_equal_range<unordered_multimap>();
     test_map_non_transparent_erase<unordered_multimap>();
     test_non_transparent_extract<unordered_multimap>();
   }
@@ -1065,7 +1322,7 @@ void test_unordered_multimap()
 
     test_non_transparent_count<unordered_multimap>();
     test_map_non_transparent_find<unordered_multimap>();
-    test_non_transparent_equal_range<unordered_multimap>();
+    test_map_non_transparent_equal_range<unordered_multimap>();
     test_map_non_transparent_erase<unordered_multimap>();
     test_non_transparent_extract<unordered_multimap>();
   }
@@ -1078,7 +1335,7 @@ void test_unordered_multimap()
 
     test_non_transparent_count<unordered_multimap>();
     test_map_non_transparent_find<unordered_multimap>();
-    test_non_transparent_equal_range<unordered_multimap>();
+    test_map_non_transparent_equal_range<unordered_multimap>();
     test_map_non_transparent_erase<unordered_multimap>();
     test_non_transparent_extract<unordered_multimap>();
   }
@@ -1092,6 +1349,7 @@ void test_unordered_set()
 
     test_set_transparent_find<unordered_set>();
     test_set_transparent_erase<unordered_set>();
+    test_set_transparent_equal_range<unordered_set>();
   }
 
   {
@@ -1101,6 +1359,7 @@ void test_unordered_set()
 
     test_set_non_transparent_find<unordered_set>();
     test_set_non_transparent_erase<unordered_set>();
+    test_set_non_transparent_equal_range<unordered_set>();
   }
 
   {
@@ -1111,6 +1370,7 @@ void test_unordered_set()
 
     test_set_non_transparent_find<unordered_set>();
     test_set_non_transparent_erase<unordered_set>();
+    test_set_non_transparent_equal_range<unordered_set>();
   }
 
   {
@@ -1121,6 +1381,7 @@ void test_unordered_set()
 
     test_set_non_transparent_find<unordered_set>();
     test_set_non_transparent_erase<unordered_set>();
+    test_set_non_transparent_equal_range<unordered_set>();
   }
 }