feedc0de/boost_container
1
0
Fork 0
forked from boostorg/container
Code Pull Requests Activity

Fixes #136 ("List of non BOOST-prefixed macros")

Browse Source
This commit is contained in:
Ion Gaztañaga
2019-12-19 05:29:46 +01:00
parent dd158987e6
commit 27c1fea452
9 changed files with 56 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/boost/container/adaptive_pool.hpp
View File

@ -251,7 +251,7 @@ class adaptive_pool
BOOST_STATIC_ASSERT(( Version > 1 ));/* BOOST_STATIC_ASSERT(( Version > 1 ));/*
dlmalloc_memchain ch; dlmalloc_memchain ch;
BOOST_CONTAINER_MEMCHAIN_INIT(&ch); BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){ if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
chain.incorporate_after(chain.before_begin() chain.incorporate_after(chain.before_begin()
@ -259,7 +259,7 @@ class adaptive_pool
,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/ ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/
if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes
(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){ (n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
} }
@ -271,7 +271,7 @@ class adaptive_pool
BOOST_STATIC_ASSERT(( Version > 1 ));/* BOOST_STATIC_ASSERT(( Version > 1 ));/*
dlmalloc_memchain ch; dlmalloc_memchain ch;
BOOST_CONTAINER_MEMCHAIN_INIT(&ch); BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){ if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
chain.incorporate_after(chain.before_begin() chain.incorporate_after(chain.before_begin()
@ -279,7 +279,7 @@ class adaptive_pool
,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/ ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/
if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays
(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){ (n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
} }
@ -536,7 +536,7 @@ class private_adaptive_pool
{ {
BOOST_STATIC_ASSERT(( Version > 1 )); BOOST_STATIC_ASSERT(( Version > 1 ));
if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes
(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){ (n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
} }
@ -547,7 +547,7 @@ class private_adaptive_pool
{ {
BOOST_STATIC_ASSERT(( Version > 1 )); BOOST_STATIC_ASSERT(( Version > 1 ));
if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays
(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){ (n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
} }

8
include/boost/container/allocator.hpp
View File

@ -287,7 +287,7 @@ class allocator
BOOST_STATIC_ASSERT(( Version > 1 )); BOOST_STATIC_ASSERT(( Version > 1 ));
dlmalloc_memchain ch; dlmalloc_memchain ch;
BOOST_CONTAINER_MEMCHAIN_INIT(&ch); BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){ if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
chain.incorporate_after(chain.before_begin() chain.incorporate_after(chain.before_begin()
@ -295,7 +295,7 @@ class allocator
,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) ); ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );
/* /*
if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){ if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
}*/ }*/
} }
@ -308,7 +308,7 @@ class allocator
BOOST_STATIC_ASSERT(( Version > 1 )); BOOST_STATIC_ASSERT(( Version > 1 ));
dlmalloc_memchain ch; dlmalloc_memchain ch;
BOOST_CONTAINER_MEMCHAIN_INIT(&ch); BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){ if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
chain.incorporate_after(chain.before_begin() chain.incorporate_after(chain.before_begin()
@ -316,7 +316,7 @@ class allocator
,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) ); ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );
/* /*
if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){ if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
}*/ }*/
} }

8
include/boost/container/detail/alloc_lib.h
View File

@ -196,11 +196,11 @@ typedef struct boost_cont_memchain_impl
/*!Indicates the all elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays /*!Indicates the all elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays
must be contiguous.*/ must be contiguous.*/
#define DL_MULTIALLOC_ALL_CONTIGUOUS ((size_t)(-1)) #define BOOST_CONTAINER_DL_MULTIALLOC_ALL_CONTIGUOUS ((size_t)(-1))
/*!Indicates the number of contiguous elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays /*!Indicates the number of contiguous elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays
should be selected by those functions.*/ should be selected by those functions.*/
#define DL_MULTIALLOC_DEFAULT_CONTIGUOUS ((size_t)(0)) #define BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS ((size_t)(0))
typedef struct boost_cont_malloc_stats_impl typedef struct boost_cont_malloc_stats_impl
{ {
@ -225,8 +225,8 @@ enum
BOOST_CONTAINER_EXPAND_OR_NEW = BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BOTH BOOST_CONTAINER_EXPAND_OR_NEW = BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BOTH
}; };
//#define BOOST_CONTAINERDLMALLOC__FOOTERS //#define BOOST_CONTAINER_DLMALLOC_FOOTERS
#ifndef BOOST_CONTAINERDLMALLOC__FOOTERS #ifndef BOOST_CONTAINER_DLMALLOC_FOOTERS
enum { BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t) }; enum { BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t) };
#else #else
enum { BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t)*2 }; enum { BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t)*2 };

4
include/boost/container/node_allocator.hpp
View File

@ -258,7 +258,7 @@ class node_allocator
BOOST_STATIC_ASSERT(( Version > 1 )); BOOST_STATIC_ASSERT(( Version > 1 ));
dlmalloc_memchain ch; dlmalloc_memchain ch;
BOOST_CONTAINER_MEMCHAIN_INIT(&ch); BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){ if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }
chain.incorporate_after( chain.before_begin() chain.incorporate_after( chain.before_begin()
@ -273,7 +273,7 @@ class node_allocator
{ {
BOOST_STATIC_ASSERT(( Version > 1 )); BOOST_STATIC_ASSERT(( Version > 1 ));
dlmalloc_memchain ch; dlmalloc_memchain ch;
dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch); dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch);
if(BOOST_UNLIKELY(BOOST_CONTAINER_MEMCHAIN_EMPTY(&ch))){ if(BOOST_UNLIKELY(BOOST_CONTAINER_MEMCHAIN_EMPTY(&ch))){
boost::container::throw_bad_alloc(); boost::container::throw_bad_alloc();
} }

60
include/boost/container/stable_vector.hpp
View File

@ -434,13 +434,13 @@ class stable_vector_iterator
#if defined(STABLE_VECTOR_ENABLE_INVARIANT_CHECKING) #if defined(STABLE_VECTOR_ENABLE_INVARIANT_CHECKING)
#define STABLE_VECTOR_CHECK_INVARIANT \ #define BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT \
invariant_checker BOOST_JOIN(check_invariant_,__LINE__)(*this); \ invariant_checker BOOST_JOIN(check_invariant_,__LINE__)(*this); \
BOOST_JOIN(check_invariant_,__LINE__).touch(); BOOST_JOIN(check_invariant_,__LINE__).touch();
#else //STABLE_VECTOR_ENABLE_INVARIANT_CHECKING #else //STABLE_VECTOR_ENABLE_INVARIANT_CHECKING
#define STABLE_VECTOR_CHECK_INVARIANT #define BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT
#endif //#if defined(STABLE_VECTOR_ENABLE_INVARIANT_CHECKING) #endif //#if defined(STABLE_VECTOR_ENABLE_INVARIANT_CHECKING)
@ -604,7 +604,7 @@ class stable_vector
BOOST_CONTAINER_FORCEINLINE stable_vector() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<ValueAllocator>::value) BOOST_CONTAINER_FORCEINLINE stable_vector() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<ValueAllocator>::value)
: internal_data(), index() : internal_data(), index()
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
} }
//! <b>Effects</b>: Constructs a stable_vector taking the allocator as parameter. //! <b>Effects</b>: Constructs a stable_vector taking the allocator as parameter.
@ -615,7 +615,7 @@ class stable_vector
BOOST_CONTAINER_FORCEINLINE explicit stable_vector(const allocator_type& al) BOOST_NOEXCEPT_OR_NOTHROW BOOST_CONTAINER_FORCEINLINE explicit stable_vector(const allocator_type& al) BOOST_NOEXCEPT_OR_NOTHROW
: internal_data(al), index(al) : internal_data(al), index(al)
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
} }
//! <b>Effects</b>: Constructs a stable_vector //! <b>Effects</b>: Constructs a stable_vector
@ -630,7 +630,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->resize(n); this->resize(n);
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -648,7 +648,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->resize(n, default_init); this->resize(n, default_init);
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -664,7 +664,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->resize(n); this->resize(n);
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -682,7 +682,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->resize(n, default_init); this->resize(n, default_init);
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -698,7 +698,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->insert(this->cend(), n, t); this->insert(this->cend(), n, t);
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -715,7 +715,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->insert(this->cend(), first, last); this->insert(this->cend(), first, last);
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -732,7 +732,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->insert(this->cend(), x.begin(), x.end()); this->insert(this->cend(), x.begin(), x.end());
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -749,7 +749,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
insert(cend(), il.begin(), il.end()); insert(cend(), il.begin(), il.end());
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
#endif #endif
@ -775,7 +775,7 @@ class stable_vector
{ {
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->insert(this->cend(), x.begin(), x.end()); this->insert(this->cend(), x.begin(), x.end());
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
@ -795,7 +795,7 @@ class stable_vector
else{ else{
stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); stable_vector_detail::clear_on_destroy<stable_vector> cod(*this);
this->insert(this->cend(), boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end())); this->insert(this->cend(), boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end()));
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
cod.release(); cod.release();
} }
} }
@ -822,7 +822,7 @@ class stable_vector
//! <b>Complexity</b>: Linear to the number of elements in x. //! <b>Complexity</b>: Linear to the number of elements in x.
stable_vector& operator=(BOOST_COPY_ASSIGN_REF(stable_vector) x) stable_vector& operator=(BOOST_COPY_ASSIGN_REF(stable_vector) x)
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
if (BOOST_LIKELY(this != &x)) { if (BOOST_LIKELY(this != &x)) {
node_allocator_type &this_alloc = this->priv_node_alloc(); node_allocator_type &this_alloc = this->priv_node_alloc();
const node_allocator_type &x_alloc = x.priv_node_alloc(); const node_allocator_type &x_alloc = x.priv_node_alloc();
@ -865,7 +865,7 @@ class stable_vector
//Resources can be transferred if both allocators are //Resources can be transferred if both allocators are
//going to be equal after this function (either propagated or already equal) //going to be equal after this function (either propagated or already equal)
if(propagate_alloc || allocators_equal){ if(propagate_alloc || allocators_equal){
STABLE_VECTOR_CHECK_INVARIANT BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT
//Destroy objects but retain memory in case x reuses it in the future //Destroy objects but retain memory in case x reuses it in the future
this->clear(); this->clear();
//Move allocator if needed //Move allocator if needed
@ -889,7 +889,7 @@ class stable_vector
//! <b>Complexity</b>: Linear to the range [il.begin(), il.end()). //! <b>Complexity</b>: Linear to the range [il.begin(), il.end()).
stable_vector& operator=(std::initializer_list<value_type> il) stable_vector& operator=(std::initializer_list<value_type> il)
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
assign(il.begin(), il.end()); assign(il.begin(), il.end());
return *this; return *this;
} }
@ -920,7 +920,7 @@ class stable_vector
#endif #endif
assign(InputIterator first,InputIterator last) assign(InputIterator first,InputIterator last)
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
iterator first1 = this->begin(); iterator first1 = this->begin();
iterator last1 = this->end(); iterator last1 = this->end();
for ( ; first1 != last1 && first != last; ++first1, ++first) for ( ; first1 != last1 && first != last; ++first1, ++first)
@ -941,7 +941,7 @@ class stable_vector
//! //!
BOOST_CONTAINER_FORCEINLINE void assign(std::initializer_list<value_type> il) BOOST_CONTAINER_FORCEINLINE void assign(std::initializer_list<value_type> il)
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
assign(il.begin(), il.end()); assign(il.begin(), il.end());
} }
#endif #endif
@ -1124,7 +1124,7 @@ class stable_vector
void resize(size_type n) void resize(size_type n)
{ {
typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator; typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator;
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
if(n > this->size()) if(n > this->size())
this->insert(this->cend(), value_init_iterator(n - this->size()), value_init_iterator()); this->insert(this->cend(), value_init_iterator(n - this->size()), value_init_iterator());
else if(n < this->size()) else if(n < this->size())
@ -1142,7 +1142,7 @@ class stable_vector
void resize(size_type n, default_init_t) void resize(size_type n, default_init_t)
{ {
typedef default_init_construct_iterator<value_type, difference_type> default_init_iterator; typedef default_init_construct_iterator<value_type, difference_type> default_init_iterator;
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
if(n > this->size()) if(n > this->size())
this->insert(this->cend(), default_init_iterator(n - this->size()), default_init_iterator()); this->insert(this->cend(), default_init_iterator(n - this->size()), default_init_iterator());
else if(n < this->size()) else if(n < this->size())
@ -1157,7 +1157,7 @@ class stable_vector
//! <b>Complexity</b>: Linear to the difference between size() and new_size. //! <b>Complexity</b>: Linear to the difference between size() and new_size.
void resize(size_type n, const T& t) void resize(size_type n, const T& t)
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
if(n > this->size()) if(n > this->size())
this->insert(this->cend(), n - this->size(), t); this->insert(this->cend(), n - this->size(), t);
else if(n < this->size()) else if(n < this->size())
@ -1190,7 +1190,7 @@ class stable_vector
//! <b>Throws</b>: If memory allocation allocation throws. //! <b>Throws</b>: If memory allocation allocation throws.
void reserve(size_type n) void reserve(size_type n)
{ {
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
if(n > this->max_size()){ if(n > this->max_size()){
throw_length_error("stable_vector::reserve max_size() exceeded"); throw_length_error("stable_vector::reserve max_size() exceeded");
} }
@ -1562,7 +1562,7 @@ class stable_vector
iterator insert(const_iterator p, size_type n, const T& t) iterator insert(const_iterator p, size_type n, const T& t)
{ {
BOOST_ASSERT(this->priv_in_range_or_end(p)); BOOST_ASSERT(this->priv_in_range_or_end(p));
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
typedef constant_iterator<value_type, difference_type> cvalue_iterator; typedef constant_iterator<value_type, difference_type> cvalue_iterator;
return this->insert(p, cvalue_iterator(t, n), cvalue_iterator()); return this->insert(p, cvalue_iterator(t, n), cvalue_iterator());
} }
@ -1579,7 +1579,7 @@ class stable_vector
BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, std::initializer_list<value_type> il) BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, std::initializer_list<value_type> il)
{ {
//Position checks done by insert() //Position checks done by insert()
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
return insert(p, il.begin(), il.end()); return insert(p, il.begin(), il.end());
} }
#endif #endif
@ -1608,7 +1608,7 @@ class stable_vector
) )
{ {
BOOST_ASSERT(this->priv_in_range_or_end(p)); BOOST_ASSERT(this->priv_in_range_or_end(p));
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
const size_type pos_n = p - this->cbegin(); const size_type pos_n = p - this->cbegin();
for(; first != last; ++first){ for(; first != last; ++first){
this->emplace(p, *first); this->emplace(p, *first);
@ -1678,7 +1678,7 @@ class stable_vector
BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p) BOOST_NOEXCEPT_OR_NOTHROW BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p) BOOST_NOEXCEPT_OR_NOTHROW
{ {
BOOST_ASSERT(this->priv_in_range(p)); BOOST_ASSERT(this->priv_in_range(p));
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
const size_type d = p - this->cbegin(); const size_type d = p - this->cbegin();
index_iterator it = this->index.begin() + d; index_iterator it = this->index.begin() + d;
this->priv_delete_node(p.node_pointer()); this->priv_delete_node(p.node_pointer());
@ -1697,7 +1697,7 @@ class stable_vector
{ {
BOOST_ASSERT(first == last || BOOST_ASSERT(first == last ||
(first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last))); (first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last)));
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
const const_iterator cbeg(this->cbegin()); const const_iterator cbeg(this->cbegin());
const size_type d1 = static_cast<size_type>(first - cbeg), const size_type d1 = static_cast<size_type>(first - cbeg),
d2 = static_cast<size_type>(last - cbeg); d2 = static_cast<size_type>(last - cbeg);
@ -1733,7 +1733,7 @@ class stable_vector
BOOST_ASSERT(allocator_traits_type::propagate_on_container_swap::value || BOOST_ASSERT(allocator_traits_type::propagate_on_container_swap::value ||
allocator_traits_type::is_always_equal::value || allocator_traits_type::is_always_equal::value ||
this->get_stored_allocator() == x.get_stored_allocator()); this->get_stored_allocator() == x.get_stored_allocator());
STABLE_VECTOR_CHECK_INVARIANT; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag; dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
dtl::swap_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag); dtl::swap_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
//vector's allocator is swapped here //vector's allocator is swapped here
@ -2174,7 +2174,7 @@ stable_vector(InputIterator, InputIterator, Allocator const&) ->
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
#undef STABLE_VECTOR_CHECK_INVARIANT #undef BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT
} //namespace container { } //namespace container {

10
src/dlmalloc_ext_2_8_6.c
View File

@ -791,21 +791,21 @@ static int internal_node_multialloc
/*Error if wrong element_size parameter */ /*Error if wrong element_size parameter */
if (!element_size || if (!element_size ||
/*OR Error if n_elements less than contiguous_elements */ /*OR Error if n_elements less than contiguous_elements */
((contiguous_elements + 1) > (DL_MULTIALLOC_DEFAULT_CONTIGUOUS + 1) && n_elements < contiguous_elements) || ((contiguous_elements + 1) > (BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS + 1) && n_elements < contiguous_elements) ||
/* OR Error if integer overflow */ /* OR Error if integer overflow */
(SQRT_MAX_SIZE_T < (element_req_size | contiguous_elements) && (SQRT_MAX_SIZE_T < (element_req_size | contiguous_elements) &&
(MAX_SIZE_T / element_req_size) < contiguous_elements)) { (MAX_SIZE_T / element_req_size) < contiguous_elements)) {
return 0; return 0;
} }
switch (contiguous_elements) { switch (contiguous_elements) {
case DL_MULTIALLOC_DEFAULT_CONTIGUOUS: case BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS:
{ {
/* Default contiguous, just check that we can store at least one element */ /* Default contiguous, just check that we can store at least one element */
elements_per_segment = INTERNAL_MULTIALLOC_DEFAULT_CONTIGUOUS_MEM / element_req_size; elements_per_segment = INTERNAL_MULTIALLOC_DEFAULT_CONTIGUOUS_MEM / element_req_size;
elements_per_segment += (size_t)(!elements_per_segment); elements_per_segment += (size_t)(!elements_per_segment);
} }
break; break;
case DL_MULTIALLOC_ALL_CONTIGUOUS: case BOOST_CONTAINER_DL_MULTIALLOC_ALL_CONTIGUOUS:
/* All elements should be allocated in a single call */ /* All elements should be allocated in a single call */
elements_per_segment = n_elements; elements_per_segment = n_elements;
break; break;
@ -1002,11 +1002,11 @@ static int internal_multialloc_arrays
max_size = MAX_REQUEST/element_size; max_size = MAX_REQUEST/element_size;
/* Different sizes*/ /* Different sizes*/
switch(contiguous_elements){ switch(contiguous_elements){
case DL_MULTIALLOC_DEFAULT_CONTIGUOUS: case BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS:
/* Use default contiguous mem */ /* Use default contiguous mem */
boost_cont_multialloc_segmented_malloc_size = INTERNAL_MULTIALLOC_DEFAULT_CONTIGUOUS_MEM; boost_cont_multialloc_segmented_malloc_size = INTERNAL_MULTIALLOC_DEFAULT_CONTIGUOUS_MEM;
break; break;
case DL_MULTIALLOC_ALL_CONTIGUOUS: case BOOST_CONTAINER_DL_MULTIALLOC_ALL_CONTIGUOUS:
boost_cont_multialloc_segmented_malloc_size = MAX_REQUEST + CHUNK_OVERHEAD; boost_cont_multialloc_segmented_malloc_size = MAX_REQUEST + CHUNK_OVERHEAD;
break; break;
default: default:

8
test/alloc_full_test.cpp
View File

@ -512,7 +512,7 @@ bool test_many_equal_allocation()
for(int i = 0; i != NumIt/10; ++i){ for(int i = 0; i != NumIt/10; ++i){
dlmalloc_memchain chain; dlmalloc_memchain chain;
BOOST_CONTAINER_MEMCHAIN_INIT(&chain); BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
dlmalloc_multialloc_nodes((i+1)*2, i+1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain); dlmalloc_multialloc_nodes((i+1)*2, i+1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain); dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it)) if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
break; break;
@ -624,7 +624,7 @@ bool test_many_different_allocation()
for(int i = 0; i != NumIt; ++i){ for(int i = 0; i != NumIt; ++i){
dlmalloc_memchain chain; dlmalloc_memchain chain;
BOOST_CONTAINER_MEMCHAIN_INIT(&chain); BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain); dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain); dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it)) if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
break; break;
@ -702,7 +702,7 @@ bool test_many_deallocation()
for(int i = 0; i != NumIt; ++i){ for(int i = 0; i != NumIt; ++i){
dlmalloc_memchain chain; dlmalloc_memchain chain;
BOOST_CONTAINER_MEMCHAIN_INIT(&chain); BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain); dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain); dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it)) if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
return false; return false;
@ -720,7 +720,7 @@ bool test_many_deallocation()
for(int i = 0; i != NumIt; ++i){ for(int i = 0; i != NumIt; ++i){
dlmalloc_memchain chain; dlmalloc_memchain chain;
BOOST_CONTAINER_MEMCHAIN_INIT(&chain); BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
dlmalloc_multialloc_nodes(ArraySize, i*4+1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain); dlmalloc_multialloc_nodes(ArraySize, i*4+1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain); dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it)) if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
return false; return false;

4
test/flat_map_test.cpp
View File

@ -7,8 +7,6 @@
// See http://www.boost.org/libs/container for documentation. // See http://www.boost.org/libs/container for documentation.
// //
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#include <boost/container/detail/config_begin.hpp>
#include <vector> #include <vector>
#include <boost/container/flat_map.hpp> #include <boost/container/flat_map.hpp>
@ -834,5 +832,3 @@ int main()
return 0; return 0;
} }
#include <boost/container/detail/config_end.hpp>

6
test/throw_exception_test.cpp
View File

@ -9,8 +9,6 @@
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#define BOOST_CONTAINER_USER_DEFINED_THROW_CALLBACKS #define BOOST_CONTAINER_USER_DEFINED_THROW_CALLBACKS
#include <boost/container/detail/config_begin.hpp>
#include <boost/container/throw_exception.hpp> #include <boost/container/throw_exception.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
@ -74,7 +72,5 @@ int main()
//Check user-defined throw callbacks are called //Check user-defined throw callbacks are called
throw_bad_alloc(); throw_bad_alloc();
//Never reached //Never reached
std::abort(); return 33;
} }
#include <boost/container/detail/config_end.hpp>