boostorg/container
1
0
Fork 1
mirror of https://github.com/boostorg/container.git synced 2025-08-01 05:24:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Simplify dependencies dropping Boost.Core

Browse Source
This commit is contained in:
Ion Gaztañaga
2023-02-01 23:00:23 +01:00
parent 70f756960e
commit 552688c7fc
35 changed files with 282 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
bench/bench_alloc.cpp
View File

@@ -13,7 +13,6 @@
#endif
#include <boost/container/detail/dlmalloc.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/container/throw_exception.hpp>
#define BOOST_INTERPROCESS_VECTOR_ALLOC_STATS
@@ -63,7 +62,7 @@ void allocation_timing_test(std::size_t num_iterations, std::size_t num_elements
dlmalloc_free(first_mem);
++numalloc;
BOOST_TRY{
BOOST_CONTAINER_TRY{
dlmalloc_command_ret_t ret;
for(size_t e = capacity + 1; e < num_elements; ++e){
size_t received_size;
@@ -101,11 +100,11 @@ void allocation_timing_test(std::size_t num_iterations, std::size_t num_elements
}
dlmalloc_free(addr);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
dlmalloc_free(addr);
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
assert( dlmalloc_allocated_memory() == 0);

9
bench/bench_alloc_expand_bwd.cpp
View File

@@ -13,7 +13,6 @@
#endif
#include <boost/container/allocator.hpp>
#include <boost/core/no_exceptions_support.hpp>
#define BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -114,7 +113,7 @@ void vector_test_template(std::size_t num_iterations, std::size_t num_elements,
bc::vector<MyInt, IntAllocator> v;
v.reset_alloc_stats();
void *first_mem = 0;
BOOST_TRY{
BOOST_CONTAINER_TRY{
first_mem = bc::dlmalloc_malloc(sizeof(MyInt)*num_elements*3/2);
v.push_back(MyInt(0));
bc::dlmalloc_free(first_mem);
@@ -126,11 +125,11 @@ void vector_test_template(std::size_t num_iterations, std::size_t num_elements,
numexpand += v.num_expand_bwd;
capacity = static_cast<std::size_t>(v.capacity());
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
bc::dlmalloc_free(first_mem);
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
assert(bc::dlmalloc_allocated_memory() == 0);

1
bench/bench_set.hpp
View File

@@ -19,7 +19,6 @@
#include <iomanip>
#include <boost/container/vector.hpp>
#include <boost/container/string.hpp>
#include <boost/core/no_exceptions_support.hpp>
using boost::move_detail::cpu_timer;
using boost::move_detail::cpu_times;

1
bench/bench_static_vector.cpp
View File

@@ -16,7 +16,6 @@
#include "varray.hpp"
#include <boost/container/vector.hpp>
#include <boost/container/static_vector.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include "../test/movable_int.hpp"
#include <vector>

25
bench/detail/varray_util.hpp
View File

@@ -18,7 +18,6 @@
#include <limits>
#include <boost/config.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/container/detail/addressof.hpp>
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -251,18 +250,18 @@ O uninitialized_move_dispatch(I first, I last, O dst,
O o = dst;
BOOST_TRY
BOOST_CONTAINER_TRY
{
typedef typename boost::container::iterator_traits<O>::value_type value_type;
for (; first != last; ++first, ++o )
new (boost::container::dtl::addressof(*o)) value_type(boost::move(*first));
}
BOOST_CATCH(...)
BOOST_CONTAINER_CATCH(...)
{
destroy(dst, o);
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return dst;
}
@@ -431,17 +430,17 @@ void uninitialized_fill_dispatch(I first, I last,
typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
I it = first;
BOOST_TRY
BOOST_CONTAINER_TRY
{
for ( ; it != last ; ++it )
new (boost::container::dtl::addressof(*it)) value_type(); // may throw
}
BOOST_CATCH(...)
BOOST_CONTAINER_CATCH(...)
{
destroy(first, it);
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template <typename I, typename DisableTrivialInit>
@@ -600,7 +599,7 @@ inline std::size_t uninitialized_copy_s(I first, I last, F dest, std::size_t max
std::size_t count = 0;
F it = dest;
BOOST_TRY
BOOST_CONTAINER_TRY
{
for ( ; first != last ; ++it, ++first, ++count )
{
@@ -611,12 +610,12 @@ inline std::size_t uninitialized_copy_s(I first, I last, F dest, std::size_t max
construct(0, it, *first); // may throw
}
}
BOOST_CATCH(...)
BOOST_CONTAINER_CATCH(...)
{
destroy(dest, it);
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return count;
}

6
example/doc_custom_devector.cpp
View File

@@ -7,13 +7,9 @@
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/core/no_exceptions_support.hpp>
//[doc_custom_devector
#include <boost/container/devector.hpp>
#include <boost/static_assert.hpp>
/*<-*/
#include <boost/core/no_exceptions_support.hpp>
/*->*/
//Make sure assertions are active
#ifdef NDEBUG
@@ -39,7 +35,7 @@ int main ()
bool exception_thrown = false;
/*<-*/
#ifndef BOOST_NO_EXCEPTIONS
BOOST_TRY{ size_optimized_devector_t v(256); } BOOST_CATCH(...){ exception_thrown = true; } BOOST_CATCH_END
BOOST_CONTAINER_TRY{ size_optimized_devector_t v(256); } BOOST_CONTAINER_CATCH(...){ exception_thrown = true; } BOOST_CONTAINER_CATCH_END
#else
exception_thrown = true;
#endif //BOOST_NO_EXCEPTIONS

4
example/doc_custom_vector.cpp
View File

@@ -7,11 +7,9 @@
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/core/no_exceptions_support.hpp>
//[doc_custom_vector
#include <boost/container/vector.hpp>
#include <boost/static_assert.hpp>
#include <boost/core/no_exceptions_support.hpp>
//Make sure assertions are active
#ifdef NDEBUG
@@ -36,7 +34,7 @@ int main ()
bool exception_thrown = false;
/*<-*/
#ifndef BOOST_NO_EXCEPTIONS
BOOST_TRY{ size_optimized_vector_t v(256); } BOOST_CATCH(...){ exception_thrown = true; } BOOST_CATCH_END
BOOST_CONTAINER_TRY{ size_optimized_vector_t v(256); } BOOST_CONTAINER_CATCH(...){ exception_thrown = true; } BOOST_CONTAINER_CATCH_END
#else
exception_thrown = true;
#endif //BOOST_NO_EXCEPTIONS

65
include/boost/container/deque.hpp
View File

@@ -50,7 +50,6 @@
#include <boost/move/detail/move_helpers.hpp>
// other
#include <boost/assert.hpp>
#include <boost/core/no_exceptions_support.hpp>
// std
#include <cstddef>
@@ -434,16 +433,16 @@ class deque_base
ptr_alloc_ptr nstart = this->members_.m_map + difference_type(this->members_.m_map_size - num_nodes) / 2;
ptr_alloc_ptr nfinish = nstart + difference_type(num_nodes);
BOOST_TRY {
BOOST_CONTAINER_TRY {
this->priv_create_nodes(nstart, nfinish);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
this->members_.m_map = 0;
this->members_.m_map_size = 0;
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
this->members_.m_start.priv_set_node(nstart, get_block_size());
this->members_.m_finish.priv_set_node(nfinish - 1, get_block_size());
@@ -455,15 +454,15 @@ class deque_base
void priv_create_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish)
{
ptr_alloc_ptr cur = nstart;
BOOST_TRY {
BOOST_CONTAINER_TRY {
for (; cur < nfinish; ++cur)
*cur = this->priv_allocate_node();
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->priv_destroy_nodes(nstart, cur);
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW
@@ -2123,15 +2122,15 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
const size_type raw_gap = n - elemsafter;
::boost::container::uninitialized_move_alloc
(this->alloc(), pos, old_finish, old_finish + difference_type(raw_gap));
BOOST_TRY{
BOOST_CONTAINER_TRY{
proxy.copy_n_and_update(this->alloc(), pos, elemsafter);
proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->priv_destroy_range(old_finish, old_finish + difference_type(elemsafter));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
this->members_.m_finish = new_finish;
}
}
@@ -2176,7 +2175,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
void priv_fill_initialize(const value_type& value)
{
index_pointer cur = this->members_.m_start.m_node;
BOOST_TRY {
BOOST_CONTAINER_TRY {
for ( ; cur < this->members_.m_finish.m_node; ++cur){
boost::container::uninitialized_fill_alloc
(this->alloc(), *cur, *cur + get_block_ssize(), value);
@@ -2184,26 +2183,26 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
boost::container::uninitialized_fill_alloc
(this->alloc(), this->members_.m_finish.m_first, this->members_.m_finish.m_cur, value);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->priv_destroy_range(this->members_.m_start, iterator(*cur, cur, get_block_size()));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template <class InIt>
void priv_range_initialize(InIt first, InIt last, typename iterator_enable_if_tag<InIt, std::input_iterator_tag>::type* =0)
{
this->priv_initialize_map(0);
BOOST_TRY {
BOOST_CONTAINER_TRY {
for ( ; first != last; ++first)
this->emplace_back(*first);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->clear();
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template <class FwdIt>
@@ -2214,7 +2213,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
this->priv_initialize_map(n);
index_pointer cur_node = this->members_.m_start.m_node;
BOOST_TRY {
BOOST_CONTAINER_TRY {
for (; cur_node < this->members_.m_finish.m_node; ++cur_node) {
FwdIt mid = first;
boost::container::iterator_uadvance(mid, get_block_size());
@@ -2223,11 +2222,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
}
::boost::container::uninitialized_copy_alloc(this->alloc(), first, last, this->members_.m_finish.m_first);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->priv_destroy_range(this->members_.m_start, iterator(*cur_node, cur_node, get_block_size()));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
// Called only if this->members_.m_finish.m_cur == this->members_.m_finish.m_first.
@@ -2268,16 +2267,16 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
this->priv_reallocate_map(new_nodes, true);
}
size_type i = 1;
BOOST_TRY {
BOOST_CONTAINER_TRY {
for (; i <= new_nodes; ++i)
*(this->members_.m_start.m_node - difference_type(i)) = this->priv_allocate_node();
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
for (size_type j = 1; j < i; ++j)
this->priv_deallocate_node(*(this->members_.m_start.m_node - difference_type(j)));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
return this->members_.m_start - difference_type(n);
}
@@ -2293,16 +2292,16 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
this->priv_reallocate_map(new_nodes, false);
}
size_type i = 1;
BOOST_TRY {
BOOST_CONTAINER_TRY {
for (; i <= new_nodes; ++i)
*(this->members_.m_finish.m_node + difference_type(i)) = this->priv_allocate_node();
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
for (size_type j = 1; j < i; ++j)
this->priv_deallocate_node(*(this->members_.m_finish.m_node + difference_type(j)));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
return this->members_.m_finish + difference_type(n);
}

9
include/boost/container/detail/adaptive_node_pool_impl.hpp
View File

@@ -42,7 +42,6 @@
#include <boost/intrusive/slist.hpp>
// other
#include <boost/assert.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <cstddef>
namespace boost {
@@ -760,7 +759,7 @@ class private_adaptive_node_pool_impl_common
, const size_type real_num_node, const size_type num_subblocks)
{
size_type i = 0;
BOOST_TRY{
BOOST_CONTAINER_TRY{
this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
while(i != n){
//If there are no free nodes we allocate all needed blocks
@@ -800,12 +799,12 @@ class private_adaptive_node_pool_impl_common
i += num_elems;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
}

17
include/boost/container/detail/advanced_insert_int.hpp
View File

@@ -41,7 +41,6 @@
#include <boost/move/detail/force_ptr.hpp>
// other
#include <boost/assert.hpp>
#include <boost/core/no_exceptions_support.hpp>
namespace boost { namespace container { namespace dtl {
@@ -315,14 +314,14 @@ struct insert_emplace_proxy
typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(get<IdxPack>(this->args_))...);
value_type *vp = move_detail::force_ptr<value_type *>(&v);
BOOST_TRY{
BOOST_CONTAINER_TRY{
*p = ::boost::move(*vp);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
alloc_traits::destroy(a, vp);
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
alloc_traits::destroy(a, vp);
}
};
@@ -438,14 +437,14 @@ struct insert_emplace_proxy_arg##N\
typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
value_type *vp = move_detail::force_ptr<value_type *>(&v);\
BOOST_TRY{\
BOOST_CONTAINER_TRY{\
*p = ::boost::move(*vp);\
}\
BOOST_CATCH(...){\
BOOST_CONTAINER_CATCH(...){\
alloc_traits::destroy(a, vp);\
BOOST_RETHROW\
BOOST_CONTAINER_RETHROW\
}\
BOOST_CATCH_END\
BOOST_CONTAINER_CATCH_END\
alloc_traits::destroy(a, vp);\
}\
};\

9
include/boost/container/detail/allocator_version_traits.hpp
View File

@@ -29,7 +29,6 @@
#include <boost/container/detail/allocation_type.hpp> //allocation_type
#include <boost/container/detail/mpl.hpp> //integral_constant
#include <boost/intrusive/pointer_traits.hpp> //pointer_traits
#include <boost/core/no_exceptions_support.hpp> //BOOST_TRY
namespace boost {
namespace container {
@@ -139,15 +138,15 @@ struct allocator_version_traits<Allocator, 1>
throw_logic_error("version 1 allocator without allocate_new flag");
}
else{
BOOST_TRY{
BOOST_CONTAINER_TRY{
ret = a.allocate(prefer_in_recvd_out_size);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
if(!(command & nothrow_allocation)){
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
reuse = pointer();
}
return ret;

81
include/boost/container/detail/copy_move_algo.hpp
View File

@@ -34,7 +34,6 @@
#include <boost/move/utility_core.hpp>
#include <boost/move/traits.hpp>
// other
#include <boost/core/no_exceptions_support.hpp>
#include <boost/assert.hpp>
// std
#include <cstring> //for memmove/memcpy
@@ -351,19 +350,19 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
uninitialized_move_alloc(Allocator &a, I f, I l, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (f != l) {
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return r;
}
@@ -396,20 +395,20 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
uninitialized_move_alloc_n(Allocator &a, I f, std::size_t n, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (n) {
--n;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return r;
}
@@ -442,20 +441,20 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
uninitialized_move_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (n) {
--n;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return f;
}
@@ -488,19 +487,19 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
uninitialized_copy_alloc(Allocator &a, I f, I l, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (f != l) {
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
++f; ++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return r;
}
@@ -533,20 +532,20 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
uninitialized_copy_alloc_n(Allocator &a, I f, std::size_t n, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (n) {
--n;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
++f; ++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return r;
}
@@ -579,19 +578,19 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
uninitialized_copy_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (n) {
boost::container::construct_in_place(a, boost::movelib::iterator_to_raw_pointer(r), f);
++f; ++r; --n;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return f;
}
@@ -623,20 +622,20 @@ inline typename dtl::disable_if_memzero_initializable<F, F>::type
uninitialized_value_init_alloc_n(Allocator &a, std::size_t n, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (n) {
--n;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r));
++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return r;
}
@@ -675,20 +674,20 @@ template
inline F uninitialized_default_init_alloc_n(Allocator &a, std::size_t n, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (n) {
--n;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), default_init);
++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return r;
}
@@ -712,19 +711,19 @@ template
inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
{
F back = f;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (f != l) {
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(f), t);
++f;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != l; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
@@ -748,20 +747,20 @@ template
inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, std::size_t n, F r)
{
F back = r;
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (n) {
--n;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), v);
++r;
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
for (; back != r; ++back){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return r;
}

66
include/boost/container/detail/dispatch_uses_allocator.hpp
View File

@@ -33,8 +33,6 @@
#endif
#include <boost/move/utility_core.hpp>
#include <boost/core/no_exceptions_support.hpp>
namespace boost { namespace container {
namespace dtl {
@@ -228,14 +226,14 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MO
, Pair* p)
{
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first));
BOOST_TRY{
BOOST_CONTAINER_TRY{
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second));
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
@@ -249,14 +247,14 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MO
, Pair* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y)
{
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<U>(x));
BOOST_TRY{
BOOST_CONTAINER_TRY{
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<V>(y));
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template < typename ConstructAlloc
@@ -296,15 +294,15 @@ typename dtl::enable_if< dtl::is_pair<Pair> BOOST_MOVE_I void>::type\
(void)p; (void)q;\
dispatch_uses_allocator\
(construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_TMPL_GET##N);\
BOOST_TRY{\
BOOST_CONTAINER_TRY{\
dispatch_uses_allocator\
(construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_TMPL_GETQ##M);\
}\
BOOST_CATCH(...) {\
BOOST_CONTAINER_CATCH(...) {\
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
BOOST_RETHROW\
BOOST_CONTAINER_RETHROW\
}\
BOOST_CATCH_END\
BOOST_CONTAINER_CATCH_END\
}\
//
BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BOOST_TUPLE_CODE)
@@ -320,14 +318,14 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
{
(void)t1; (void)t2;
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(pair->first), ::boost::forward<Args1>(get<Indexes1>(t1))...);
BOOST_TRY{
BOOST_CONTAINER_TRY{
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(pair->second), ::boost::forward<Args2>(get<Indexes2>(t2))...);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template< typename ConstructAlloc, typename ArgAlloc, class Pair
@@ -356,15 +354,15 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
(void)p; (void)q;\
dispatch_uses_allocator\
(construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
BOOST_TRY{\
BOOST_CONTAINER_TRY{\
dispatch_uses_allocator\
(construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
}\
BOOST_CATCH(...) {\
BOOST_CONTAINER_CATCH(...) {\
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
BOOST_RETHROW\
BOOST_CONTAINER_RETHROW\
}\
BOOST_CATCH_END\
BOOST_CONTAINER_CATCH_END\
}\
//
BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_MSVC2010_TUPLE_CODE)
@@ -391,15 +389,15 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
(void)p; (void)q;\
dispatch_uses_allocator\
(construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
BOOST_TRY{\
BOOST_CONTAINER_TRY{\
dispatch_uses_allocator\
(construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
}\
BOOST_CATCH(...) {\
BOOST_CONTAINER_CATCH(...) {\
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
BOOST_RETHROW\
BOOST_CONTAINER_RETHROW\
}\
BOOST_CATCH_END\
BOOST_CONTAINER_CATCH_END\
}\
//
BOOST_MOVE_ITER2D_0TOMAX(BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_MAX_IT, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_CODE)
@@ -418,14 +416,14 @@ typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
(ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args)
{
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));
BOOST_TRY{
BOOST_CONTAINER_TRY{
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<Args>(args)...);
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
#else
@@ -439,14 +437,14 @@ typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
{\
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));\
BOOST_TRY{\
BOOST_CONTAINER_TRY{\
dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
}\
BOOST_CATCH(...) {\
BOOST_CONTAINER_CATCH(...) {\
allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));\
BOOST_RETHROW\
BOOST_CONTAINER_RETHROW\
}\
BOOST_CATCH_END\
BOOST_CONTAINER_CATCH_END\
}\
//
BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE_CODE)

60
include/boost/container/detail/mutex.hpp
View File

@@ -30,6 +30,8 @@
// Extremely Light-Weight wrapper classes for OS thread synchronization
#define BOOST_MUTEX_HELPER_NONE 0
#define BOOST_MUTEX_HELPER_WIN32 1
#define BOOST_MUTEX_HELPER_PTHREAD 2
@@ -50,14 +52,6 @@
defined(__i386__) || defined(__x86_64__))) || \
(defined(_MSC_VER) && _MSC_VER>=1310))
#define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_SPINLOCKS
#endif
#if defined(BOOST_WINDOWS)
#include <boost/winapi/critical_section.hpp>
#include <boost/winapi/thread.hpp>
#ifndef BOOST_MUTEX_HELPER
#define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_WIN32
#endif
#elif defined(BOOST_HAS_UNISTD_H)
#include <unistd.h>
#if !defined(BOOST_MUTEX_HELPER) && (defined(_POSIX_THREADS) || defined(BOOST_HAS_PTHREADS))
@@ -74,11 +68,9 @@
//...
#elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_SPINLOCKS
#if defined(_MSC_VER)
#include <boost/detail/interlocked.hpp>
#define interlockedcompareexchange _InterlockedCompareExchange
#include <intrin.h>
#define interlockedexchange _InterlockedExchange
#elif defined(WIN32) && defined(__GNUC__)
#define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)
#define interlockedexchange __sync_lock_test_and_set
#endif /* Win32 */
@@ -123,8 +115,52 @@
/* How to yield for a spin lock */
#define SPINS_PER_YIELD 63
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
#if !defined( BOOST_USE_WINDOWS_H )
#if defined (WIN32_PLATFORM_PSPC)
#define BOOST_CONTAINERWINAPI_IMPORT BOOST_SYMBOL_IMPORT
#elif defined (_WIN32_WCE)
#define BOOST_CONTAINERWINAPI_IMPORT
#else
#define BOOST_CONTAINERWINAPI_IMPORT BOOST_SYMBOL_IMPORT
#endif
#if defined(WINAPI)
#define BOOST_CONTAINERWINAPI_WINAPI_CC WINAPI
#else
#if defined(_M_IX86) || defined(__i386__)
#define BOOST_CONTAINERWINAPI_DETAIL_STDCALL __stdcall
#else
#define BOOST_CONTAINERWINAPI_DETAIL_STDCALL
#endif
#define BOOST_CONTAINERWINAPI_WINAPI_CC BOOST_CONTAINERWINAPI_DETAIL_STDCALL
#endif
#if !defined(__LP64__)
namespace boost {
namespace container_winapi {
typedef unsigned long DWORD_;
#else
typedef unsigned int DWORD_;
#endif
typedef int BOOL_;
}}
extern "C" {
BOOST_CONTAINERWINAPI_IMPORT boost::container_winapi::DWORD_ BOOST_CONTAINERWINAPI_WINAPI_CC
SleepEx(
boost::container_winapi::DWORD_ dwMilliseconds,
boost::container_winapi::BOOL_ bAlertable);
} // extern "C"
#endif
namespace boost {
namespace container_winapi {
using ::SleepEx;
}
}
#define SLEEP_EX_DURATION 50 /* delay for yield/sleep */
#define SPIN_LOCK_YIELD boost::winapi::SleepEx(SLEEP_EX_DURATION, 0)
#define SPIN_LOCK_YIELD boost::container_winapi::SleepEx(SLEEP_EX_DURATION, 0)
#elif defined (__SVR4) && defined (__sun) /* solaris */
#include <thread.h>
#define SPIN_LOCK_YIELD thr_yield();

26
include/boost/container/detail/node_alloc_holder.hpp
View File

@@ -45,8 +45,6 @@
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <boost/move/detail/fwd_macros.hpp>
#endif
// other
#include <boost/core/no_exceptions_support.hpp>
namespace boost {
@@ -417,26 +415,26 @@ struct node_alloc_holder
NodePtr create_node_from_key(BOOST_FWD_REF(KeyConvertible) key)
{
NodePtr p = this->allocate_one();
BOOST_TRY{
BOOST_CONTAINER_TRY{
::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) Node;
NodeAlloc &na = this->node_alloc();
node_allocator_traits_type::construct
(na, dtl::addressof(p->get_real_data().first), boost::forward<KeyConvertible>(key));
BOOST_TRY{
BOOST_CONTAINER_TRY{
node_allocator_traits_type::construct(na, dtl::addressof(p->get_real_data().second));
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
node_allocator_traits_type::destroy(na, dtl::addressof(p->get_real_data().first));
BOOST_RETHROW;
BOOST_CONTAINER_RETHROW;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
p->destroy_header();
this->node_alloc().deallocate(p, 1);
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return (p);
}
@@ -470,7 +468,7 @@ struct node_alloc_holder
chain.clear();
Node *p = 0;
BOOST_TRY{
BOOST_CONTAINER_TRY{
Deallocator node_deallocator(NodePtr(), nalloc);
dtl::scoped_node_destructor<NodeAlloc> sdestructor(nalloc, 0);
while(n){
@@ -490,12 +488,12 @@ struct node_alloc_holder
sdestructor.release();
node_deallocator.release();
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
chain.incorporate_after(chain.last(), &*itbeg, &*itlast, n);
node_allocator_version_traits_type::deallocate_individual(this->node_alloc(), chain);
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
}

9
include/boost/container/detail/node_pool_impl.hpp
View File

@@ -33,7 +33,6 @@
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/slist.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/assert.hpp>
#include <cstddef>
@@ -310,7 +309,7 @@ class private_node_pool_impl
size_type blocksize =
(get_rounded_size)(m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);
BOOST_TRY{
BOOST_CONTAINER_TRY{
for(size_type i = 0; i != num_blocks; ++i){
//We allocate a new NodeBlock and put it as first
//element in the free Node list
@@ -326,11 +325,11 @@ class private_node_pool_impl
}
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
//to-do: if possible, an efficient way to deallocate allocated blocks
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
//!Deprecated, use deallocate_free_blocks

10
include/boost/container/detail/tree.hpp
View File

@@ -53,8 +53,6 @@
#endif
#include <boost/move/detail/move_helpers.hpp>
#include <boost/move/detail/force_ptr.hpp>
// other
#include <boost/core/no_exceptions_support.hpp>
@@ -311,20 +309,20 @@ class RecyclingCloner
{
if(node_ptr_type p = m_icont.unlink_leftmost_without_rebalance()){
//First recycle a node (this can't throw)
BOOST_TRY{
BOOST_CONTAINER_TRY{
//This can throw
this->do_assign(p, other, bool_<DoMove>());
return p;
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
//If there is an exception destroy the whole source
m_holder.destroy_node(p);
while((p = m_icont.unlink_leftmost_without_rebalance())){
m_holder.destroy_node(p);
}
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
else{
return m_holder.create_node(boost::move(other.get_real_data()));

25
include/boost/container/detail/workaround.hpp
View File

@@ -161,5 +161,30 @@ BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore(T1 const&)
}} //namespace boost::container {
#if !(defined BOOST_NO_EXCEPTIONS)
# define BOOST_CONTAINER_TRY { try
# define BOOST_CONTAINER_CATCH(x) catch(x)
# define BOOST_CONTAINER_RETHROW throw;
# define BOOST_CONTAINER_CATCH_END }
#else
# if !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
# define BOOST_CONTAINER_TRY { if (true)
# define BOOST_CONTAINER_CATCH(x) else if (false)
# else
// warning C4127: conditional expression is constant
# define BOOST_CONTAINER_TRY { \
__pragma(warning(push)) \
__pragma(warning(disable: 4127)) \
if (true) \
__pragma(warning(pop))
# define BOOST_CONTAINER_CATCH(x) else \
__pragma(warning(push)) \
__pragma(warning(disable: 4127)) \
if (false) \
__pragma(warning(pop))
# endif
# define BOOST_CONTAINER_RETHROW
# define BOOST_CONTAINER_CATCH_END }
#endif
#endif //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

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

@@ -48,8 +48,6 @@
#include <boost/move/algo/detail/merge.hpp>
#include <boost/move/detail/force_ptr.hpp>
#include <boost/type_traits/is_nothrow_move_constructible.hpp>
//std
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list> //for std::initializer_list
@@ -348,17 +346,17 @@ class devector
)
: m_(allocator)
{
BOOST_TRY{
BOOST_CONTAINER_TRY{
while (first != last) {
this->emplace_back(*first++);
}
BOOST_ASSERT(invariants_ok());
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
this->destroy_elements(m_.buffer + m_.front_idx, m_.buffer + m_.back_idx);
this->deallocate_buffer();
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

2
include/boost/container/flat_map.hpp
View File

@@ -43,8 +43,6 @@
// intrusive
#include <boost/intrusive/detail/minimal_pair_header.hpp> //pair
#include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal
//others
#include <boost/core/no_exceptions_support.hpp>
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list>

1
include/boost/container/map.hpp
View File

@@ -46,7 +46,6 @@
#include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal
// other
#include <boost/static_assert.hpp>
#include <boost/core/no_exceptions_support.hpp>
// std
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list>

19
include/boost/container/node_handle.hpp
View File

@@ -30,7 +30,7 @@
#include <boost/move/utility_core.hpp>
#include <boost/move/adl_move_swap.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/container/detail/mpl.hpp>
#include <boost/assert.hpp>
@@ -112,15 +112,16 @@ class node_handle
BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle)
typedef typename nator_traits::pointer node_pointer;
typedef ::boost::aligned_storage
typedef typename dtl::aligned_storage
< sizeof(nallocator_type)
, boost::alignment_of<nallocator_type>::value> nalloc_storage_t;
, dtl::alignment_of<nallocator_type>::value
>::type nalloc_storage_t;
node_pointer m_ptr;
nalloc_storage_t m_nalloc_storage;
void move_construct_alloc(nallocator_type &al)
{ ::new(m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(al)); }
{ ::new((void*)m_nalloc_storage.data, boost_container_new_t()) nallocator_type(::boost::move(al)); }
void destroy_deallocate_node()
{
@@ -132,7 +133,7 @@ class node_handle
void move_construct_end(OtherNodeHandle &nh)
{
if(m_ptr){
::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(nh.node_alloc()));
::new ((void*)m_nalloc_storage.data, boost_container_new_t()) nallocator_type(::boost::move(nh.node_alloc()));
node_handle_friend::destroy_alloc(nh);
node_handle_friend::get_node_pointer(nh) = node_pointer();
}
@@ -140,7 +141,7 @@ class node_handle
}
void destroy_alloc() BOOST_NOEXCEPT
{ static_cast<nallocator_type*>(m_nalloc_storage.address())->~nallocator_type(); }
{ static_cast<nallocator_type*>((void*)m_nalloc_storage.data)->~nallocator_type(); }
node_pointer &get_node_pointer() BOOST_NOEXCEPT
{ return m_ptr; }
@@ -161,7 +162,7 @@ class node_handle
: m_ptr(p)
{
if(m_ptr){
::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(al);
::new ((void*)m_nalloc_storage.data, boost_container_new_t()) nallocator_type(al);
}
}
@@ -374,7 +375,7 @@ class node_handle
nallocator_type &node_alloc() BOOST_NOEXCEPT
{
BOOST_ASSERT(!empty());
return *static_cast<nallocator_type*>(m_nalloc_storage.address());
return *static_cast<nallocator_type*>((void*)m_nalloc_storage.data);
}
@@ -384,7 +385,7 @@ class node_handle
const nallocator_type &node_alloc() const BOOST_NOEXCEPT
{
BOOST_ASSERT(!empty());
return *static_cast<const nallocator_type*>(m_nalloc_storage.address());
return *static_cast<const nallocator_type*>((const void*)m_nalloc_storage.data);
}
//! <b>Effects</b>: x.swap(y).

2
include/boost/container/scoped_allocator.hpp
View File

@@ -38,8 +38,6 @@
#endif
#include <boost/move/utility_core.hpp>
#include <boost/core/no_exceptions_support.hpp>
namespace boost { namespace container {
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

2
include/boost/container/slist.hpp
View File

@@ -48,8 +48,6 @@
#endif
#include <boost/move/detail/move_helpers.hpp>
#include <boost/move/detail/force_ptr.hpp>
// other
#include <boost/core/no_exceptions_support.hpp>
// std
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list>

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

@@ -60,7 +60,6 @@
#include <boost/move/detail/iterator_to_raw_pointer.hpp>
// other
#include <boost/assert.hpp>
#include <boost/core/no_exceptions_support.hpp>
// std
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list>
@@ -2091,38 +2090,38 @@ class stable_vector
{
node_type *praw = ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t())
node_type(index_traits_type::ptr_to_node_base_ptr(*up_index));
BOOST_TRY{
BOOST_CONTAINER_TRY{
//This can throw
boost::container::construct_in_place
( this->priv_node_alloc()
, praw->get_data_ptr()
, it);
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
praw->destroy_header();
this->priv_node_alloc().deallocate(p, 1);
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template<class ValueConvertible>
void priv_build_node_from_convertible(const node_ptr &p, BOOST_FWD_REF(ValueConvertible) value_convertible)
{
node_type *praw = ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) node_type;
BOOST_TRY{
BOOST_CONTAINER_TRY{
//This can throw
boost::container::allocator_traits<node_allocator_type>::construct
( this->priv_node_alloc()
, p->get_data_ptr()
, ::boost::forward<ValueConvertible>(value_convertible));
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
praw->destroy_header();
this->priv_node_alloc().deallocate(p, 1);
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
void priv_swap_members(stable_vector &x)

23
include/boost/container/string.hpp
View File

@@ -50,7 +50,6 @@
#include <boost/move/traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <iosfwd>
#include <istream> //
@@ -2969,7 +2968,7 @@ class basic_string
const size_type long_size = this->priv_long_size();
const size_type long_storage = this->priv_long_storage();
//We can make this nothrow as chars are always NoThrowCopyables
BOOST_TRY{
BOOST_CONTAINER_TRY{
pointer reuse = 0;
real_cap = long_size+1;
const pointer ret = this->allocation_command(allocate_new, long_size+1, real_cap, reuse);
@@ -2982,10 +2981,10 @@ class basic_string
//And release old buffer
this->alloc().deallocate(long_addr, long_storage);
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
return;
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template<class AllocVersion>
@@ -3015,20 +3014,20 @@ class basic_string
//Save initial position
FwdIt init = first;
BOOST_TRY{
BOOST_CONTAINER_TRY{
//Construct objects
for (; count--; ++first){
this->construct(first, val);
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
//Call destructors
for (; init != first; ++init){
this->destroy(init);
}
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
}
template<class InpIt, class FwdIt> inline
@@ -3038,20 +3037,20 @@ class basic_string
FwdIt dest_init = dest;
size_type constructed = 0;
BOOST_TRY{
BOOST_CONTAINER_TRY{
//Try to build objects
for (; first != last; ++dest, ++first, ++constructed){
this->construct(dest, *first);
}
}
BOOST_CATCH(...){
BOOST_CONTAINER_CATCH(...){
//Call destructors
for (; constructed--; ++dest_init){
this->destroy(dest_init);
}
BOOST_RETHROW
BOOST_CONTAINER_RETHROW
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
return (constructed);
}

1
include/boost/container/vector.hpp
View File

@@ -62,7 +62,6 @@
#include <boost/move/algo/predicate.hpp>
#include <boost/move/algo/detail/set_difference.hpp>
// other
#include <boost/core/no_exceptions_support.hpp>
#include <boost/assert.hpp>
#include <boost/cstdint.hpp>

1
src/global_resource.cpp
View File

@@ -11,7 +11,6 @@
#define BOOST_CONTAINER_SOURCE
#include <boost/container/pmr/memory_resource.hpp>
#include <boost/container/pmr/global_resource.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/container/throw_exception.hpp>
#include <boost/container/detail/dlmalloc.hpp> //For global lock
#include <boost/container/detail/singleton.hpp>

1
test/deque_test.cpp
View File

@@ -28,7 +28,6 @@
#include "propagate_allocator_test.hpp"
#include "vector_test.hpp"
#include "default_init_test.hpp"
#include <boost/core/no_exceptions_support.hpp>
#include "../../intrusive/test/iterator_test.hpp"
using namespace boost::container;

7
test/devector_test.cpp
View File

@@ -18,7 +18,6 @@
#include <boost/container/list.hpp>
#include <boost/container/allocator.hpp>
#include <boost/container/vector.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/type_traits/is_default_constructible.hpp>
#include <boost/type_traits/is_nothrow_move_constructible.hpp>
#include "dummy_test_allocator.hpp"
@@ -636,13 +635,13 @@ template <class Devector> void test_il_assignment()
test_elem_throw::on_copy_after(3);
BOOST_TRY
BOOST_CONTAINER_TRY
{
a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
BOOST_TEST(false);
}
BOOST_CATCH(const test_exception&) {}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH(const test_exception&) {}
BOOST_CONTAINER_CATCH_END
test_elem_throw::do_not_throw();
test_equal_range(a, {1, 2, 3, 4, 5, 6});

9
test/global_resource_test.cpp
View File

@@ -10,7 +10,6 @@
#include <boost/container/pmr/global_resource.hpp>
#include <boost/container/pmr/memory_resource.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include "derived_from_memory_resource.hpp"
@@ -91,15 +90,15 @@ void test_null_memory_resource()
#if !defined(BOOST_NO_EXCEPTIONS)
bool bad_allocexception_thrown = false;
BOOST_TRY{
BOOST_CONTAINER_TRY{
mr->allocate(1, 1);
}
BOOST_CATCH(std::bad_alloc&) {
BOOST_CONTAINER_CATCH(std::bad_alloc&) {
bad_allocexception_thrown = true;
}
BOOST_CATCH(...) {
BOOST_CONTAINER_CATCH(...) {
}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
BOOST_TEST(bad_allocexception_thrown == true);
#endif //BOOST_NO_EXCEPTIONS

1
test/memory_resource_test.cpp
View File

@@ -9,7 +9,6 @@
//////////////////////////////////////////////////////////////////////////////
#include <boost/container/pmr/memory_resource.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include "derived_from_memory_resource.hpp"
#include <cstdlib>

17
test/static_vector_options_test.cpp
View File

@@ -10,7 +10,6 @@
#define BOOST_ENABLE_ASSERT_HANDLER
#include <boost/container/static_vector.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <new> //for bad_alloc
#include <boost/assert.hpp>
#include <cstdlib>
@@ -87,16 +86,16 @@ void test_throw_on_overflow()
v.resize(Capacity);
bool expected_type_thrown = false;
BOOST_TRY{
BOOST_CONTAINER_TRY{
v.push_back(0);
}
BOOST_CATCH(bad_alloc_t&)
BOOST_CONTAINER_CATCH(bad_alloc_t&)
{
expected_type_thrown = true;
}
BOOST_CATCH(...)
BOOST_CONTAINER_CATCH(...)
{}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
BOOST_TEST(expected_type_thrown == true);
BOOST_TEST(v.capacity() == Capacity);
@@ -115,16 +114,16 @@ void test_throw_on_overflow()
v.resize(Capacity);
bool expected_type_thrown = false;
BOOST_TRY{
BOOST_CONTAINER_TRY{
v.push_back(0);
}
BOOST_CATCH(throw_on_overflow_off)
BOOST_CONTAINER_CATCH(throw_on_overflow_off)
{
expected_type_thrown = true;
}
BOOST_CATCH(...)
BOOST_CONTAINER_CATCH(...)
{}
BOOST_CATCH_END
BOOST_CONTAINER_CATCH_END
BOOST_TEST(expected_type_thrown == true);
BOOST_TEST(v.capacity() == Capacity);

1
test/static_vector_test.cpp
View File

@@ -8,7 +8,6 @@
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/core/lightweight_test.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/container/vector.hpp>
#include <boost/container/list.hpp>
#include <boost/container/detail/iterator.hpp>

1
test/vector_test.hpp
View File

@@ -22,7 +22,6 @@
#include <boost/move/utility_core.hpp>
#include <boost/move/iterator.hpp>
#include <boost/move/make_unique.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/static_assert.hpp>
#include "print_container.hpp"