diff --git a/test/avl_multiset_test.cpp b/test/avl_multiset_test.cpp index c02f961..1238950 100644 --- a/test/avl_multiset_test.cpp +++ b/test/avl_multiset_test.cpp @@ -21,13 +21,13 @@ namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_insert_before()(); test_main_template()(); - // test (bounded pointers) x ((nonconst/const size) x (special node allocator) + // test (bounded pointers) x (nonconst/const size) x (special node allocator) test_main_template_bptr< true >()(); test_main_template_bptr< false >()(); diff --git a/test/avl_set_test.cpp b/test/avl_set_test.cpp index 18d5b9d..26f66d9 100644 --- a/test/avl_set_test.cpp +++ b/test/avl_set_test.cpp @@ -20,13 +20,13 @@ namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_insert_before()(); test_main_template()(); - // test (bounded pointers) x ((nonconst/const size) x (special node allocator) + // test (bounded pointers) x (nonconst/const size) x (special node allocator) test_main_template_bptr< true >()(); test_main_template_bptr< false >()(); diff --git a/test/bounded_pointer.hpp b/test/bounded_pointer.hpp index 75828cc..7dcf8d8 100644 --- a/test/bounded_pointer.hpp +++ b/test/bounded_pointer.hpp @@ -222,44 +222,92 @@ std::vector< bool > Bounded_Allocator< T >::_in_use; template < typename T > class Bounded_Reference_Cont - : public std::vector< Bounded_Reference< T > > + : private std::vector< Bounded_Reference< T > > { private: - typedef T value_type; + typedef T val_type; typedef std::vector< Bounded_Reference< T > > Base; typedef Bounded_Allocator< T > allocator_type; typedef Bounded_Pointer< T > pointer; public: + typedef typename Base::value_type value_type; + typedef typename Base::iterator iterator; + typedef typename Base::const_iterator const_iterator; + typedef typename Base::reference reference; + typedef typename Base::const_reference const_reference; + typedef typename Base::reverse_iterator reverse_iterator; + typedef typename Base::const_reverse_iterator const_reverse_iterator; + + iterator begin() { return Base::begin(); } + iterator end() { return Base::end(); } + const_iterator begin() const { return Base::begin(); } + const_iterator end() const { return Base::end(); } + reverse_iterator rbegin() { return Base::rbegin(); } + reverse_iterator rend() { return Base::rend(); } + const_reverse_iterator rbegin() const { return Base::rbegin(); } + const_reverse_iterator rend() const { return Base::rend(); } + reference front() { return Base::front(); } + const_reference front() const { return Base::front(); } + reference back() { return Base::back(); } + const_reference back() const { return Base::back(); } + size_t size() const { return Base::size(); } + reference operator [] (size_t i) { return Base::operator [] (i); } + const_reference operator [] (size_t i) const { return Base::operator [] (i); } + void push_back(const value_type& v) { Base::push_back(v); } + Bounded_Reference_Cont(size_t n = 0) : Base(), _allocator() { for (size_t i = 0; i < n; ++i) { pointer p = _allocator.allocate(1); - new (p.raw()) value_type(); + new (p.raw()) val_type(); Base::push_back(*p); } } Bounded_Reference_Cont(const Bounded_Reference_Cont& other) : Base(), _allocator(other._allocator) { //std::clog << "copying values container\n"; - for (typename Base::const_iterator it = other.begin(); it != other.end(); ++it) + *this = other; + } + template < typename InputIterator > + Bounded_Reference_Cont(InputIterator it_start, InputIterator it_end) : Base(), _allocator() + { + for (InputIterator it = it_start; it != it_end; ++it) { pointer p = _allocator.allocate(1); - new (p.raw()) value_type(*it); + new (p.raw()) val_type(*it); Base::push_back(*p); } } ~Bounded_Reference_Cont() + { + clear(); + } + void clear() { while (not Base::empty()) { pointer p = &Base::back(); - p->~value_type(); + p->~val_type(); _allocator.deallocate(p, 1); Base::pop_back(); } } + Bounded_Reference_Cont& operator = (const Bounded_Reference_Cont& other) + { + if (&other != this) + { + clear(); + for (typename Base::const_iterator it = other.begin(); it != other.end(); ++it) + { + pointer p = _allocator.allocate(1); + new (p.raw()) val_type(*it); + Base::push_back(*p); + } + } + return *this; + } private: allocator_type _allocator; diff --git a/test/bptr_value.hpp b/test/bptr_value.hpp index e930cf2..daec91f 100644 --- a/test/bptr_value.hpp +++ b/test/bptr_value.hpp @@ -167,6 +167,21 @@ struct AVLTree_BPtr_Node_Traits static balance positive() { return 1; } }; +struct Tree_BPtr_Node_Traits +{ + typedef BPtr_Value val_t; + typedef val_t node; + typedef Bounded_Pointer< val_t > node_ptr; + typedef Bounded_Pointer< const val_t > const_node_ptr; + + static node_ptr get_parent(const_node_ptr p) { return p->_parent; } + static void set_parent(node_ptr p, node_ptr parent) { p->_parent = parent; } + static node_ptr get_left(const_node_ptr p) { return p->_l_child; } + static void set_left(node_ptr p, node_ptr l_child) { p->_l_child = l_child; } + static node_ptr get_right(const_node_ptr p) { return p->_r_child; } + static void set_right(node_ptr p, node_ptr r_child) { p->_r_child = r_child; } +}; + template < typename Node_Traits > struct BPtr_Value_Traits { diff --git a/test/generic_assoc_test.hpp b/test/generic_assoc_test.hpp index 5854df0..45b861e 100644 --- a/test/generic_assoc_test.hpp +++ b/test/generic_assoc_test.hpp @@ -78,38 +78,32 @@ struct test_generic_assoc typedef typename Value_Container< value_type >::type value_cont_type; typedef typename ValueTraits::reference reference; typedef typename ValueTraits::const_reference const_reference; - static void test_all(value_cont_type& values); - static void test_clone(value_cont_type& values); + static void test_all(value_cont_type&); + static void test_clone(value_cont_type&); static void test_insert_erase_burst(); - static void test_container_from_end(value_cont_type& values); - static void test_splay_up(value_cont_type& values); - static void test_splay_up(value_cont_type& values, boost::intrusive::detail::true_type); - static void test_splay_up(value_cont_type& values, boost::intrusive::detail::false_type); - static void test_splay_down(value_cont_type& values); - static void test_splay_down(value_cont_type& values, boost::intrusive::detail::true_type); - static void test_splay_down(value_cont_type& values, boost::intrusive::detail::false_type); - static void test_rebalance(value_cont_type& values); - static void test_rebalance(value_cont_type& values, boost::intrusive::detail::true_type); - static void test_rebalance(value_cont_type& values, boost::intrusive::detail::false_type); - static void test_insert_before(value_cont_type& values); - static void test_insert_before(value_cont_type& values, boost::intrusive::detail::true_type); - static void test_insert_before(value_cont_type& values, boost::intrusive::detail::false_type); - static void test_container_from_iterator(value_cont_type& values); + static void test_container_from_end(value_cont_type&, detail::true_type); + static void test_container_from_end(value_cont_type&, detail::false_type) {} + static void test_splay_up(value_cont_type&, detail::true_type); + static void test_splay_up(value_cont_type&, detail::false_type) {} + static void test_splay_down(value_cont_type&, detail::true_type); + static void test_splay_down(value_cont_type&, detail::false_type) {} + static void test_rebalance(value_cont_type&, detail::true_type); + static void test_rebalance(value_cont_type&, detail::false_type) {} + static void test_insert_before(value_cont_type&, detail::true_type); + static void test_insert_before(value_cont_type&, detail::false_type) {} + static void test_container_from_iterator(value_cont_type&, detail::true_type); + static void test_container_from_iterator(value_cont_type&, detail::false_type) {} }; -template < bool Has_Container_From_Iterator, typename assoc_type, typename Value_Container > -struct test_container_from_iterator_impl -{ - void operator () (Value_Container&) - { - std::clog << "skipping test_container_from_iterator\n"; - } -}; -template < typename assoc_type, typename Value_Container > -struct test_container_from_iterator_impl< true, assoc_type, Value_Container > -{ - void operator () (Value_Container& values) +template class ContainerDefiner> +void test_generic_assoc:: + test_container_from_iterator(value_cont_type& values, detail::true_type) { + typedef typename ContainerDefiner + < value_type + , value_traits + , constant_time_size + >::type assoc_type; assoc_type testset(values.begin(), values.end()); typedef typename assoc_type::iterator it_type; typedef typename assoc_type::const_iterator cit_type; @@ -127,19 +121,6 @@ struct test_container_from_iterator_impl< true, assoc_type, Value_Container > BOOST_TEST(testset.size() == sz); } } -}; - -template class ContainerDefiner> -void test_generic_assoc:: - test_container_from_iterator(value_cont_type& values) -{ - typedef typename ContainerDefiner - < value_type - , value_traits - , constant_time_size - >::type assoc_type; - test_container_from_iterator_impl< assoc_type::has_container_from_iterator, assoc_type, value_cont_type >()(values); -} template class ContainerDefiner> void test_generic_assoc::test_insert_erase_burst() @@ -202,14 +183,20 @@ void test_generic_assoc::test_insert_erase_burst( template class ContainerDefiner> void test_generic_assoc::test_all(value_cont_type& values) { + typedef typename ContainerDefiner + < value_type + , value_traits + , constant_time_size + >::type assoc_type; + test_clone(values); - test_container_from_end(values); - test_splay_up(values); - test_splay_down(values); - test_rebalance(values); - test_insert_before(values); + test_container_from_end(values, detail::bool_< assoc_type::has_container_from_iterator >()); + test_splay_up(values, detail::bool_< has_splay< assoc_type >::value >()); + test_splay_down(values, detail::bool_< has_splay< assoc_type >::value >()); + test_rebalance(values, detail::bool_< has_rebalance< assoc_type >::value >()); + test_insert_before(values, detail::bool_< has_insert_before< assoc_type >::value >()); test_insert_erase_burst(); - test_container_from_iterator(values); + test_container_from_iterator(values, detail::bool_< assoc_type::has_container_from_iterator >()); } template class ContainerDefiner> @@ -230,28 +217,9 @@ void test_generic_assoc BOOST_TEST (testset2.empty()); } -template < bool Has_Container_From_Iterator, typename assoc_type, typename value_cont_type > -struct test_container_from_end_impl -{ - void operator () (value_cont_type&) - { - std::clog << "skipping test_container_from_end\n"; - } -}; -template < typename assoc_type, typename value_cont_type > -struct test_container_from_end_impl< true, assoc_type, value_cont_type > -{ - void operator () (value_cont_type& values) -{ - assoc_type testset (values.begin(), values.begin() + values.size()); - BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end())); - BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend())); -} -}; - template class ContainerDefiner> void test_generic_assoc - ::test_container_from_end(value_cont_type& values) + ::test_container_from_end(value_cont_type& values, detail::true_type) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner @@ -259,12 +227,14 @@ void test_generic_assoc , value_traits , constant_time_size >::type assoc_type; - test_container_from_end_impl< assoc_type::has_container_from_iterator, assoc_type, value_cont_type >()(values); + assoc_type testset (values.begin(), values.begin() + values.size()); + BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end())); + BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend())); } template class ContainerDefiner> void test_generic_assoc::test_splay_up -(value_cont_type& values, boost::intrusive::detail::true_type) +(value_cont_type& values, detail::true_type) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner @@ -279,7 +249,7 @@ void test_generic_assoc::test_splay_up { assoc_type testset (values.begin(), values.end()); num_values = testset.size(); - original_testset.insert(original_testset.end(), testset.begin(), testset.end()); + original_testset = value_cont_type(testset.begin(), testset.end()); } for(std::size_t i = 0; i != num_values; ++i){ @@ -300,28 +270,9 @@ void test_generic_assoc::test_splay_up } } -template class ContainerDefiner> -void test_generic_assoc::test_splay_up -(value_cont_type&, boost::intrusive::detail::false_type) -{} - -template class ContainerDefiner> -void test_generic_assoc::test_splay_up -(value_cont_type& values) -{ - typedef typename ContainerDefiner - < value_type - , value_traits - , constant_time_size - >::type assoc_type; - typedef typename detail::remove_const::type Type; - typedef detail::bool_::value> enabler; - test_splay_up(values, enabler()); -} - template class ContainerDefiner> void test_generic_assoc::test_splay_down -(value_cont_type& values, boost::intrusive::detail::true_type) +(value_cont_type& values, detail::true_type) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner @@ -336,7 +287,7 @@ void test_generic_assoc::test_splay_down { assoc_type testset (values.begin(), values.end()); num_values = testset.size(); - original_testset.insert(original_testset.end(), testset.begin(), testset.end()); + original_testset = value_cont_type(testset.begin(), testset.end()); } for(std::size_t i = 0; i != num_values; ++i){ @@ -358,28 +309,9 @@ void test_generic_assoc::test_splay_down } } -template class ContainerDefiner> -void test_generic_assoc::test_splay_down -(value_cont_type&, boost::intrusive::detail::false_type) -{} - -template class ContainerDefiner> -void test_generic_assoc::test_splay_down -(value_cont_type& values) -{ - typedef typename ContainerDefiner - < value_type - , value_traits - , constant_time_size - >::type assoc_type; - typedef typename detail::remove_const::type Type; - typedef detail::bool_::value> enabler; - test_splay_down(values, enabler()); -} - template class ContainerDefiner> void test_generic_assoc::test_rebalance -(value_cont_type& values, boost::intrusive::detail::true_type) +(value_cont_type& values, detail::true_type) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner @@ -391,7 +323,8 @@ void test_generic_assoc::test_rebalance orig_set_t original_testset; { assoc_type testset (values.begin(), values.end()); - original_testset.insert(original_testset.end(), testset.begin(), testset.end()); + //original_testset.insert(original_testset.end(), testset.begin(), testset.end()); + original_testset = value_cont_type(testset.begin(), testset.end()); } { assoc_type testset(values.begin(), values.end()); @@ -416,28 +349,9 @@ void test_generic_assoc::test_rebalance } } -template class ContainerDefiner> -void test_generic_assoc::test_rebalance -(value_cont_type&, boost::intrusive::detail::false_type) -{} - -template class ContainerDefiner> -void test_generic_assoc::test_rebalance -(value_cont_type& values) -{ - typedef typename ContainerDefiner - < value_type - , value_traits - , constant_time_size - >::type assoc_type; - typedef typename detail::remove_const::type Type; - typedef detail::bool_::value> enabler; - test_rebalance(values, enabler()); -} - template class ContainerDefiner> void test_generic_assoc::test_insert_before -(value_cont_type& values, boost::intrusive::detail::true_type) +(value_cont_type& values, detail::true_type) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner @@ -485,25 +399,6 @@ void test_generic_assoc::test_insert_before } } -template class ContainerDefiner> -void test_generic_assoc::test_insert_before -(value_cont_type&, boost::intrusive::detail::false_type) -{} - -template class ContainerDefiner> -void test_generic_assoc::test_insert_before -(value_cont_type& values) -{ - typedef typename ContainerDefiner - < value_type - , value_traits - , constant_time_size - >::type assoc_type; - typedef typename detail::remove_const::type Type; - typedef detail::bool_::value> enabler; - test_insert_before(values, enabler()); -} - }}} //namespace boost::intrusive::test #include diff --git a/test/generic_multiset_test.hpp b/test/generic_multiset_test.hpp index fe3800d..82aa6cc 100644 --- a/test/generic_multiset_test.hpp +++ b/test/generic_multiset_test.hpp @@ -18,6 +18,7 @@ #include "test_macros.hpp" #include "test_container.hpp" #include "generic_assoc_test.hpp" +#include namespace boost{ namespace intrusive{ @@ -30,11 +31,11 @@ struct test_generic_multiset typedef typename Value_Container< value_type >::type value_cont_type; typedef typename ValueTraits::reference reference; typedef typename ValueTraits::const_reference const_reference; - static void test_all (); - static void test_sort(value_cont_type& values); - static void test_insert(value_cont_type& values); - static void test_swap(value_cont_type& values); - static void test_find(value_cont_type& values); + static void test_all(); + static void test_sort(value_cont_type&); + static void test_insert(value_cont_type&); + static void test_swap(value_cont_type&); + static void test_find(value_cont_type&); static void test_impl(); }; @@ -52,6 +53,22 @@ void test_generic_multiset::test_all () , value_traits , constant_time_size >::type multiset_type; +#ifdef PRINT_TESTS + std::clog << "testing multiset with:\n" + << " value_type = " << typeid(value_type).name() << "\n" + << " sizeof(value_type) = " << sizeof(value_type) << "\n" + << " link_mode = " << ValueTraits::link_mode << "\n" + << " node = " << typeid(typename multiset_type::node).name() << "\n" + << " sizeof(node) = " << sizeof(typename multiset_type::node) << "\n" + << " node_ptr = " << typeid(typename multiset_type::node_ptr).name() << "\n" + << " sizeof(node_ptr) = " << sizeof(typename multiset_type::node_ptr) << "\n" + << " constant_time_size = " << multiset_type::constant_time_size << "\n" + << " has_container_from_iterator = " << multiset_type::has_container_from_iterator << "\n" + << " has_splay = " << has_splay< multiset_type >::value << "\n" + << " has_rebalance = " << has_rebalance< multiset_type >::value << "\n" + << " has_insert_before = " << has_insert_before< multiset_type >::value << "\n" + << " sizeof(multiset_type) = " << sizeof(multiset_type) << "\n"; +#endif { multiset_type testset(values.begin(), values.end()); test::test_container(testset); diff --git a/test/generic_set_test.hpp b/test/generic_set_test.hpp index cf132a2..86bea8b 100644 --- a/test/generic_set_test.hpp +++ b/test/generic_set_test.hpp @@ -18,6 +18,7 @@ #include "test_macros.hpp" #include "test_container.hpp" #include "generic_assoc_test.hpp" +#include namespace boost{ namespace intrusive{ @@ -37,13 +38,12 @@ struct test_generic_set typedef typename ValueTraits::reference reference; typedef typename ValueTraits::const_reference const_reference; static void test_all(); - static void test_sort(value_cont_type& values); - static void test_insert(value_cont_type& values); - static void test_insert_advanced(value_cont_type& values, boost::intrusive::detail::true_type); - static void test_insert_advanced(value_cont_type& values, boost::intrusive::detail::false_type); - static void test_insert_advanced(value_cont_type& values); - static void test_swap(value_cont_type& values); - static void test_find(value_cont_type& values); + static void test_sort(value_cont_type&); + static void test_insert(value_cont_type&); + static void test_insert_advanced(value_cont_type&, detail::true_type); + static void test_insert_advanced(value_cont_type&, detail::false_type); + static void test_swap(value_cont_type&); + static void test_find(value_cont_type&); static void test_impl(); }; @@ -62,6 +62,23 @@ void test_generic_set::test_all() , value_traits , constant_time_size >::type set_type; +#ifdef PRINT_TESTS + std::clog << "testing set with:\n" + << " value_type = " << typeid(value_type).name() << "\n" + << " sizeof(value_type) = " << sizeof(value_type) << "\n" + << " link_mode = " << ValueTraits::link_mode << "\n" + << " node = " << typeid(typename set_type::node).name() << "\n" + << " sizeof(node) = " << sizeof(typename set_type::node) << "\n" + << " node_ptr = " << typeid(typename set_type::node_ptr).name() << "\n" + << " sizeof(node_ptr) = " << sizeof(typename set_type::node_ptr) << "\n" + << " constant_time_size = " << set_type::constant_time_size << "\n" + << " has_container_from_iterator = " << set_type::has_container_from_iterator << "\n" + << " is_treap = " << is_treap< set_type >::value << "\n" + << " has_splay = " << has_splay< set_type >::value << "\n" + << " has_rebalance = " << has_rebalance< set_type >::value << "\n" + << " has_insert_before = " << has_insert_before< set_type >::value << "\n" + << " sizeof(set_type) = " << sizeof(set_type) << "\n"; +#endif { set_type testset(values.begin(), values.end()); test::test_container(testset); @@ -77,7 +94,7 @@ void test_generic_set::test_all() } test_sort(values); test_insert(values); - test_insert_advanced(values); + test_insert_advanced(values, detail::bool_< is_treap< set_type >::value >()); test_swap(values); test_find(values); test_impl(); @@ -187,9 +204,10 @@ void test_generic_set::test_insert(value_cont_typ } } +// treap version template class ContainerDefiner> void test_generic_set::test_insert_advanced -(value_cont_type& values, boost::intrusive::detail::true_type) +(value_cont_type& values, detail::true_type) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner @@ -207,28 +225,10 @@ void test_generic_set::test_insert_advanced } } - -template class ContainerDefiner> -void test_generic_set::test_insert_advanced -(value_cont_type& values) -{ - typedef typename ValueTraits::value_type value_type; - typedef typename ContainerDefiner - < value_type - , value_traits - , constant_time_size - >::type set_type; - typedef typename detail::remove_const::type Type; - typedef detail::bool_::value> enabler; - test_insert_advanced(values, enabler()); -} - - //test: insert, const_iterator, const_reverse_iterator, erase, s_iterator_to: template class ContainerDefiner> void test_generic_set::test_insert_advanced - ( value_cont_type& values - , boost::intrusive::detail::false_type) +(value_cont_type& values, detail::false_type) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner @@ -246,7 +246,6 @@ void test_generic_set::test_insert_advanced } } - //test: insert (seq-version), swap, erase (seq-version), size: template class ContainerDefiner> void test_generic_set::test_swap(value_cont_type& values) diff --git a/test/itestvalue.hpp b/test/itestvalue.hpp index 43ffc5e..b10a520 100644 --- a/test/itestvalue.hpp +++ b/test/itestvalue.hpp @@ -118,16 +118,15 @@ void swap_nodes(testvalue< Hooks, ConstantTimeSize >& lhs, testvalue< Hooks, Con lhs.swap_nodes(rhs); } -template -std::size_t hash_value(const testvalue &t) +template < typename Value_Type > +std::size_t hash_value(const Value_Type& t) { boost::hash hasher; - return hasher(t.value_); + return hasher((&t)->value_); } -template -bool priority_order( const testvalue &t1 - , const testvalue &t2) +template < typename Value_Type > +bool priority_order(const Value_Type& t1, const Value_Type& t2) { std::size_t hash1 = hash_value(t1); boost::hash_combine(hash1, &t1); diff --git a/test/list_test.cpp b/test/list_test.cpp index 06f8eb9..3e58f64 100644 --- a/test/list_test.cpp +++ b/test/list_test.cpp @@ -51,21 +51,23 @@ struct test_list typedef typename value_traits::value_type value_type; typedef typename list_type::node_algorithms node_algorithms; - static void test_all(Value_Container& values); - static void test_front_back(Value_Container& values); - static void test_sort(Value_Container& values); - static void test_merge(Value_Container& values); - static void test_remove_unique(Value_Container& values); - static void test_insert(Value_Container& values); - static void test_shift(Value_Container& values); - static void test_swap(Value_Container& values); - static void test_clone(Value_Container& values); - static void test_container_from_end(Value_Container& values); + static void test_all(Value_Container&); + static void test_front_back(Value_Container&); + static void test_sort(Value_Container&); + static void test_merge(Value_Container&); + static void test_remove_unique(Value_Container&); + static void test_insert(Value_Container&); + static void test_shift(Value_Container&); + static void test_swap(Value_Container&); + static void test_clone(Value_Container&); + static void test_container_from_end(Value_Container&, detail::true_type); + static void test_container_from_end(Value_Container&, detail::false_type) {} }; template < typename List_Type, typename Value_Container > void test_list< List_Type, Value_Container >::test_all(Value_Container& values) { +#ifdef PRINT_TESTS std::clog << "testing list with:\n" << " value_type = " << typeid(value_type).name() << "\n" << " sizeof(value_type) = " << sizeof(value_type) << "\n" @@ -77,6 +79,7 @@ void test_list< List_Type, Value_Container >::test_all(Value_Container& values) << " constant_time_size = " << list_type::constant_time_size << "\n" << " has_container_from_iterator = " << list_type::has_container_from_iterator << "\n" << " sizeof(list_type) = " << sizeof(list_type) << "\n"; +#endif { list_type list(values.begin(), values.end()); test::test_container(list); @@ -93,7 +96,7 @@ void test_list< List_Type, Value_Container >::test_all(Value_Container& values) test_shift(values); test_swap(values); test_clone(values); - test_container_from_end(values); + test_container_from_end(values, detail::bool_< List_Type::has_container_from_iterator >()); } //test: push_front, pop_front, push_back, pop_back, front, back, size, empty: @@ -338,33 +341,14 @@ void test_list< List_Type, Value_Container > } } -template < class List_Type, typename Value_Container, bool > -struct test_container_from_end_impl -{ - void operator () (Value_Container&) - { - std::clog << "skipping test_container_from_end\n"; - } -}; - template < class List_Type, typename Value_Container > -struct test_container_from_end_impl< List_Type, Value_Container, true > +void test_list< List_Type, Value_Container > + ::test_container_from_end(Value_Container& values, detail::true_type) { - void operator () (Value_Container& values) -{ - typedef List_Type list_type; list_type testlist1 (values.begin(), values.begin() + values.size()); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.end())); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.cend())); } -}; - -template < class List_Type, typename Value_Container > -void test_list< List_Type, Value_Container > - ::test_container_from_end(Value_Container& values) -{ - test_container_from_end_impl< List_Type, Value_Container, List_Type::has_container_from_iterator >()(values); -} template < class List_Type, typename Value_Container > void test_list< List_Type, Value_Container > @@ -546,15 +530,15 @@ struct test_main_template_bptr int main( int, char* [] ) { - // test combinations of (regular/smart)_ptr x (const/nonconst)_size x (default/non-default)_header_holder - // skip smart_ptr with non-default header_holder + // test (plain/smart pointers) x (nonconst/const size) x (void node allocator) test_main_template()(); - test_main_template, false, true>()(); + test_main_template, false, true>()(); test_main_template()(); - test_main_template, true, true>()(); + test_main_template, true, true>()(); + // test (plain pointers) x (nonconst/const size) x (standard node allocator) test_main_template()(); test_main_template()(); - // test bounded pointers with const/non_const size (always with non-default header_holder) + // test (bounded pointers) x ((nonconst/const size) x (special node allocator) test_main_template_bptr< true >()(); test_main_template_bptr< false >()(); diff --git a/test/multiset_test.cpp b/test/multiset_test.cpp index b96e206..2c65244 100644 --- a/test/multiset_test.cpp +++ b/test/multiset_test.cpp @@ -20,13 +20,13 @@ namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_insert_before()(); test_main_template()(); - // test (bounded pointers) x ((nonconst/const size) x (special node allocator) + // test (bounded pointers) x (nonconst/const size) x (special node allocator) test_main_template_bptr< true >()(); test_main_template_bptr< false >()(); diff --git a/test/set_test.cpp b/test/set_test.cpp index 537335c..d633773 100644 --- a/test/set_test.cpp +++ b/test/set_test.cpp @@ -21,13 +21,13 @@ namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_insert_before()(); test_main_template()(); - // test (bounded pointers) x ((nonconst/const size) x (special node allocator) + // test (bounded pointers) x (nonconst/const size) x (special node allocator) test_main_template_bptr< true >()(); test_main_template_bptr< false >()(); diff --git a/test/sg_multiset_test.cpp b/test/sg_multiset_test.cpp index 4eee56c..f2665f0 100644 --- a/test/sg_multiset_test.cpp +++ b/test/sg_multiset_test.cpp @@ -13,19 +13,20 @@ #include #include #include "itestvalue.hpp" +#include "bptr_value.hpp" #include "smart_ptr.hpp" #include "generic_multiset_test.hpp" namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_rebalance +template #else template #endif struct has_insert_before struct GetContainer { - typedef boost::intrusive::sg_multiset + typedef boost::intrusive::sg_set < ValueType , Option1 , Option2 @@ -94,7 +95,7 @@ template< class ValueType > struct GetContainerFixedAlpha { - typedef boost::intrusive::sg_multiset + typedef boost::intrusive::sg_set < ValueType , Option1 , Option2 @@ -103,7 +104,101 @@ struct GetContainerFixedAlpha > type; }; -template +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainer_With_Holder +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + typedef boost::intrusive::sg_multiset + < ValueType + , Option1 + , Option2 + , Option3 + > type; +}; +}; + +// container generator with standard (non-void) node allocator +template <> +struct GetContainer_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< sgtree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::sg_multiset + < ValueType + , Option1 + , Option2 + , Option3 + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainerFixedAlpha_With_Holder +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainerFixedAlpha +{ + typedef boost::intrusive::sg_multiset + < ValueType + , Option1 + , Option2 + , Option3 + > type; +}; +}; + +// container generator with standard (non-void) node allocator +template <> +struct GetContainerFixedAlpha_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainerFixedAlpha +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< sgtree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::sg_multiset + < ValueType + , Option1 + , Option2 + , Option3 + , boost::intrusive::floating_point + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + + +template class test_main_template { public: @@ -116,7 +211,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits < value_type @@ -125,13 +220,13 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_base_value_traits < value_type , typename hooks::base_hook_type >::type - , GetContainerFixedAlpha + , GetContainerFixedAlpha_With_Holder< Default_Holder >::template GetContainerFixedAlpha >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits < value_type @@ -140,22 +235,73 @@ class test_main_template , &value_type::node_ > >::type - , GetContainerFixedAlpha + , GetContainerFixedAlpha_With_Holder< Default_Holder >::template GetContainerFixedAlpha >::test_all(); test::test_generic_multiset < nonhook_node_member_value_traits< value_type, typename hooks::nonhook_node_member_type, &value_type::nhn_member_, safe_link >, - GetContainerFixedAlpha + GetContainerFixedAlpha_With_Holder< Default_Holder >::template GetContainerFixedAlpha >::test_all(); return 0; } }; +// container generator which ignores further parametrization, except for compare option +template < typename Value_Traits, bool Constant_Time_Size, typename Header_Holder > +struct Get_Preset_Container +{ + template < class + , class Option1 = void + , class Option2 = void + , class Option3 = void + > + struct GetContainer + { + // ignore further paramatrization except for the compare option + // notably ignore the size option (use preset) + typedef typename pack_options< sgtree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename packed_options::compare compare_option; + + typedef boost::intrusive::sg_multiset< typename Value_Traits::value_type, + value_traits< Value_Traits >, + constant_time_size< Constant_Time_Size >, + compare< compare_option >, + header_holder_type< Header_Holder > + > type; + }; +}; + +template < bool Constant_Time_Size > +struct test_main_template_bptr +{ + void operator () () + { + typedef BPtr_Value value_type; + typedef BPtr_Value_Traits< Tree_BPtr_Node_Traits > value_traits; + typedef Bounded_Allocator< value_type > allocator_type; + + allocator_type::init(); + test::test_generic_multiset< value_traits, + Get_Preset_Container< value_traits, Constant_Time_Size, + Bounded_Pointer_Holder< value_type > >::template GetContainer + >::test_all(); + assert(allocator_type::is_clear()); + allocator_type::destroy(); + } +}; + int main( int, char* [] ) { - test_main_template()(); - test_main_template >()(); + // test (plain/smart pointers) x (const size) x (void node allocator) + test_main_template()(); + test_main_template, true >()(); + // test (plain pointers) x (const size) x (standard node allocator) + test_main_template()(); + // test (bounded pointers) x (nonconst/const size) x (special node allocator) + test_main_template_bptr< true >()(); + test_main_template_bptr< false >()(); + return boost::report_errors(); } diff --git a/test/sg_set_test.cpp b/test/sg_set_test.cpp index 00926e1..ad5a9db 100644 --- a/test/sg_set_test.cpp +++ b/test/sg_set_test.cpp @@ -12,19 +12,20 @@ #include #include #include "itestvalue.hpp" +#include "bptr_value.hpp" #include "smart_ptr.hpp" #include "generic_set_test.hpp" namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_rebalance +template #else template #endif struct has_insert_before type; }; -template +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainer_With_Holder +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + typedef boost::intrusive::sg_set + < ValueType + , Option1 + , Option2 + , Option3 + > type; +}; +}; + +// container generator with standard (non-void) node allocator +template <> +struct GetContainer_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< sgtree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::sg_set + < ValueType + , Option1 + , Option2 + , Option3 + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainerFixedAlpha_With_Holder +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainerFixedAlpha +{ + typedef boost::intrusive::sg_set + < ValueType + , Option1 + , Option2 + , Option3 + > type; +}; +}; + +// container generator with standard (non-void) node allocator +template <> +struct GetContainerFixedAlpha_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainerFixedAlpha +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< sgtree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::sg_set + < ValueType + , Option1 + , Option2 + , Option3 + , boost::intrusive::floating_point + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + +template class test_main_template { public: @@ -114,7 +208,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_member_value_traits < value_type @@ -123,14 +217,14 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_base_value_traits < value_type , typename hooks::base_hook_type >::type - , GetContainerFixedAlpha + , GetContainerFixedAlpha_With_Holder< Default_Holder >::template GetContainerFixedAlpha >::test_all(); test::test_generic_set < typename detail::get_member_value_traits < value_type @@ -139,23 +233,74 @@ class test_main_template , &value_type::node_ > >::type - , GetContainerFixedAlpha + , GetContainerFixedAlpha_With_Holder< Default_Holder >::template GetContainerFixedAlpha >::test_all(); test::test_generic_set < nonhook_node_member_value_traits< value_type, typename hooks::nonhook_node_member_type, &value_type::nhn_member_, safe_link >, - GetContainerFixedAlpha + GetContainerFixedAlpha_With_Holder< Default_Holder >::template GetContainerFixedAlpha >::test_all(); return 0; } }; +// container generator which ignores further parametrization, except for compare option +template < typename Value_Traits, bool Constant_Time_Size, typename Header_Holder > +struct Get_Preset_Container +{ + template < class + , class Option1 = void + , class Option2 = void + , class Option3 = void + > + struct GetContainer + { + // ignore further paramatrization except for the compare option + // notably ignore the size option (use preset) + typedef typename pack_options< sgtree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename packed_options::compare compare_option; + + typedef boost::intrusive::sg_set< typename Value_Traits::value_type, + value_traits< Value_Traits >, + constant_time_size< Constant_Time_Size >, + compare< compare_option >, + header_holder_type< Header_Holder > + > type; + }; +}; + +template < bool Constant_Time_Size > +struct test_main_template_bptr +{ + void operator () () + { + typedef BPtr_Value value_type; + typedef BPtr_Value_Traits< Tree_BPtr_Node_Traits > value_traits; + typedef Bounded_Allocator< value_type > allocator_type; + + allocator_type::init(); + test::test_generic_set< value_traits, + Get_Preset_Container< value_traits, Constant_Time_Size, + Bounded_Pointer_Holder< value_type > >::template GetContainer + >::test_all(); + assert(allocator_type::is_clear()); + allocator_type::destroy(); + } +}; + int main( int, char* [] ) { - test_main_template()(); - test_main_template >()(); + // test (plain/smart pointers) x (const size) x (void node allocator) + test_main_template()(); + test_main_template, true >()(); + // test (plain pointers) x (const size) x (standard node allocator) + test_main_template()(); + // test (bounded pointers) x (nonconst/const size) x (special node allocator) + test_main_template_bptr< true >()(); + test_main_template_bptr< false >()(); + return boost::report_errors(); } #include diff --git a/test/slist_test.cpp b/test/slist_test.cpp index e6c544d..457b71d 100644 --- a/test/slist_test.cpp +++ b/test/slist_test.cpp @@ -50,26 +50,27 @@ struct test_slist typedef typename value_traits::value_type value_type; typedef typename list_type::node_algorithms node_algorithms; - static void test_all(Value_Container& values); - static void test_front(Value_Container& values); - static void test_back(Value_Container& values, detail::bool_); - static void test_back(Value_Container& values, detail::bool_); - static void test_sort(Value_Container& values); - static void test_merge(Value_Container& values); - static void test_remove_unique(Value_Container& values); - static void test_insert(Value_Container& values); - static void test_shift(Value_Container& values); - static void test_swap(Value_Container& values); - static void test_slow_insert(Value_Container& values); - static void test_clone(Value_Container& values); - static void test_container_from_end(Value_Container &, detail::bool_){} - static void test_container_from_end(Value_Container &values, detail::bool_); + static void test_all(Value_Container&); + static void test_front(Value_Container&); + static void test_back(Value_Container&, detail::true_type); + static void test_back(Value_Container&, detail::false_type) {} + static void test_sort(Value_Container&); + static void test_merge(Value_Container&); + static void test_remove_unique(Value_Container&); + static void test_insert(Value_Container&); + static void test_shift(Value_Container&); + static void test_swap(Value_Container&); + static void test_slow_insert(Value_Container&); + static void test_clone(Value_Container&); + static void test_container_from_end(Value_Container&, detail::true_type); + static void test_container_from_end(Value_Container&, detail::false_type) {} }; template < typename List_Type, typename Value_Container > void test_slist< List_Type, Value_Container > ::test_all (Value_Container& values) { +#ifdef PRINT_TESTS std::clog << "testing slist with:\n" << " value_type = " << typeid(value_type).name() << "\n" << " sizeof(value_type) = " << sizeof(value_type) << "\n" @@ -83,6 +84,7 @@ void test_slist< List_Type, Value_Container > << " cache_last = " << list_type::cache_last << "\n" << " has_container_from_iterator = " << list_type::has_container_from_iterator << "\n" << " sizeof(list_type) = " << sizeof(list_type) << "\n"; +#endif { list_type list(values.begin(), values.end()); test::test_container(list); @@ -91,7 +93,7 @@ void test_slist< List_Type, Value_Container > test::test_sequence_container(list, values); } test_front(values); - test_back(values, detail::bool_()); + test_back(values, detail::bool_< list_type::cache_last >()); test_sort(values); test_merge (values); test_remove_unique(values); @@ -100,7 +102,7 @@ void test_slist< List_Type, Value_Container > test_slow_insert (values); test_swap(values); test_clone(values); - test_container_from_end(values, detail::bool_()); + test_container_from_end(values, detail::bool_< not list_type::linear and list_type::has_container_from_iterator >()); } //test: push_front, pop_front, front, size, empty: @@ -130,7 +132,7 @@ void test_slist< List_Type, Value_Container > //test: push_front, pop_front, front, size, empty: template < typename List_Type, typename Value_Container > void test_slist< List_Type, Value_Container > - ::test_back(Value_Container& values, detail::bool_) + ::test_back(Value_Container& values, detail::true_type) { list_type testlist; BOOST_TEST (testlist.empty()); @@ -145,13 +147,6 @@ void test_slist< List_Type, Value_Container > BOOST_TEST (&testlist.back() == &values[1]); } -//test: push_front, pop_front, front, size, empty: -template < typename List_Type, typename Value_Container > -void test_slist< List_Type, Value_Container > - ::test_back(Value_Container&, detail::bool_) -{} - - //test: merge due to error in merge implementation: template < typename List_Type, typename Value_Container > void test_slist< List_Type, Value_Container > @@ -440,10 +435,8 @@ void test_slist< List_Type, Value_Container > template < typename List_Type, typename Value_Container > void test_slist< List_Type, Value_Container > - ::test_container_from_end(Value_Container& values - ,detail::bool_) + ::test_container_from_end(Value_Container& values, detail::true_type) { - list_type testlist1 (values.begin(), values.begin() + values.size()); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.end())); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.cend())); @@ -782,18 +775,19 @@ struct test_main_template_bptr int main(int, char* []) { - // test combinations of (regular/smart)_ptr x (const/nonconst)_size x (default/non-default)_header_holder - // skip smart_ptr with non-default header_holder + // test (plain/smart pointers) x (nonconst/const size) x (void node allocator) test_main_template()(); - test_main_template, false, true>()(); + test_main_template, false, true>()(); test_main_template()(); - test_main_template, true, true>()(); + test_main_template, true, true>()(); + // test (plain pointers) x (nonconst/const size) x (standard node allocator) test_main_template()(); test_main_template()(); - // test bounded pointers with const/non_const size (always with non-default header_holder) + // test (bounded pointers) x ((nonconst/const size) x (special node allocator) test_main_template_bptr< true >()(); test_main_template_bptr< false >()(); + return boost::report_errors(); } #include diff --git a/test/splay_multiset_test.cpp b/test/splay_multiset_test.cpp index c22706e..9c2bc13 100644 --- a/test/splay_multiset_test.cpp +++ b/test/splay_multiset_test.cpp @@ -14,19 +14,20 @@ #include #include #include "itestvalue.hpp" +#include "bptr_value.hpp" #include "smart_ptr.hpp" #include "generic_multiset_test.hpp" namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_splay +template #else template #endif struct has_rebalance +template #else template #endif struct has_const_searches nonhook_node_member_type; }; +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainer_With_Holder +{ template< class ValueType , class Option1 =void , class Option2 =void @@ -105,8 +110,35 @@ struct GetContainer , Option3 > type; }; +}; -template +// container generator with standard (non-void) node allocator +template <> +struct GetContainer_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< splaytree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::splay_multiset + < ValueType + , Option1 + , Option2 + , Option3 + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + +template class test_main_template { public: @@ -119,7 +151,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits < value_type @@ -128,22 +160,22 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < nonhook_node_member_value_traits< value_type, typename hooks::nonhook_node_member_type, &value_type::nhn_member_, safe_link >, - GetContainer + GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; -template -class test_main_template +template +class test_main_template { public: int operator()() @@ -155,7 +187,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits @@ -165,14 +197,14 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_base_value_traits < value_type , typename hooks::auto_base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits @@ -182,17 +214,69 @@ class test_main_template , &value_type::auto_node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; +// container generator which ignores further parametrization, except for compare option +template < typename Value_Traits, bool Constant_Time_Size, typename Header_Holder > +struct Get_Preset_Container +{ + template < class + , class Option1 = void + , class Option2 = void + , class Option3 = void + > + struct GetContainer + { + // ignore further paramatrization except for the compare option + // notably ignore the size option (use preset) + typedef typename pack_options< splaytree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename packed_options::compare compare_option; + + typedef boost::intrusive::splay_multiset< typename Value_Traits::value_type, + value_traits< Value_Traits >, + constant_time_size< Constant_Time_Size >, + compare< compare_option >, + header_holder_type< Header_Holder > + > type; + }; +}; + +template < bool Constant_Time_Size > +struct test_main_template_bptr +{ + void operator () () + { + typedef BPtr_Value value_type; + typedef BPtr_Value_Traits< Tree_BPtr_Node_Traits > value_traits; + typedef Bounded_Allocator< value_type > allocator_type; + + allocator_type::init(); + test::test_generic_multiset< value_traits, + Get_Preset_Container< value_traits, Constant_Time_Size, + Bounded_Pointer_Holder< value_type > >::template GetContainer + >::test_all(); + assert(allocator_type::is_clear()); + allocator_type::destroy(); + } +}; + int main( int, char* [] ) { - test_main_template()(); - test_main_template, false>()(); - test_main_template()(); - test_main_template, true>()(); + // test (plain/smart pointers) x (nonconst/const size) x (void node allocator) + test_main_template()(); + test_main_template, false, true>()(); + test_main_template()(); + test_main_template, true, true>()(); + // test (plain pointers) x (nonconst/const size) x (standard node allocator) + test_main_template()(); + test_main_template()(); + // test (bounded pointers) x (nonconst/const size) x (special node allocator) + test_main_template_bptr< true >()(); + test_main_template_bptr< false >()(); + return boost::report_errors(); } diff --git a/test/splay_set_test.cpp b/test/splay_set_test.cpp index 7fc3fce..9ac14fe 100644 --- a/test/splay_set_test.cpp +++ b/test/splay_set_test.cpp @@ -12,19 +12,20 @@ #include #include #include "itestvalue.hpp" +#include "bptr_value.hpp" #include "smart_ptr.hpp" #include "generic_set_test.hpp" namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_splay +template #else template #endif struct has_rebalance +template #else template #endif struct has_const_searches nonhook_node_member_type; }; +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainer_With_Holder +{ template< class ValueType , class Option1 =void , class Option2 =void @@ -102,8 +107,35 @@ struct GetContainer , Option3 > type; }; +}; -template +// container generator with standard (non-void) node allocator +template <> +struct GetContainer_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< splaytree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::splay_set + < ValueType + , Option1 + , Option2 + , Option3 + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + +template class test_main_template { public: @@ -116,7 +148,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_member_value_traits < value_type @@ -125,21 +157,21 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < nonhook_node_member_value_traits< value_type, typename hooks::nonhook_node_member_type, &value_type::nhn_member_, safe_link >, - GetContainer + GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; -template -class test_main_template +template +class test_main_template { public: int operator()() @@ -151,7 +183,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_member_value_traits @@ -161,14 +193,14 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_base_value_traits < value_type , typename hooks::auto_base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_member_value_traits @@ -178,19 +210,71 @@ class test_main_template , &value_type::auto_node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; +// container generator which ignores further parametrization, except for compare option +template < typename Value_Traits, bool Constant_Time_Size, typename Header_Holder > +struct Get_Preset_Container +{ + template < class + , class Option1 = void + , class Option2 = void + , class Option3 = void + > + struct GetContainer + { + // ignore further paramatrization except for the compare option + // notably ignore the size option (use preset) + typedef typename pack_options< splaytree_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename packed_options::compare compare_option; + + typedef boost::intrusive::splay_set< typename Value_Traits::value_type, + value_traits< Value_Traits >, + constant_time_size< Constant_Time_Size >, + compare< compare_option >, + header_holder_type< Header_Holder > + > type; + }; +}; + +template < bool Constant_Time_Size > +struct test_main_template_bptr +{ + void operator () () + { + typedef BPtr_Value value_type; + typedef BPtr_Value_Traits< Tree_BPtr_Node_Traits > value_traits; + typedef Bounded_Allocator< value_type > allocator_type; + + allocator_type::init(); + test::test_generic_set< value_traits, + Get_Preset_Container< value_traits, Constant_Time_Size, + Bounded_Pointer_Holder< value_type > >::template GetContainer + >::test_all(); + assert(allocator_type::is_clear()); + allocator_type::destroy(); + } +}; + int main( int, char* [] ) { - test_main_template()(); - test_main_template, false>()(); - test_main_template()(); - test_main_template, true>()(); + // test (plain/smart pointers) x (nonconst/const size) x (void node allocator) + test_main_template()(); + test_main_template, false, true>()(); + test_main_template()(); + test_main_template, true, true>()(); + // test (plain pointers) x (nonconst/const size) x (standard node allocator) + test_main_template()(); + test_main_template()(); + // test (bounded pointers) x (nonconst/const size) x (special node allocator) + test_main_template_bptr< true >()(); + test_main_template_bptr< false >()(); + return boost::report_errors(); } #include diff --git a/test/treap_multiset_test.cpp b/test/treap_multiset_test.cpp index 7918082..0b68455 100644 --- a/test/treap_multiset_test.cpp +++ b/test/treap_multiset_test.cpp @@ -14,19 +14,20 @@ #include #include #include "itestvalue.hpp" +#include "bptr_value.hpp" #include "smart_ptr.hpp" #include "generic_multiset_test.hpp" namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_insert_before nonhook_node_member_type; }; +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainer_With_Holder +{ template< class ValueType , class Option1 =void , class Option2 =void @@ -71,8 +76,35 @@ struct GetContainer , Option3 > type; }; +}; -template +// container generator with standard (non-void) node allocator +template <> +struct GetContainer_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< treap_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::treap_multiset + < ValueType + , Option1 + , Option2 + , Option3 + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + +template class test_main_template { public: @@ -85,7 +117,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits < value_type @@ -94,21 +126,21 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < nonhook_node_member_value_traits< value_type, typename hooks::nonhook_node_member_type, &value_type::nhn_member_, safe_link >, - GetContainer + GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; -template -class test_main_template +template +class test_main_template { public: int operator()() @@ -120,7 +152,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits @@ -130,14 +162,14 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_base_value_traits < value_type , typename hooks::auto_base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_multiset < typename detail::get_member_value_traits @@ -147,18 +179,70 @@ class test_main_template , &value_type::auto_node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; +// container generator which ignores further parametrization, except for compare option +template < typename Value_Traits, bool Constant_Time_Size, typename Header_Holder > +struct Get_Preset_Container +{ + template < class + , class Option1 = void + , class Option2 = void + , class Option3 = void + > + struct GetContainer + { + // ignore further paramatrization except for the compare option + // notably ignore the size option (use preset) + typedef typename pack_options< treap_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename packed_options::compare compare_option; + + typedef boost::intrusive::treap_multiset< typename Value_Traits::value_type, + value_traits< Value_Traits >, + constant_time_size< Constant_Time_Size >, + compare< compare_option >, + header_holder_type< Header_Holder > + > type; + }; +}; + +template < bool Constant_Time_Size > +struct test_main_template_bptr +{ + void operator () () + { + typedef BPtr_Value value_type; + typedef BPtr_Value_Traits< Tree_BPtr_Node_Traits > value_traits; + typedef Bounded_Allocator< value_type > allocator_type; + + allocator_type::init(); + test::test_generic_multiset< value_traits, + Get_Preset_Container< value_traits, Constant_Time_Size, + Bounded_Pointer_Holder< value_type > >::template GetContainer + >::test_all(); + assert(allocator_type::is_clear()); + allocator_type::destroy(); + } +}; + int main( int, char* [] ) { - test_main_template()(); - test_main_template, false>()(); - test_main_template()(); - test_main_template, true>()(); + // test (plain/smart pointers) x (nonconst/const size) x (void node allocator) + test_main_template()(); + test_main_template, false, true>()(); + test_main_template()(); + test_main_template, true, true>()(); + // test (plain pointers) x (nonconst/const size) x (standard node allocator) + test_main_template()(); + test_main_template()(); + // test (bounded pointers) x (nonconst/const size) x (special node allocator) + test_main_template_bptr< true >()(); + test_main_template_bptr< false >()(); + return boost::report_errors(); } diff --git a/test/treap_set_test.cpp b/test/treap_set_test.cpp index 8d1cd49..3edd829 100644 --- a/test/treap_set_test.cpp +++ b/test/treap_set_test.cpp @@ -12,19 +12,20 @@ #include #include #include "itestvalue.hpp" +#include "bptr_value.hpp" #include "smart_ptr.hpp" #include "generic_set_test.hpp" namespace boost { namespace intrusive { namespace test { #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template +template #else template #endif struct has_insert_before +template #else template #endif struct is_treap nonhook_node_member_type; }; +// container generator with void node allocator +template < bool Default_Holder > +struct GetContainer_With_Holder +{ template< class ValueType , class Option1 =void , class Option2 =void @@ -86,8 +91,35 @@ struct GetContainer , Option3 > type; }; +}; -template +// container generator with standard (non-void) node allocator +template <> +struct GetContainer_With_Holder< false > +{ +template< class ValueType + , class Option1 =void + , class Option2 =void + , class Option3 =void + > +struct GetContainer +{ + // extract node type through options->value_traits->node_traits->node + typedef typename pack_options< treap_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename detail::get_value_traits< ValueType, typename packed_options::proto_value_traits>::type value_traits; + typedef typename value_traits::node_traits::node node; + + typedef boost::intrusive::treap_set + < ValueType + , Option1 + , Option2 + , Option3 + , header_holder_type< pointer_holder< node > > + > type; +}; +}; + +template class test_main_template { public: @@ -100,7 +132,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_member_value_traits < value_type @@ -109,21 +141,21 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < nonhook_node_member_value_traits< value_type, typename hooks::nonhook_node_member_type, &value_type::nhn_member_, safe_link >, - GetContainer + GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; -template -class test_main_template +template +class test_main_template { public: int operator()() @@ -135,7 +167,7 @@ class test_main_template < value_type , typename hooks::base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_member_value_traits @@ -145,14 +177,14 @@ class test_main_template , &value_type::node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_base_value_traits < value_type , typename hooks::auto_base_hook_type >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); test::test_generic_set < typename detail::get_member_value_traits @@ -162,19 +194,71 @@ class test_main_template , &value_type::auto_node_ > >::type - , GetContainer + , GetContainer_With_Holder< Default_Holder >::template GetContainer >::test_all(); return 0; } }; +// container generator which ignores further parametrization, except for compare option +template < typename Value_Traits, bool Constant_Time_Size, typename Header_Holder > +struct Get_Preset_Container +{ + template < class + , class Option1 = void + , class Option2 = void + , class Option3 = void + > + struct GetContainer + { + // ignore further paramatrization except for the compare option + // notably ignore the size option (use preset) + typedef typename pack_options< treap_defaults, Option1, Option2, Option3 >::type packed_options; + typedef typename packed_options::compare compare_option; + + typedef boost::intrusive::treap_set< typename Value_Traits::value_type, + value_traits< Value_Traits >, + constant_time_size< Constant_Time_Size >, + compare< compare_option >, + header_holder_type< Header_Holder > + > type; + }; +}; + +template < bool Constant_Time_Size > +struct test_main_template_bptr +{ + void operator () () + { + typedef BPtr_Value value_type; + typedef BPtr_Value_Traits< Tree_BPtr_Node_Traits > value_traits; + typedef Bounded_Allocator< value_type > allocator_type; + + allocator_type::init(); + test::test_generic_set< value_traits, + Get_Preset_Container< value_traits, Constant_Time_Size, + Bounded_Pointer_Holder< value_type > >::template GetContainer + >::test_all(); + assert(allocator_type::is_clear()); + allocator_type::destroy(); + } +}; + int main( int, char* [] ) { - test_main_template()(); - test_main_template, false>()(); - test_main_template()(); - test_main_template, true>()(); + // test (plain/smart pointers) x (nonconst/const size) x (void node allocator) + test_main_template()(); + test_main_template, false, true>()(); + test_main_template()(); + test_main_template, true, true>()(); + // test (plain pointers) x (nonconst/const size) x (standard node allocator) + test_main_template()(); + test_main_template()(); + // test (bounded pointers) x (nonconst/const size) x (special node allocator) + test_main_template_bptr< true >()(); + test_main_template_bptr< false >()(); + return boost::report_errors(); }