| |
| // Copyright 2006-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) |
| |
| // This header contains metafunctions/functions to get the equivalent |
| // associative container for an unordered container, and compare the contents. |
| |
| #if !defined(BOOST_UNORDERED_TEST_HELPERS_TRACKER_HEADER) |
| #define BOOST_UNORDERED_TEST_HELPERS_TRACKER_HEADER |
| |
| #include <set> |
| #include <map> |
| #include <iterator> |
| #include <algorithm> |
| #include <boost/mpl/if.hpp> |
| #include <boost/mpl/eval_if.hpp> |
| #include <boost/mpl/identity.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include "../objects/fwd.hpp" |
| #include "./metafunctions.hpp" |
| #include "./helpers.hpp" |
| #include "./equivalent.hpp" |
| #include "./list.hpp" |
| |
| namespace test |
| { |
| template <class X> |
| struct equals_to_compare2 |
| : public boost::mpl::identity< |
| std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> > |
| { |
| }; |
| |
| template <class X> |
| struct equals_to_compare |
| : public boost::mpl::eval_if< |
| boost::is_same<X, test::equal_to>, |
| boost::mpl::identity<test::less>, |
| equals_to_compare2<X> |
| > |
| { |
| }; |
| |
| template <class X1, class X2> |
| void compare_range(X1 const& x1, X2 const& x2) |
| { |
| typedef test::list<BOOST_DEDUCED_TYPENAME X1::value_type> value_list; |
| value_list values1(x1.begin(), x1.end()); |
| value_list values2(x2.begin(), x2.end()); |
| values1.sort(); |
| values2.sort(); |
| BOOST_TEST(values1.size() == values2.size() && |
| test::equal(values1.begin(), values1.end(), values2.begin(), |
| test::equivalent)); |
| } |
| |
| template <class X1, class X2, class T> |
| void compare_pairs(X1 const& x1, X2 const& x2, T*) |
| { |
| test::list<T> values1(x1.first, x1.second); |
| test::list<T> values2(x2.first, x2.second); |
| values1.sort(); |
| values2.sort(); |
| BOOST_TEST(values1.size() == values2.size() && |
| test::equal(values1.begin(), values1.end(), |
| values2.begin(), test::equivalent)); |
| } |
| |
| template <class X> |
| struct ordered_set : public |
| boost::mpl::if_< |
| test::has_unique_keys<X>, |
| std::set< |
| BOOST_DEDUCED_TYPENAME X::value_type, |
| BOOST_DEDUCED_TYPENAME equals_to_compare< |
| BOOST_DEDUCED_TYPENAME X::key_equal |
| >::type |
| >, |
| std::multiset< |
| BOOST_DEDUCED_TYPENAME X::value_type, |
| BOOST_DEDUCED_TYPENAME equals_to_compare< |
| BOOST_DEDUCED_TYPENAME X::key_equal |
| >::type |
| > |
| > {}; |
| |
| template <class X> |
| struct ordered_map : public |
| boost::mpl::if_< |
| test::has_unique_keys<X>, |
| std::map< |
| BOOST_DEDUCED_TYPENAME X::key_type, |
| BOOST_DEDUCED_TYPENAME X::mapped_type, |
| BOOST_DEDUCED_TYPENAME equals_to_compare< |
| BOOST_DEDUCED_TYPENAME X::key_equal |
| >::type |
| >, |
| std::multimap< |
| BOOST_DEDUCED_TYPENAME X::key_type, |
| BOOST_DEDUCED_TYPENAME X::mapped_type, |
| BOOST_DEDUCED_TYPENAME equals_to_compare< |
| BOOST_DEDUCED_TYPENAME X::key_equal |
| >::type |
| > |
| > {}; |
| |
| template <class X> |
| struct ordered_base : public |
| boost::mpl::eval_if< |
| test::is_set<X>, |
| test::ordered_set<X>, |
| test::ordered_map<X> |
| > {}; |
| |
| template <class X> |
| class ordered : public ordered_base<X>::type |
| { |
| typedef BOOST_DEDUCED_TYPENAME ordered_base<X>::type base; |
| public: |
| typedef BOOST_DEDUCED_TYPENAME base::key_compare key_compare; |
| |
| ordered() |
| : base() |
| {} |
| |
| explicit ordered(key_compare const& compare) |
| : base(compare) |
| {} |
| |
| void compare(X const& x) |
| { |
| compare_range(x, *this); |
| } |
| |
| void compare_key(X const& x, |
| BOOST_DEDUCED_TYPENAME X::value_type const& val) |
| { |
| compare_pairs( |
| x.equal_range(get_key<X>(val)), |
| this->equal_range(get_key<X>(val)), |
| (BOOST_DEDUCED_TYPENAME X::value_type*) 0); |
| } |
| |
| template <class It> |
| void insert_range(It begin, It end) { |
| while(begin != end) { |
| this->insert(*begin); |
| ++begin; |
| } |
| } |
| }; |
| |
| template <class Equals> |
| BOOST_DEDUCED_TYPENAME |
| equals_to_compare<Equals>::type create_compare(Equals const&) |
| { |
| BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type x; |
| return x; |
| } |
| |
| template <class X> |
| ordered<X> create_ordered(X const& container) |
| { |
| return ordered<X>(create_compare(container.key_eq())); |
| } |
| |
| template <class X1, class X2> |
| void check_container(X1 const& container, X2 const& values) |
| { |
| ordered<X1> tracker = create_ordered(container); |
| tracker.insert_range(values.begin(), values.end()); |
| tracker.compare(container); |
| } |
| } |
| |
| #endif |
| |