Subject: [Boost-commit] svn:boost r74180 - in trunk: boost/unordered/detail libs/unordered/test/unordered
From: dnljms_at_[hidden]
Date: 2011-08-31 18:23:02
Author: danieljames
Date: 2011-08-31 18:23:01 EDT (Wed, 31 Aug 2011)
New Revision: 74180
URL: http://svn.boost.org/trac/boost/changeset/74180
Log:
Unordered: Add option to use old equality implementation for backwards compatability.
Added:
trunk/libs/unordered/test/unordered/equality_deprecated.cpp (contents, props changed)
Text files modified:
trunk/boost/unordered/detail/equivalent.hpp | 29 +++++++++++++++++++++++++++--
trunk/boost/unordered/detail/unique.hpp | 7 +++++++
trunk/libs/unordered/test/unordered/Jamfile.v2 | 1 +
3 files changed, 35 insertions(+), 2 deletions(-)
Modified: trunk/boost/unordered/detail/equivalent.hpp
==============================================================================
--- trunk/boost/unordered/detail/equivalent.hpp (original)
+++ trunk/boost/unordered/detail/equivalent.hpp 2011-08-31 18:23:01 EDT (Wed, 31 Aug 2011)
@@ -67,7 +67,9 @@
return true;
}
-
+
+#if !defined(BOOST_UNORDERED_DEPRECATED_EQUALITY)
+
static bool group_equals(node_ptr n1, node_ptr end1,
node_ptr n2, node_ptr end2)
{
@@ -108,7 +110,30 @@
return true;
}
-
+
+#else
+
+ static bool group_equals(node_ptr n1, node_ptr end1,
+ node_ptr n2, node_ptr end2)
+ {
+ for(;;)
+ {
+ if(!extractor::compare_mapped(
+ node::get_value(n1), node::get_value(n2)))
+ return false;
+
+ n1 = n1->next_;
+ n2 = n2->next_;
+
+ if (n1 == end1) return n2 == end2;
+ if (n2 == end2) return false;
+ }
+
+ return true;
+ }
+
+#endif
+
static bool find(node_ptr n, node_ptr end, value_type const& v)
{
for(;n != end; n = n->next_)
Modified: trunk/boost/unordered/detail/unique.hpp
==============================================================================
--- trunk/boost/unordered/detail/unique.hpp (original)
+++ trunk/boost/unordered/detail/unique.hpp 2011-08-31 18:23:01 EDT (Wed, 31 Aug 2011)
@@ -60,8 +60,15 @@
n1; n1 = n1->next_)
{
node_ptr n2 = other.find_matching_node(n1);
+
+#if !defined(BOOST_UNORDERED_DEPRECATED_EQUALITY)
if(!n2 || node::get_value(n1) != node::get_value(n2))
return false;
+#else
+ if(!n2 || !extractor::compare_mapped(
+ node::get_value(n1), node::get_value(n2)))
+ return false;
+#endif
}
return true;
Modified: trunk/libs/unordered/test/unordered/Jamfile.v2
==============================================================================
--- trunk/libs/unordered/test/unordered/Jamfile.v2 (original)
+++ trunk/libs/unordered/test/unordered/Jamfile.v2 2011-08-31 18:23:01 EDT (Wed, 31 Aug 2011)
@@ -45,5 +45,6 @@
[ run load_factor_tests.cpp ]
[ run rehash_tests.cpp ]
[ run equality_tests.cpp ]
+ [ run equality_deprecated.cpp ]
[ run swap_tests.cpp ]
;
Added: trunk/libs/unordered/test/unordered/equality_deprecated.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/unordered/test/unordered/equality_deprecated.cpp 2011-08-31 18:23:01 EDT (Wed, 31 Aug 2011)
@@ -0,0 +1,173 @@
+
+// Copyright 2008-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_UNORDERED_DEPRECATED_EQUALITY
+
+#include "../helpers/prefix.hpp"
+
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/preprocessor/seq.hpp>
+#include <list>
+#include "../helpers/test.hpp"
+
+namespace equality_tests
+{
+ struct mod_compare
+ {
+ bool alt_hash_;
+
+ explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
+
+ bool operator()(int x, int y) const
+ {
+ return x % 1000 == y % 1000;
+ }
+
+ int operator()(int x) const
+ {
+ return alt_hash_ ? x % 250 : (x + 5) % 250;
+ }
+ };
+
+#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2) \
+ { \
+ boost::unordered_set<int, mod_compare, mod_compare> set1, set2; \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
+ BOOST_TEST(set1 op set2); \
+ }
+
+#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2) \
+ { \
+ boost::unordered_multiset<int, mod_compare, mod_compare> \
+ set1, set2; \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
+ BOOST_TEST(set1 op set2); \
+ }
+
+#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2) \
+ { \
+ boost::unordered_map<int, int, mod_compare, mod_compare> \
+ map1, map2; \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
+ BOOST_TEST(map1 op map2); \
+ }
+
+#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2) \
+ { \
+ boost::unordered_multimap<int, int, mod_compare, mod_compare> \
+ map1, map2; \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
+ BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
+ BOOST_TEST(map1 op map2); \
+ }
+
+#define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
+#define UNORDERED_MAP_INSERT(r, map, item) \
+ map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
+
+ UNORDERED_AUTO_TEST(equality_size_tests)
+ {
+ boost::unordered_set<int> x1, x2;
+ BOOST_TEST(x1 == x2);
+ BOOST_TEST(!(x1 != x2));
+
+ x1.insert(1);
+ BOOST_TEST(x1 != x2);
+ BOOST_TEST(!(x1 == x2));
+ BOOST_TEST(x2 != x1);
+ BOOST_TEST(!(x2 == x1));
+
+ x2.insert(1);
+ BOOST_TEST(x1 == x2);
+ BOOST_TEST(!(x1 != x2));
+
+ x2.insert(2);
+ BOOST_TEST(x1 != x2);
+ BOOST_TEST(!(x1 == x2));
+ BOOST_TEST(x2 != x1);
+ BOOST_TEST(!(x2 == x1));
+ }
+
+ UNORDERED_AUTO_TEST(equality_key_value_tests)
+ {
+ UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
+ UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
+ UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
+ }
+
+ UNORDERED_AUTO_TEST(equality_collision_test)
+ {
+ UNORDERED_EQUALITY_MULTISET_TEST(
+ (1), !=, (501))
+ UNORDERED_EQUALITY_MULTISET_TEST(
+ (1)(251), !=, (1)(501))
+ UNORDERED_EQUALITY_MULTIMAP_TEST(
+ ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
+ UNORDERED_EQUALITY_MULTISET_TEST(
+ (1)(501), ==, (1)(501))
+ UNORDERED_EQUALITY_SET_TEST(
+ (1)(501), ==, (501)(1))
+ }
+
+ UNORDERED_AUTO_TEST(equality_group_size_test)
+ {
+ UNORDERED_EQUALITY_MULTISET_TEST(
+ (10)(20)(20), !=, (10)(10)(20))
+ UNORDERED_EQUALITY_MULTIMAP_TEST(
+ ((10)(1))((20)(1))((20)(1)), !=,
+ ((10)(1))((20)(1))((10)(1)))
+ UNORDERED_EQUALITY_MULTIMAP_TEST(
+ ((20)(1))((10)(1))((10)(1)), ==,
+ ((10)(1))((20)(1))((10)(1)))
+ }
+
+ UNORDERED_AUTO_TEST(equality_map_value_test)
+ {
+ UNORDERED_EQUALITY_MAP_TEST(
+ ((1)(1)), !=, ((1)(2)))
+ UNORDERED_EQUALITY_MAP_TEST(
+ ((1)(1)), ==, ((1)(1)))
+ UNORDERED_EQUALITY_MULTIMAP_TEST(
+ ((1)(1)), !=, ((1)(2)))
+ UNORDERED_EQUALITY_MULTIMAP_TEST(
+ ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
+ UNORDERED_EQUALITY_MULTIMAP_TEST(
+ ((1)(2))((1)(1)), !=, ((1)(1))((1)(2)))
+ }
+
+ UNORDERED_AUTO_TEST(equality_predicate_test)
+ {
+ UNORDERED_EQUALITY_SET_TEST(
+ (1), ==, (1001))
+ UNORDERED_EQUALITY_MAP_TEST(
+ ((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)))
+ }
+
+ // Test that equality still works when the two containers have
+ // different hash functions but the same equality predicate.
+
+ UNORDERED_AUTO_TEST(equality_different_hash_test)
+ {
+ typedef boost::unordered_set<int, mod_compare, mod_compare> set;
+ set set1(0, mod_compare(false), mod_compare(false));
+ set set2(0, mod_compare(true), mod_compare(true));
+ BOOST_TEST(set1 == set2);
+ set1.insert(1); set2.insert(2);
+ BOOST_TEST(set1 != set2);
+ set1.insert(2); set2.insert(1);
+ BOOST_TEST(set1 == set2);
+ set1.insert(10); set2.insert(20);
+ BOOST_TEST(set1 != set2);
+ set1.insert(20); set2.insert(10);
+ BOOST_TEST(set1 == set2);
+ }
+
+}
+
+RUN_TESTS()