forked from boostorg/container
Remove Boost.StaticAsser dependency
This commit is contained in:
1 parent
716ec48861
commit
7c74232a40
62 files changed
+344
-348
No files matched your search
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
#include <cstddef>
|
||||
#include <boost/container/allocator_traits.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
#include <boost/container/detail/function_detector.hpp>
|
||||
#include <boost/move/utility_core.hpp>
|
||||
@@ -250,66 +249,66 @@ int main()
|
||||
test_void_allocator();
|
||||
|
||||
//SimpleAllocator
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::value_type, int>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::pointer, int*>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::const_pointer, const int*>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::void_pointer, void*>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::const_void_pointer, const void*>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::difference_type, std::ptrdiff_t>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::size_type, std::size_t>::value ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::propagate_on_container_copy_assignment::value == false ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::propagate_on_container_move_assignment::value == false ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::propagate_on_container_swap::value == false ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::is_always_equal::value == true ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::is_partially_propagable::value == false ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::rebind_traits<double>::allocator_type
|
||||
, SimpleAllocator<double> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< SimpleAllocator<int> >::rebind_alloc<double>::value_type
|
||||
, double >::value ));
|
||||
|
||||
//ComplexAllocator
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::value_type, int>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::pointer, SimpleSmartPtr<int> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::const_pointer, SimpleSmartPtr<const int> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::void_pointer, SimpleSmartPtr<void> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::const_void_pointer, SimpleSmartPtr<const void> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::difference_type, signed short>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::size_type, unsigned short>::value ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::propagate_on_container_copy_assignment::value == true ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::propagate_on_container_move_assignment::value == true ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::propagate_on_container_swap::value == true ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::is_always_equal::value == false ));
|
||||
BOOST_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::is_partially_propagable::value == true ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::rebind_traits<double>::allocator_type
|
||||
, ComplexAllocator<double> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<boost::container::allocator_traits
|
||||
< ComplexAllocator<int> >::rebind_alloc<double>::value_type
|
||||
, double >::value ));
|
||||
|
||||
|
||||
+2
-2
@@ -421,7 +421,7 @@ int main ()
|
||||
typedef boost::container::deque<int> cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
, "has_trivial_destructor_after_move(std::allocator) test failed");
|
||||
@@ -431,7 +431,7 @@ int main ()
|
||||
typedef boost::container::deque<int, std::allocator<int> > cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
, "has_trivial_destructor_after_move(std::allocator) test failed");
|
||||
|
||||
@@ -56,7 +56,7 @@ void test_stored_size_type()
|
||||
//Test size reduction
|
||||
{
|
||||
typedef devector<unsigned char, void, options_t> devector_t;
|
||||
BOOST_STATIC_ASSERT( sizeof(Unsigned) >= sizeof(std::size_t) ||
|
||||
BOOST_CONTAINER_STATIC_ASSERT( sizeof(Unsigned) >= sizeof(std::size_t) ||
|
||||
sizeof(devector_t) < sizeof(devector<unsigned char>) );
|
||||
}
|
||||
|
||||
|
||||
@@ -24,7 +24,6 @@
|
||||
#include "propagate_allocator_test.hpp"
|
||||
#include "check_equal_containers.hpp"
|
||||
#include "movable_int.hpp"
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/algorithm/cxx14/equal.hpp>
|
||||
|
||||
@@ -4045,7 +4044,7 @@ int main()
|
||||
typedef boost::container::devector<int> cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
, "has_trivial_destructor_after_move(std::allocator) test failed");
|
||||
@@ -4055,7 +4054,7 @@ int main()
|
||||
typedef boost::container::devector<int, std::allocator<int> > cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
, "has_trivial_destructor_after_move(std::allocator) test failed");
|
||||
|
||||
@@ -14,7 +14,6 @@
|
||||
#include <boost/container/vector.hpp>
|
||||
#include <boost/container/devector.hpp>
|
||||
#include <boost/container/deque.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/container/detail/container_or_allocator_rebind.hpp>
|
||||
|
||||
@@ -117,12 +116,12 @@ int main()
|
||||
typedef flat_map<int, float, std::less<int>, small_vector<std::pair<int, float>, 10> > map_container_t;
|
||||
typedef flat_multimap<int, float, std::less<int>, small_vector<std::pair<int, float>, 10> > multimap_container_t;
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<map_container_t, small_flat_map<int, float, 10> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<multimap_container_t, small_flat_multimap<int, float, 10> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<map_container_t, small_flat_map<int, float, 10> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<multimap_container_t, small_flat_multimap<int, float, 10> >::value ));
|
||||
#endif
|
||||
|
||||
BOOST_STATIC_ASSERT(( is_same<map_container_t, small_flat_map_of<int, float, 10>::type >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<multimap_container_t, small_flat_multimap_of<int, float, 10>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<map_container_t, small_flat_map_of<int, float, 10>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<multimap_container_t, small_flat_multimap_of<int, float, 10>::type >::value ));
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
#include <vector>
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/flat_map.hpp>
|
||||
#include <boost/container/allocator.hpp>
|
||||
#include <boost/container/detail/container_or_allocator_rebind.hpp>
|
||||
@@ -463,8 +462,8 @@ struct get_real_stored_allocator<flat_multimap<Key, T, Compare, Allocator> >
|
||||
|
||||
bool test_heterogeneous_lookups()
|
||||
{
|
||||
BOOST_STATIC_ASSERT((dtl::is_transparent<less_transparent>::value));
|
||||
BOOST_STATIC_ASSERT(!(dtl::is_transparent<std::less<int> >::value));
|
||||
BOOST_CONTAINER_STATIC_ASSERT((dtl::is_transparent<less_transparent>::value));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(!(dtl::is_transparent<std::less<int> >::value));
|
||||
typedef flat_map<int, char, less_transparent> map_t;
|
||||
typedef flat_multimap<int, char, less_transparent> mmap_t;
|
||||
typedef map_t::value_type value_type;
|
||||
@@ -776,7 +775,7 @@ int main()
|
||||
typedef boost::container::new_allocator<value_t> alloc_or_cont_t;
|
||||
typedef boost::container::flat_map<int, int> cont;
|
||||
typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_map, default) test failed");
|
||||
}
|
||||
@@ -785,7 +784,7 @@ int main()
|
||||
typedef boost::container::vector<value_t> alloc_or_cont_t;
|
||||
typedef boost::container::flat_map<int, int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_map, vector) test failed");
|
||||
}
|
||||
@@ -794,7 +793,7 @@ int main()
|
||||
typedef std::vector<value_t> alloc_or_cont_t;
|
||||
typedef boost::container::flat_map<int, int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_map, std::vector) test failed");
|
||||
}
|
||||
@@ -803,7 +802,7 @@ int main()
|
||||
typedef boost::container::new_allocator<value_t> alloc_or_cont_t;
|
||||
typedef boost::container::flat_multimap<int, int> cont;
|
||||
typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_multimap, default) test failed");
|
||||
}
|
||||
@@ -812,7 +811,7 @@ int main()
|
||||
typedef boost::container::vector<value_t> alloc_or_cont_t;
|
||||
typedef boost::container::flat_multimap<int, int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_multimap, vector) test failed");
|
||||
}
|
||||
@@ -821,7 +820,7 @@ int main()
|
||||
typedef std::vector<value_t> alloc_or_cont_t;
|
||||
typedef boost::container::flat_multimap<int, int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG (boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG (boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_multimap, std::vector) test failed");
|
||||
}
|
||||
|
||||
@@ -14,7 +14,6 @@
|
||||
#include <boost/container/vector.hpp>
|
||||
#include <boost/container/deque.hpp>
|
||||
#include <boost/container/devector.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/container/detail/container_or_allocator_rebind.hpp>
|
||||
|
||||
@@ -113,11 +112,11 @@ int main()
|
||||
typedef flat_set<int, std::less<int>, small_vector<int, 10> > set_container_t;
|
||||
typedef flat_multiset<int, std::less<int>, small_vector<int, 10> > multiset_container_t;
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<set_container_t, small_flat_set<int, 10> >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<multiset_container_t, small_flat_multiset<int, 10> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<set_container_t, small_flat_set<int, 10> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<multiset_container_t, small_flat_multiset<int, 10> >::value ));
|
||||
#endif
|
||||
BOOST_STATIC_ASSERT(( is_same<set_container_t, small_flat_set_of<int, 10>::type >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<multiset_container_t, small_flat_multiset_of<int, 10>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<set_container_t, small_flat_set_of<int, 10>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<multiset_container_t, small_flat_multiset_of<int, 10>::type >::value ));
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -870,7 +870,7 @@ int main()
|
||||
{
|
||||
typedef boost::container::flat_set<int> cont;
|
||||
typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_set, default) test failed");
|
||||
}
|
||||
@@ -879,7 +879,7 @@ int main()
|
||||
typedef boost::container::vector<int> alloc_or_cont_t;
|
||||
typedef boost::container::flat_set<int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_set, vector) test failed");
|
||||
}
|
||||
@@ -888,7 +888,7 @@ int main()
|
||||
typedef std::vector<int> alloc_or_cont_t;
|
||||
typedef boost::container::flat_set<int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_set, std::vector) test failed");
|
||||
}
|
||||
@@ -896,7 +896,7 @@ int main()
|
||||
{
|
||||
typedef boost::container::flat_multiset<int> cont;
|
||||
typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_multiset, default) test failed");
|
||||
}
|
||||
@@ -905,7 +905,7 @@ int main()
|
||||
typedef boost::container::vector<int> alloc_or_cont_t;
|
||||
typedef boost::container::flat_multiset<int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_multiset, vector) test failed");
|
||||
}
|
||||
@@ -914,7 +914,7 @@ int main()
|
||||
typedef std::vector<int> alloc_or_cont_t;
|
||||
typedef boost::container::flat_multiset<int, std::less<int>, alloc_or_cont_t> cont;
|
||||
typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
|
||||
BOOST_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG ( boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<tree>::value
|
||||
, "has_trivial_destructor_after_move(flat_multiset, std::vector) test failed");
|
||||
}
|
||||
|
||||
@@ -11,7 +11,6 @@
|
||||
#include <boost/container/small_vector.hpp>
|
||||
#include <boost/container/stable_vector.hpp>
|
||||
#include <boost/container/static_vector.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
@@ -133,7 +132,7 @@ int main ()
|
||||
std::less<int>, void> tree;
|
||||
typedef tree::container_type container_type;
|
||||
typedef tree::key_compare key_compare;
|
||||
BOOST_STATIC_ASSERT_MSG ((boost::has_trivial_destructor_after_move<tree>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG ((boost::has_trivial_destructor_after_move<tree>::value ==
|
||||
boost::has_trivial_destructor_after_move<container_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<key_compare>::value)
|
||||
, "has_trivial_destructor_after_move(default allocator) test failed");
|
||||
@@ -144,7 +143,7 @@ int main ()
|
||||
std::less<int>, std::allocator<int> > tree;
|
||||
typedef tree::container_type container_type;
|
||||
typedef tree::key_compare key_compare;
|
||||
BOOST_STATIC_ASSERT_MSG( (boost::has_trivial_destructor_after_move<tree>::value ==
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG( (boost::has_trivial_destructor_after_move<tree>::value ==
|
||||
boost::has_trivial_destructor_after_move<container_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<key_compare>::value)
|
||||
, "has_trivial_destructor_after_move(std::allocator) test failed");
|
||||
|
||||
+2
-2
@@ -263,7 +263,7 @@ int main ()
|
||||
typedef boost::container::list<int> cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
@@ -274,7 +274,7 @@ int main ()
|
||||
typedef boost::container::list<int, std::allocator<int> > cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
|
||||
+6
-6
@@ -643,8 +643,8 @@ int main ()
|
||||
typedef multimap< int*, int*, std::less<int*>, std::allocator< std::pair<int *const, int*> >
|
||||
, tree_assoc_options< optimize_size<false>, tree_type<avl_tree> >::type > avlmmap_size_optimized_no;
|
||||
|
||||
BOOST_STATIC_ASSERT(sizeof(rbmmap_size_optimized_yes) < sizeof(rbmap_size_optimized_no));
|
||||
BOOST_STATIC_ASSERT(sizeof(avlmap_size_optimized_yes) < sizeof(avlmmap_size_optimized_no));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sizeof(rbmmap_size_optimized_yes) < sizeof(rbmap_size_optimized_no));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sizeof(avlmap_size_optimized_yes) < sizeof(avlmmap_size_optimized_no));
|
||||
|
||||
////////////////////////////////////
|
||||
// has_trivial_destructor_after_move testing
|
||||
@@ -658,7 +658,7 @@ int main ()
|
||||
{
|
||||
typedef boost::container::map<int, int> cont;
|
||||
typedef boost::container::dtl::tree<value_type, int, std::less<int>, void, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(map, default allocator) test failed");
|
||||
@@ -667,7 +667,7 @@ int main ()
|
||||
{
|
||||
typedef boost::container::map<int, int, std::less<int>, std::allocator<value_type> > cont;
|
||||
typedef boost::container::dtl::tree<value_type, int, std::less<int>, std::allocator<value_type>, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(map, std::allocator) test failed");
|
||||
@@ -680,7 +680,7 @@ int main ()
|
||||
// default allocator
|
||||
typedef boost::container::multimap<int, int> cont;
|
||||
typedef boost::container::dtl::tree<value_type, int, std::less<int>, void, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(multimap, default allocator) test failed");
|
||||
@@ -689,7 +689,7 @@ int main ()
|
||||
{
|
||||
typedef boost::container::multimap<int, int, std::less<int>, std::allocator<value_type> > cont;
|
||||
typedef boost::container::dtl::tree<value_type, int, std::less<int>, std::allocator<value_type>, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(multimap, std::allocator) test failed");
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/node_handle.hpp>
|
||||
#include <boost/container/new_allocator.hpp>
|
||||
#include <boost/move/utility_core.hpp>
|
||||
@@ -177,16 +176,16 @@ typedef allocator_traits<node_alloc_t>::portable_rebind_alloc<test_pair>::type v
|
||||
void test_types()
|
||||
{
|
||||
//set
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::value_type, test_pair>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::key_type, test_pair>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::mapped_type, test_pair>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::allocator_type, value_allocator_type>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::value_type, test_pair>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::key_type, test_pair>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::mapped_type, test_pair>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::allocator_type, value_allocator_type>::value ));
|
||||
|
||||
//map
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::value_type, test_pair>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::key_type, int>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::mapped_type, unsigned>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::allocator_type, value_allocator_type>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::value_type, test_pair>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::key_type, int>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::mapped_type, unsigned>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::allocator_type, value_allocator_type>::value ));
|
||||
}
|
||||
|
||||
void test_default_constructor()
|
||||
|
||||
@@ -22,7 +22,6 @@
|
||||
#include <boost/intrusive/detail/mpl.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <cstring>
|
||||
#include <iterator>
|
||||
#include <new>
|
||||
@@ -37,14 +36,14 @@ static buffer_t buffer_0xFF;
|
||||
template<class Iterator>
|
||||
const Iterator &on_0x00_buffer()
|
||||
{
|
||||
BOOST_STATIC_ASSERT(sizeof(buffer_t) >= sizeof(Iterator));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sizeof(buffer_t) >= sizeof(Iterator));
|
||||
return * ::new(std::memset(&buffer_0x00, 0x00, sizeof(buffer_0x00))) Iterator();
|
||||
}
|
||||
|
||||
template<class Iterator>
|
||||
const Iterator &on_0xFF_buffer()
|
||||
{
|
||||
BOOST_STATIC_ASSERT(sizeof(buffer_t) >= sizeof(Iterator));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sizeof(buffer_t) >= sizeof(Iterator));
|
||||
return * ::new(std::memset(&buffer_0xFF, 0xFF, sizeof(buffer_0xFF))) Iterator();
|
||||
}
|
||||
|
||||
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/deque.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef deque<int, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::deque_of<int>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::deque_of<int>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::deque<int> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::deque<int> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/devector.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef devector<int, growth_factor_60, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::devector_of<int>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::devector_of<int>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::devector<int> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::devector<int> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/flat_map.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef flat_map<int, float, std::less<int>, pmr::polymorphic_allocator<std::pair<int, float> > > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_map_of<int, float>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_map_of<int, float>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_map<int, float> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_map<int, float> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/flat_set.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef flat_set<int, std::less<int>, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_set_of<int>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_set_of<int>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_set<int> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_set<int> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/list.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef list<int, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::list_of<int>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::list_of<int>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::list<int> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::list<int> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/map.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef map<int, float, std::less<int>, pmr::polymorphic_allocator<std::pair<const int, float> > > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::map_of<int, float>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::map_of<int, float>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::map<int, float> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::map<int, float> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/set.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef set<int, std::less<int>, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::set_of<int>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::set_of<int>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::set<int> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::set<int> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/small_vector.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef small_vector<int, 2, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::small_vector_of<int, 2>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::small_vector_of<int, 2>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::small_vector<int, 2> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::small_vector<int, 2> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/stable_vector.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef stable_vector<int, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::stable_vector_of<int>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::stable_vector_of<int>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::stable_vector<int> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::stable_vector<int> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/string.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -19,13 +18,13 @@ int main()
|
||||
|
||||
typedef basic_string<char, std::char_traits<char>, pmr::polymorphic_allocator<char> > string_t;
|
||||
typedef basic_string<wchar_t, std::char_traits<wchar_t>, pmr::polymorphic_allocator<wchar_t> > wstring_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<string_t, pmr::string>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<string_t, pmr::basic_string_of<char>::type>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<wstring_t, pmr::wstring>::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<wstring_t, pmr::basic_string_of<wchar_t>::type>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<string_t, pmr::string>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<string_t, pmr::basic_string_of<char>::type>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<wstring_t, pmr::wstring>::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<wstring_t, pmr::basic_string_of<wchar_t>::type>::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<string_t, pmr::string >::value ));
|
||||
BOOST_STATIC_ASSERT(( is_same<wstring_t, pmr::wstring >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<string_t, pmr::string >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<wstring_t, pmr::wstring >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -9,7 +9,6 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/container/pmr/vector.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/detail/type_traits.hpp>
|
||||
|
||||
int main()
|
||||
@@ -18,9 +17,9 @@ int main()
|
||||
using boost::container::dtl::is_same;
|
||||
|
||||
typedef vector<int, pmr::polymorphic_allocator<int> > intcontainer_t;
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::vector_of<int>::type >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::vector_of<int>::type >::value ));
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::vector<int> >::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_same<intcontainer_t, pmr::vector<int> >::value ));
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -51,7 +51,6 @@ struct mark_on_destructor
|
||||
bool mark_on_destructor::destroyed = false;
|
||||
|
||||
#include <boost/container/scoped_allocator.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/container/vector.hpp>
|
||||
#include <boost/container/detail/pair.hpp>
|
||||
|
||||
@@ -97,81 +96,81 @@ int main()
|
||||
, InnerAlloc2 > Rebound9Scoped2Inner;
|
||||
|
||||
//outer_allocator_type
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< OuterAlloc
|
||||
, Scoped0Inner::outer_allocator_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< OuterAlloc
|
||||
, Scoped1Inner::outer_allocator_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< OuterAlloc
|
||||
, Scoped2Inner::outer_allocator_type>::value ));
|
||||
//value_type
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
|
||||
, Scoped0Inner::value_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
|
||||
, Scoped1Inner::value_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
|
||||
, Scoped2Inner::value_type>::value ));
|
||||
//size_type
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
|
||||
, Scoped0Inner::size_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
|
||||
, Scoped1Inner::size_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
|
||||
, Scoped2Inner::size_type>::value ));
|
||||
|
||||
//difference_type
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
|
||||
, Scoped0Inner::difference_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
|
||||
, Scoped1Inner::difference_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
|
||||
, Scoped2Inner::difference_type>::value ));
|
||||
|
||||
//pointer
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
|
||||
, Scoped0Inner::pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
|
||||
, Scoped1Inner::pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
|
||||
, Scoped2Inner::pointer>::value ));
|
||||
|
||||
//const_pointer
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
|
||||
, Scoped0Inner::const_pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
|
||||
, Scoped1Inner::const_pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
|
||||
, Scoped2Inner::const_pointer>::value ));
|
||||
|
||||
//void_pointer
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
|
||||
, Scoped0Inner::void_pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
|
||||
, Scoped1Inner::void_pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
|
||||
, Scoped2Inner::void_pointer>::value ));
|
||||
|
||||
//const_void_pointer
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
|
||||
, Scoped0Inner::const_void_pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
|
||||
, Scoped1Inner::const_void_pointer>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
|
||||
, Scoped2Inner::const_void_pointer>::value ));
|
||||
|
||||
//rebind
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<Scoped0Inner::rebind< tagged_integer<9> >::other
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<Scoped0Inner::rebind< tagged_integer<9> >::other
|
||||
, Rebound9Scoped0Inner >::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<Scoped1Inner::rebind< tagged_integer<9> >::other
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<Scoped1Inner::rebind< tagged_integer<9> >::other
|
||||
, Rebound9Scoped1Inner >::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same<Scoped2Inner::rebind< tagged_integer<9> >::other
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same<Scoped2Inner::rebind< tagged_integer<9> >::other
|
||||
, Rebound9Scoped2Inner >::value ));
|
||||
|
||||
//inner_allocator_type
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< Scoped0Inner
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< Scoped0Inner
|
||||
, Scoped0Inner::inner_allocator_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1>
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1>
|
||||
, Scoped1Inner::inner_allocator_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1, InnerAlloc2>
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1, InnerAlloc2>
|
||||
, Scoped2Inner::inner_allocator_type>::value ));
|
||||
|
||||
{
|
||||
@@ -213,78 +212,78 @@ int main()
|
||||
|
||||
//propagate_on_container_copy_assignment
|
||||
//0 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_copy_assignment::value ));
|
||||
//1 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_copy_assignment::value ));
|
||||
//2 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_copy_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_copy_assignment::value ));
|
||||
|
||||
//propagate_on_container_move_assignment
|
||||
//0 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_move_assignment::value ));
|
||||
//1 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_move_assignment::value ));
|
||||
//2 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_move_assignment::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_move_assignment::value ));
|
||||
|
||||
//propagate_on_container_swap
|
||||
//0 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_swap::value ));
|
||||
//1 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_swap::value ));
|
||||
//2 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_swap::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_swap::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_swap::value ));
|
||||
//is_always_equal
|
||||
//0 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped0InnerF::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped0InnerT::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped0InnerF::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped0InnerT::is_always_equal::value ));
|
||||
//1 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped1InnerFT::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped1InnerTF::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped1InnerTT::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped1InnerFF::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped1InnerFT::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped1InnerTF::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped1InnerTT::is_always_equal::value ));
|
||||
//2 inner
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerFFT::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerFTF::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerFTT::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerTFF::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerTFT::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( !Scoped2InnerTTF::is_always_equal::value ));
|
||||
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerFFF::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerFFT::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerFTF::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerFTT::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerTFF::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerTFT::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !Scoped2InnerTTF::is_always_equal::value ));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( Scoped2InnerTTT::is_always_equal::value ));
|
||||
}
|
||||
|
||||
//Default constructor
|
||||
@@ -682,17 +681,17 @@ int main()
|
||||
////////////////////////////////////////////////////////////
|
||||
{
|
||||
//Check outer_allocator_type is scoped
|
||||
BOOST_STATIC_ASSERT(( is_scoped_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_scoped_allocator
|
||||
<ScopedScoped0Inner::outer_allocator_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same
|
||||
< outermost_allocator<ScopedScoped0Inner>::type
|
||||
, Outer10IdAlloc
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same
|
||||
< ScopedScoped0Inner::outer_allocator_type
|
||||
, scoped_allocator_adaptor<Outer10IdAlloc>
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same
|
||||
< scoped_allocator_adaptor<Outer10IdAlloc>::outer_allocator_type
|
||||
, Outer10IdAlloc
|
||||
>::value ));
|
||||
@@ -765,21 +764,21 @@ int main()
|
||||
////////////////////////////////////////////////////////////
|
||||
{
|
||||
//Check outer_allocator_type is scoped
|
||||
BOOST_STATIC_ASSERT(( is_scoped_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( is_scoped_allocator
|
||||
<ScopedScoped1Inner::outer_allocator_type>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same
|
||||
< outermost_allocator<ScopedScoped1Inner>::type
|
||||
, Outer10IdAlloc
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same
|
||||
< ScopedScoped1Inner::outer_allocator_type
|
||||
, scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( dtl::is_same
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( dtl::is_same
|
||||
< scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>::outer_allocator_type
|
||||
, Outer10IdAlloc
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( !
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( !
|
||||
uses_allocator
|
||||
< ::allocator_argument_tester<ConstructibleSuffix, 10>
|
||||
, ScopedScoped1Inner::inner_allocator_type::outer_allocator_type
|
||||
|
||||
+6
-6
@@ -590,8 +590,8 @@ int main ()
|
||||
typedef multiset< int*, std::less<int*>, std::allocator<int*>
|
||||
, tree_assoc_options< optimize_size<false>, tree_type<avl_tree> >::type > avlmset_size_optimized_no;
|
||||
|
||||
BOOST_STATIC_ASSERT(sizeof(rbmset_size_optimized_yes) < sizeof(rbset_size_optimized_no));
|
||||
BOOST_STATIC_ASSERT(sizeof(avlset_size_optimized_yes) < sizeof(avlmset_size_optimized_no));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sizeof(rbmset_size_optimized_yes) < sizeof(rbset_size_optimized_no));
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sizeof(avlset_size_optimized_yes) < sizeof(avlmset_size_optimized_no));
|
||||
|
||||
////////////////////////////////////
|
||||
// Iterator testing
|
||||
@@ -626,7 +626,7 @@ int main ()
|
||||
{
|
||||
typedef boost::container::set<int> cont;
|
||||
typedef boost::container::dtl::tree<int, void, std::less<int>, void, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(set, default allocator) test failed");
|
||||
@@ -635,7 +635,7 @@ int main ()
|
||||
{
|
||||
typedef boost::container::set<int, std::less<int>, std::allocator<int> > cont;
|
||||
typedef boost::container::dtl::tree<int, void, std::less<int>, std::allocator<int>, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(set, std::allocator) test failed");
|
||||
@@ -644,7 +644,7 @@ int main ()
|
||||
{
|
||||
typedef boost::container::multiset<int> cont;
|
||||
typedef boost::container::dtl::tree<int, void, std::less<int>, void, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(multiset, default allocator) test failed");
|
||||
@@ -653,7 +653,7 @@ int main ()
|
||||
{
|
||||
typedef boost::container::multiset<int, std::less<int>, std::allocator<int> > cont;
|
||||
typedef boost::container::dtl::tree<int, void, std::less<int>, std::allocator<int>, void> tree;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<tree>::value)
|
||||
, "has_trivial_destructor_after_move(multiset, std::allocator) test failed");
|
||||
|
||||
+2
-2
@@ -266,7 +266,7 @@ int main ()
|
||||
typedef boost::container::slist<int> cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
@@ -277,7 +277,7 @@ int main ()
|
||||
typedef boost::container::slist<int, std::allocator<int> > cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
|
||||
@@ -18,7 +18,7 @@ void test_alignment()
|
||||
{
|
||||
{ //extended alignment
|
||||
const std::size_t extended_alignment = sizeof(int)*4u;
|
||||
BOOST_STATIC_ASSERT(extended_alignment > dtl::alignment_of<int>::value);
|
||||
BOOST_CONTAINER_STATIC_ASSERT(extended_alignment > dtl::alignment_of<int>::value);
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
using options_t = small_vector_options_t< inplace_alignment<extended_alignment> >;
|
||||
#else
|
||||
|
||||
@@ -40,7 +40,7 @@ bool test_small_vector_base_test()
|
||||
typedef boost::container::small_vector_base<int> smb_t;
|
||||
{
|
||||
typedef boost::container::small_vector<int, 5> sm5_t;
|
||||
BOOST_STATIC_ASSERT(sm5_t::static_capacity == 5);
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sm5_t::static_capacity == 5);
|
||||
sm5_t sm5;
|
||||
smb_t &smb = sm5;
|
||||
smb.push_back(1);
|
||||
@@ -51,7 +51,7 @@ bool test_small_vector_base_test()
|
||||
}
|
||||
{
|
||||
typedef boost::container::small_vector<int, 7> sm7_t;
|
||||
BOOST_STATIC_ASSERT(sm7_t::static_capacity == 7);
|
||||
BOOST_CONTAINER_STATIC_ASSERT(sm7_t::static_capacity == 7);
|
||||
sm7_t sm7;
|
||||
smb_t &smb = sm7;
|
||||
smb.push_back(2);
|
||||
|
||||
@@ -204,7 +204,7 @@ int main()
|
||||
typedef boost::container::stable_vector<int> cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
@@ -215,7 +215,7 @@ int main()
|
||||
typedef boost::container::stable_vector<int, std::allocator<int> > cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG(
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG(
|
||||
!(boost::has_trivial_destructor_after_move<cont>::value !=
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)
|
||||
|
||||
@@ -44,7 +44,7 @@ void test_alignment()
|
||||
const std::size_t Capacity = 10u;
|
||||
{ //extended alignment
|
||||
const std::size_t extended_alignment = sizeof(int)*4u;
|
||||
BOOST_STATIC_ASSERT(extended_alignment > dtl::alignment_of<int>::value);
|
||||
BOOST_CONTAINER_STATIC_ASSERT(extended_alignment > dtl::alignment_of<int>::value);
|
||||
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
|
||||
using options_t = static_vector_options_t< inplace_alignment<extended_alignment> >;
|
||||
#else
|
||||
|
||||
@@ -21,7 +21,7 @@ template <typename T, size_t N>
|
||||
void test_ctor_ndc()
|
||||
{
|
||||
static_vector<T, N> s;
|
||||
BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
|
||||
BOOST_CONTAINER_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
|
||||
BOOST_TEST_EQ(s.size() , 0u);
|
||||
BOOST_TEST(s.capacity() == N);
|
||||
BOOST_TEST(s.max_size() == N);
|
||||
@@ -32,7 +32,7 @@ template <typename T, size_t N>
|
||||
void test_ctor_nc(size_t n)
|
||||
{
|
||||
static_vector<T, N> s(n);
|
||||
BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
|
||||
BOOST_CONTAINER_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
|
||||
BOOST_TEST(s.size() == n);
|
||||
BOOST_TEST(s.capacity() == N);
|
||||
BOOST_TEST(s.max_size() == N);
|
||||
@@ -52,7 +52,7 @@ template <typename T, size_t N>
|
||||
void test_ctor_nd(size_t n, T const& v)
|
||||
{
|
||||
static_vector<T, N> s(n, v);
|
||||
BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
|
||||
BOOST_CONTAINER_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
|
||||
BOOST_TEST(s.size() == n);
|
||||
BOOST_TEST(s.capacity() == N);
|
||||
BOOST_TEST_THROWS( (void)s.at(n), out_of_range_t);
|
||||
|
||||
@@ -595,7 +595,7 @@ int main()
|
||||
typedef boost::container::basic_string<char> cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG
|
||||
( (boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
(boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)),
|
||||
@@ -606,7 +606,7 @@ int main()
|
||||
typedef boost::container::basic_string<char, std::char_traits<char>, std::allocator<char> > cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG
|
||||
( (boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
(boost::has_trivial_destructor_after_move<allocator_type>::value &&
|
||||
boost::has_trivial_destructor_after_move<pointer>::value)),
|
||||
|
||||
@@ -34,49 +34,49 @@ int main()
|
||||
{
|
||||
using namespace boost::container;
|
||||
//Using dummy classes
|
||||
BOOST_STATIC_ASSERT(( false == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( false == uses_allocator
|
||||
< not_uses_allocator, int>::value ));
|
||||
|
||||
BOOST_STATIC_ASSERT(( false == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( false == uses_allocator
|
||||
< uses_allocator_and_not_convertible_to_int, int>::value ));
|
||||
|
||||
BOOST_STATIC_ASSERT(( true == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == uses_allocator
|
||||
< uses_allocator_and_convertible_to_int, int>::value ));
|
||||
|
||||
BOOST_STATIC_ASSERT(( true == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == uses_allocator
|
||||
< uses_erased_type_allocator, int>::value ));
|
||||
|
||||
//Using an allocator-like class
|
||||
BOOST_STATIC_ASSERT(( false == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( false == uses_allocator
|
||||
< allocator_argument_tester<NotUsesAllocator, 0>
|
||||
, propagation_test_allocator<float, 0>
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( true == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == uses_allocator
|
||||
< allocator_argument_tester<ConstructiblePrefix, 0>
|
||||
, propagation_test_allocator<float, 0>
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( true == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == uses_allocator
|
||||
< allocator_argument_tester<ConstructibleSuffix, 0>
|
||||
, propagation_test_allocator<float, 0>
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( true == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == uses_allocator
|
||||
< allocator_argument_tester<ErasedTypeSuffix, 0>
|
||||
, propagation_test_allocator<float, 0>
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( true == uses_allocator
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == uses_allocator
|
||||
< allocator_argument_tester<ErasedTypePrefix, 0>
|
||||
, propagation_test_allocator<float, 0>
|
||||
>::value ));
|
||||
BOOST_STATIC_ASSERT(( true == constructible_with_allocator_prefix
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == constructible_with_allocator_prefix
|
||||
< allocator_argument_tester<ConstructiblePrefix, 0> >::value ));
|
||||
|
||||
BOOST_STATIC_ASSERT(( true == constructible_with_allocator_suffix
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == constructible_with_allocator_suffix
|
||||
< allocator_argument_tester<ConstructibleSuffix, 0> >::value ));
|
||||
|
||||
BOOST_STATIC_ASSERT(( true == constructible_with_allocator_prefix
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == constructible_with_allocator_prefix
|
||||
< allocator_argument_tester<ErasedTypePrefix, 0> >::value ));
|
||||
|
||||
BOOST_STATIC_ASSERT(( true == constructible_with_allocator_suffix
|
||||
BOOST_CONTAINER_STATIC_ASSERT(( true == constructible_with_allocator_suffix
|
||||
< allocator_argument_tester<ErasedTypeSuffix, 0> >::value ));
|
||||
return 0;
|
||||
}
|
||||
@@ -225,7 +225,7 @@ bool test_span_conversion()
|
||||
#endif //BOOST_VECTOR_TEST_HAS_SPAN
|
||||
|
||||
struct POD { int POD::*ptr; };
|
||||
BOOST_STATIC_ASSERT_MSG
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG
|
||||
( boost::container::dtl::is_pod<POD>::value
|
||||
, "POD test failed"
|
||||
);
|
||||
@@ -382,7 +382,7 @@ int main()
|
||||
typedef boost::container::vector<int> cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG
|
||||
( !boost::has_trivial_destructor_after_move<pointer>::value ||
|
||||
(boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value)
|
||||
@@ -394,7 +394,7 @@ int main()
|
||||
typedef boost::container::vector<int, std::allocator<int> > cont;
|
||||
typedef cont::allocator_type allocator_type;
|
||||
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
|
||||
BOOST_STATIC_ASSERT_MSG
|
||||
BOOST_CONTAINER_STATIC_ASSERT_MSG
|
||||
( !boost::has_trivial_destructor_after_move<pointer>::value ||
|
||||
(boost::has_trivial_destructor_after_move<cont>::value ==
|
||||
boost::has_trivial_destructor_after_move<allocator_type>::value)
|
||||
|
||||
@@ -22,7 +22,6 @@
|
||||
#include <boost/move/utility_core.hpp>
|
||||
#include <boost/move/iterator.hpp>
|
||||
#include <boost/move/make_unique.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include "print_container.hpp"
|
||||
#include "check_equal_containers.hpp"
|
||||
@@ -347,7 +346,7 @@ int vector_move_assignable_only(boost::container::dtl::true_type)
|
||||
IntType aux_vect[50];
|
||||
for(int i = 0; i < 50; ++i){
|
||||
IntType new_int(-1);
|
||||
BOOST_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
|
||||
BOOST_CONTAINER_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
|
||||
aux_vect[i] = boost::move(new_int);
|
||||
}
|
||||
int aux_vect2[50];
|
||||
|
||||
Reference in new issue
Block a user