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

Refactor advanced insertion algorithms and implement a new devector insert strategy, moving elements to the middle if there is a reasonable free capacity at the other end of the container.

Browse Source
This commit is contained in:
Ion Gaztañaga
2022-09-20 00:22:19 +02:00
parent 8b27fefb8e
commit 704bf10058
13 changed files with 2574 additions and 1934 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
bench/bench_vectors.cpp
View File

@@ -319,8 +319,7 @@ void test_vectors()
vector_test_template< bc::vector<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i] , "vector ", bp);
vector_test_template< bc::small_vector<MyInt, 0, std::allocator<MyInt> >, Operation >(numit[i], numele[i], "small_vector ", bp);
vector_test_template< bc::devector<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], "devector ", bp);
vector_test_template< std::deque<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], "std::deque ", bp);
//vector_test_template< std::deque<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], "std::deque ", bp);
vector_test_template< bc::deque<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], "deque ", bp);
}
std::cout << "---------------------------------\n---------------------------------\n";

22
doc/container.qbk
View File

@@ -468,7 +468,7 @@ while also providing the regular features of `vector`, in particular the contigu
Unlike `vector`, devector can have free capacity both before and after the elements. This enables efficient
implementation of methods that modify the devector at the front. In general, `devector`'s available methods
are a superset of those of `vector` with identical behaviour, barring a couple of iterator invalidation
are a superset of those of `vector` with similar behaviour, barring a couple of iterator invalidation
guarantees that differ.
The overhead for devector is one extra `size_t` per container: Usually sizeof(devector) == 4*sizeof(T*).
@@ -697,8 +697,8 @@ the last template parameter and defined using the utility class
A higher growth factor will make it faster as it will require less data movement, but it will have a greater memory
impact (on average, more memory will be unused). A user can provide a custom implementation of the growth factor and some
predefined policies are available: [classref boost::container::growth_factor_50 growth_factor_50],
[classref boost::container::growth_factor_60 growth_factor_60] and
[classref boost::container::growth_factor_50 growth_factor_100].
[classref boost::container::growth_factor_60 growth_factor_60] (usually the default) and
[classref boost::container::growth_factor_100 growth_factor_100].
* [classref boost::container::stored_size stored_size]: the type that will be used to store size-related
parameters inside of the vector. Sometimes, when the maximum capacity to be used is much less than the
@@ -706,6 +706,9 @@ the last template parameter and defined using the utility class
`size()` and `capacity()` inside vector, so that the size of an empty vector is minimized and cache
performance might be improved. See [classref boost::container::stored_size stored_size] for more details.
* [classref boost::container::devector devector] supports an addicional [classref boost::container::relocation_limit relocation_limit]
options to control container's behaviour when back or front free capacity is exhausted.
See the following example to see how [classref boost::container::vector_options vector_options] can be
used to customize `vector` container:
@@ -1323,8 +1326,8 @@ use [*Boost.Container]? There are several reasons for that:
* `static_vector` was based on Andrew Hundt's and Adam Wulkiewicz's high-performance `varray` class.
Many performance improvements of `vector` were also inspired by their implementation. Thanks!
* `devector` is based on Thaler Benedek's high-performance `devector` implementation, then
adapted for [*Boost.Container]. Also inspired by similar implemenations by Orson Peters and Lars Hagen.
* `devector`'s initial implementation is based on Thaler Benedek's high-performance `devector` implementation,
then adapted for [*Boost.Container]. Also inspired by similar implemenations by Orson Peters and Lars Hagen.
Thanks for such a great code and documentation!
* Howard Hinnant's help and advices were essential when implementing move semantics,
@@ -1338,6 +1341,15 @@ use [*Boost.Container]? There are several reasons for that:
[section:release_notes Release Notes]
[section:release_notes_boost_1_81_00 Boost 1.81 Release]
* [classref boost::container::devector devector]'s insertion logic has been reimplemented to move elements to the center of the devector if an insertion at one end
has no free capacity but there is free capacity on the other end. Current implementation keeps reallocating memory when only inserting at one end and poping from the
other, provoking very high memory usage. The new strategy is based on the article
[@http://larshagencpp.github.io/blog/2016/05/22/devector Double-ended vector - is it useful?] by Lars Greger Nordland Hagen.
[endsect]
[section:release_notes_boost_1_80_00 Boost 1.80 Release]
* Fixed bugs/issues:

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

@@ -625,7 +625,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
BOOST_CONTAINER_FORCEINLINE explicit deque(size_type n)
: Base(n, allocator_type())
{
dtl::insert_value_initialized_n_proxy<ValAllocator, iterator> proxy;
dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
//deque_base will deallocate in case of exception...
}
@@ -642,7 +642,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
BOOST_CONTAINER_FORCEINLINE deque(size_type n, default_init_t)
: Base(n, allocator_type())
{
dtl::insert_default_initialized_n_proxy<ValAllocator, iterator> proxy;
dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
//deque_base will deallocate in case of exception...
}
@@ -657,7 +657,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
BOOST_CONTAINER_FORCEINLINE explicit deque(size_type n, const allocator_type &a)
: Base(n, a)
{
dtl::insert_value_initialized_n_proxy<ValAllocator, iterator> proxy;
dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
//deque_base will deallocate in case of exception...
}
@@ -674,7 +674,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
BOOST_CONTAINER_FORCEINLINE deque(size_type n, default_init_t, const allocator_type &a)
: Base(n, a)
{
dtl::insert_default_initialized_n_proxy<ValAllocator, iterator> proxy;
dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
//deque_base will deallocate in case of exception...
}
@@ -1181,7 +1181,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
this->priv_erase_last_n(len - new_size);
else{
const size_type n = new_size - this->size();
dtl::insert_value_initialized_n_proxy<ValAllocator, iterator> proxy;
dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
priv_insert_back_aux_impl(n, proxy);
}
}
@@ -1201,7 +1201,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
this->priv_erase_last_n(len - new_size);
else{
const size_type n = new_size - this->size();
dtl::insert_default_initialized_n_proxy<ValAllocator, iterator> proxy;
dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
priv_insert_back_aux_impl(n, proxy);
}
}
@@ -1463,7 +1463,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
return r;
}
else{
typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, iterator, Args...> type;
typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, Args...> type;
return *this->priv_insert_front_aux_impl(1, type(boost::forward<Args>(args)...));
}
}
@@ -1489,7 +1489,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
return r;
}
else{
typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, iterator, Args...> type;
typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, Args...> type;
return *this->priv_insert_back_aux_impl(1, type(boost::forward<Args>(args)...));
}
}
@@ -1516,7 +1516,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
return (this->end()-1);
}
else{
typedef dtl::insert_emplace_proxy<ValAllocator, iterator, Args...> type;
typedef dtl::insert_emplace_proxy<ValAllocator, Args...> type;
return this->priv_insert_aux_impl(p, 1, type(boost::forward<Args>(args)...));
}
}
@@ -1536,7 +1536,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
}\
else{\
typedef dtl::insert_nonmovable_emplace_proxy##N\
<ValAllocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
<ValAllocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
return *priv_insert_front_aux_impl(1, type(BOOST_MOVE_FWD##N));\
}\
}\
@@ -1553,7 +1553,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
}\
else{\
typedef dtl::insert_nonmovable_emplace_proxy##N\
<ValAllocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
<ValAllocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
return *priv_insert_back_aux_impl(1, type(BOOST_MOVE_FWD##N));\
}\
}\
@@ -1572,7 +1572,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
}\
else{\
typedef dtl::insert_emplace_proxy_arg##N\
<ValAllocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
<ValAllocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\
}\
}
@@ -1729,7 +1729,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
)
{
BOOST_ASSERT(this->priv_in_range_or_end(p));
dtl::insert_range_proxy<ValAllocator, FwdIt, iterator> proxy(first);
dtl::insert_range_proxy<ValAllocator, FwdIt> proxy(first);
return priv_insert_aux_impl(p, boost::container::iterator_udistance(first, last), proxy);
}
#endif

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

@@ -45,7 +45,7 @@
namespace boost { namespace container { namespace dtl {
template<class Allocator, class FwdIt, class Iterator>
template<class Allocator, class FwdIt>
struct move_insert_range_proxy
{
typedef typename allocator_traits<Allocator>::value_type value_type;
@@ -54,12 +54,14 @@ struct move_insert_range_proxy
: first_(first)
{}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
{
this->first_ = ::boost::container::uninitialized_move_alloc_n_source
(a, this->first_, n, p);
}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
{
this->first_ = ::boost::container::move_n_source(this->first_, n, p);
@@ -69,7 +71,7 @@ struct move_insert_range_proxy
};
template<class Allocator, class FwdIt, class Iterator>
template<class Allocator, class FwdIt>
struct insert_range_proxy
{
typedef typename allocator_traits<Allocator>::value_type value_type;
@@ -78,11 +80,13 @@ struct insert_range_proxy
: first_(first)
{}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
{
this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
{
this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
@@ -92,7 +96,7 @@ struct insert_range_proxy
};
template<class Allocator, class Iterator>
template<class Allocator>
struct insert_n_copies_proxy
{
typedef typename allocator_traits<Allocator>::value_type value_type;
@@ -101,9 +105,11 @@ struct insert_n_copies_proxy
: v_(v)
{}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{ boost::container::uninitialized_fill_alloc_n(a, v_, n, p); }
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
{
while (n){
@@ -116,16 +122,18 @@ struct insert_n_copies_proxy
const value_type &v_;
};
template<class Allocator, class Iterator>
template<class Allocator>
struct insert_value_initialized_n_proxy
{
typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
typedef typename allocator_traits<Allocator>::value_type value_type;
typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{ boost::container::uninitialized_value_init_alloc_n(a, n, p); }
template<class Iterator>
void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
while (n){
@@ -140,16 +148,18 @@ struct insert_value_initialized_n_proxy
}
};
template<class Allocator, class Iterator>
template<class Allocator>
struct insert_default_initialized_n_proxy
{
typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
typedef typename allocator_traits<Allocator>::value_type value_type;
typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{ boost::container::uninitialized_default_init_alloc_n(a, n, p); }
template<class Iterator>
void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
if(!is_pod<value_type>::value){
@@ -166,7 +176,7 @@ struct insert_default_initialized_n_proxy
}
};
template<class Allocator, class Iterator>
template<class Allocator>
struct insert_copy_proxy
{
typedef boost::container::allocator_traits<Allocator> alloc_traits;
@@ -178,12 +188,14 @@ struct insert_copy_proxy
: v_(v)
{}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
{
BOOST_ASSERT(n == 1); (void)n;
@@ -194,7 +206,7 @@ struct insert_copy_proxy
};
template<class Allocator, class Iterator>
template<class Allocator>
struct insert_move_proxy
{
typedef boost::container::allocator_traits<Allocator> alloc_traits;
@@ -206,12 +218,14 @@ struct insert_move_proxy
: v_(v)
{}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
{
BOOST_ASSERT(n == 1); (void)n;
@@ -222,15 +236,15 @@ struct insert_move_proxy
};
template<class It, class Allocator>
BOOST_CONTAINER_FORCEINLINE insert_move_proxy<Allocator, It> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
BOOST_CONTAINER_FORCEINLINE insert_move_proxy<Allocator> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
{
return insert_move_proxy<Allocator, It>(v);
return insert_move_proxy<Allocator>(v);
}
template<class It, class Allocator>
BOOST_CONTAINER_FORCEINLINE insert_copy_proxy<Allocator, It> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
BOOST_CONTAINER_FORCEINLINE insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
{
return insert_copy_proxy<Allocator, It>(v);
return insert_copy_proxy<Allocator>(v);
}
}}} //namespace boost { namespace container { namespace dtl {
@@ -244,7 +258,7 @@ namespace boost {
namespace container {
namespace dtl {
template<class Allocator, class Iterator, class ...Args>
template<class Allocator, class ...Args>
struct insert_nonmovable_emplace_proxy
{
typedef boost::container::allocator_traits<Allocator> alloc_traits;
@@ -257,11 +271,12 @@ struct insert_nonmovable_emplace_proxy
: args_(args...)
{}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
{ this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n); }
private:
template<std::size_t ...IdxPack>
template<std::size_t ...IdxPack, class Iterator>
BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
{
BOOST_ASSERT(n == 1); (void)n;
@@ -272,11 +287,11 @@ struct insert_nonmovable_emplace_proxy
tuple<Args&...> args_;
};
template<class Allocator, class Iterator, class ...Args>
template<class Allocator, class ...Args>
struct insert_emplace_proxy
: public insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...>
: public insert_nonmovable_emplace_proxy<Allocator, Args...>
{
typedef insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...> base_t;
typedef insert_nonmovable_emplace_proxy<Allocator, Args...> base_t;
typedef boost::container::allocator_traits<Allocator> alloc_traits;
typedef typename base_t::value_type value_type;
typedef typename base_t::index_tuple_t index_tuple_t;
@@ -287,12 +302,13 @@ struct insert_emplace_proxy
: base_t(::boost::forward<Args>(args)...)
{}
template<class Iterator>
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
{ this->priv_copy_some_and_update(a, index_tuple_t(), p, n); }
private:
template<std::size_t ...IdxPack>
template<std::size_t ...IdxPack, class Iterator>
BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
{
BOOST_ASSERT(n ==1); (void)n;
@@ -312,55 +328,55 @@ struct insert_emplace_proxy
};
//Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type
template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator, typename boost::container::allocator_traits<Allocator>::value_type>
: public insert_move_proxy<Allocator, Iterator>
template<class Allocator>
struct insert_emplace_proxy<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>
: public insert_move_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
: insert_move_proxy<Allocator, Iterator>(v)
: insert_move_proxy<Allocator>(v)
{}
};
//We use "add_const" here as adding "const" only confuses MSVC12(and maybe later) provoking
//compiler error C2752 ("more than one partial specialization matches").
//Any problem is solvable with an extra layer of indirection? ;-)
template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator
template<class Allocator>
struct insert_emplace_proxy<Allocator
, typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
>
: public insert_copy_proxy<Allocator, Iterator>
: public insert_copy_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
: insert_copy_proxy<Allocator>(v)
{}
};
template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator, typename boost::container::allocator_traits<Allocator>::value_type &>
: public insert_copy_proxy<Allocator, Iterator>
template<class Allocator>
struct insert_emplace_proxy<Allocator, typename boost::container::allocator_traits<Allocator>::value_type &>
: public insert_copy_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
: insert_copy_proxy<Allocator>(v)
{}
};
template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator
template<class Allocator>
struct insert_emplace_proxy<Allocator
, typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
>
: public insert_copy_proxy<Allocator, Iterator>
: public insert_copy_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
: insert_copy_proxy<Allocator>(v)
{}
};
@@ -375,7 +391,7 @@ namespace container {
namespace dtl {
#define BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE(N) \
template< class Allocator, class Iterator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
template< class Allocator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
struct insert_nonmovable_emplace_proxy##N\
{\
typedef boost::container::allocator_traits<Allocator> alloc_traits;\
@@ -386,12 +402,14 @@ struct insert_nonmovable_emplace_proxy##N\
BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
\
template<class Iterator>\
BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
{\
BOOST_ASSERT(n == 1); (void)n;\
alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
}\
\
template<class Iterator>\
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, std::size_t)\
{ BOOST_ASSERT(false); }\
\
@@ -399,12 +417,12 @@ struct insert_nonmovable_emplace_proxy##N\
BOOST_MOVE_MREF##N\
};\
\
template< class Allocator, class Iterator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
template< class Allocator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
struct insert_emplace_proxy_arg##N\
: insert_nonmovable_emplace_proxy##N< Allocator, Iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N >\
: insert_nonmovable_emplace_proxy##N< Allocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N >\
{\
typedef insert_nonmovable_emplace_proxy##N\
< Allocator, Iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N > base_t;\
< Allocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N > base_t;\
typedef typename base_t::value_type value_type;\
typedef boost::container::allocator_traits<Allocator> alloc_traits;\
\
@@ -413,6 +431,7 @@ struct insert_emplace_proxy_arg##N\
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
: base_t(BOOST_MOVE_FWD##N){}\
\
template<class Iterator>\
BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
{\
BOOST_ASSERT(n == 1); (void)n;\
@@ -437,79 +456,79 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE)
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
//Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type
template<class Allocator, class Iterator>
struct insert_emplace_proxy_arg1<Allocator, Iterator, ::boost::rv<typename boost::container::allocator_traits<Allocator>::value_type> >
: public insert_move_proxy<Allocator, Iterator>
template<class Allocator>
struct insert_emplace_proxy_arg1<Allocator, ::boost::rv<typename boost::container::allocator_traits<Allocator>::value_type> >
: public insert_move_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_move_proxy<Allocator, Iterator>(v)
: insert_move_proxy<Allocator>(v)
{}
};
template<class Allocator, class Iterator>
struct insert_emplace_proxy_arg1<Allocator, Iterator, typename boost::container::allocator_traits<Allocator>::value_type>
: public insert_copy_proxy<Allocator, Iterator>
template<class Allocator>
struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>
: public insert_copy_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
: insert_copy_proxy<Allocator>(v)
{}
};
#else //e.g. MSVC10 & MSVC11
//Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type
template<class Allocator, class Iterator>
struct insert_emplace_proxy_arg1<Allocator, Iterator, typename boost::container::allocator_traits<Allocator>::value_type>
: public insert_move_proxy<Allocator, Iterator>
template<class Allocator>
struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>
: public insert_move_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
: insert_move_proxy<Allocator, Iterator>(v)
: insert_move_proxy<Allocator>(v)
{}
};
//We use "add_const" here as adding "const" only confuses MSVC10&11 provoking
//compiler error C2752 ("more than one partial specialization matches").
//Any problem is solvable with an extra layer of indirection? ;-)
template<class Allocator, class Iterator>
struct insert_emplace_proxy_arg1<Allocator, Iterator
template<class Allocator>
struct insert_emplace_proxy_arg1<Allocator
, typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
>
: public insert_copy_proxy<Allocator, Iterator>
: public insert_copy_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
: insert_copy_proxy<Allocator>(v)
{}
};
template<class Allocator, class Iterator>
struct insert_emplace_proxy_arg1<Allocator, Iterator, typename boost::container::allocator_traits<Allocator>::value_type &>
: public insert_copy_proxy<Allocator, Iterator>
template<class Allocator>
struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator_traits<Allocator>::value_type &>
: public insert_copy_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
: insert_copy_proxy<Allocator>(v)
{}
};
template<class Allocator, class Iterator>
struct insert_emplace_proxy_arg1<Allocator, Iterator
template<class Allocator>
struct insert_emplace_proxy_arg1<Allocator
, typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
>
: public insert_copy_proxy<Allocator, Iterator>
: public insert_copy_proxy<Allocator>
{
static const bool single_value = true;
BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
: insert_copy_proxy<Allocator>(v)
{}
};
@@ -519,40 +538,6 @@ struct insert_emplace_proxy_arg1<Allocator, Iterator
#endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
namespace boost { namespace container { namespace dtl {
template <class T>
struct has_single_value
{
private:
struct two {char array_[2];};
template<bool Arg> struct wrapper;
template <class U> static two test(int, ...);
template <class U> static char test(int, const wrapper<U::single_value>*);
public:
static const bool value = sizeof(test<T>(0, 0)) == 1;
void dummy(){}
};
template<class InsertionProxy, bool = has_single_value<InsertionProxy>::value>
struct is_single_value_proxy_impl
{
static const bool value = InsertionProxy::single_value;
};
template<class InsertionProxy>
struct is_single_value_proxy_impl<InsertionProxy, false>
{
static const bool value = false;
};
template<class InsertionProxy>
struct is_single_value_proxy
: is_single_value_proxy_impl<InsertionProxy>
{};
}}} //namespace boost { namespace container { namespace dtl {
#include <boost/container/detail/config_end.hpp>
#endif //#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP

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

@@ -32,6 +32,7 @@
#include <boost/move/adl_move_swap.hpp>
#include <boost/move/iterator.hpp>
#include <boost/move/utility_core.hpp>
#include <boost/move/traits.hpp>
// other
#include <boost/core/no_exceptions_support.hpp>
// std
@@ -112,6 +113,7 @@ struct are_elements_contiguous<boost::container::vec_iterator<Pointer, IsConst>
static const bool value = true;
};
/////////////////////////
// offset_ptr
/////////////////////////
@@ -169,6 +171,46 @@ struct disable_if_memtransfer_copy_assignable
: disable_if<dtl::is_memtransfer_copy_assignable<I, O>, R>
{};
template <class T>
struct has_single_value
{
private:
struct two { char array_[2]; };
template<bool Arg> struct wrapper;
template <class U> static two test(int, ...);
template <class U> static char test(int, const wrapper<U::single_value>*);
public:
static const bool value = sizeof(test<T>(0, 0)) == 1;
void dummy() {}
};
template<class InsertionProxy, bool = has_single_value<InsertionProxy>::value>
struct is_single_value_proxy_impl
{
static const bool value = InsertionProxy::single_value;
};
template<class InsertionProxy>
struct is_single_value_proxy_impl<InsertionProxy, false>
{
static const bool value = false;
};
template<class InsertionProxy>
struct is_single_value_proxy
: is_single_value_proxy_impl<InsertionProxy>
{};
template <typename P, typename R = void>
struct enable_if_single_value_proxy
: enable_if<is_single_value_proxy<P>, R>
{};
template <typename P, typename R = void>
struct disable_if_single_value_proxy
: disable_if<is_single_value_proxy<P>, R>
{};
template
<typename I, // I models InputIterator
typename F> // F models ForwardIterator
@@ -978,6 +1020,19 @@ BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<
move_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n_source(f, n, r); }
template<typename F> // F models ForwardIterator
BOOST_CONTAINER_FORCEINLINE F move_forward_overlapping(F f, F l, F r)
{
return (f != r) ? (move)(f, l, r) : l;
}
template<typename B> // B models BidirIterator
BOOST_CONTAINER_FORCEINLINE B move_backward_overlapping(B f, B l, B rl)
{
return (l != rl) ? (move_backward)(f, l, rl) : f;
}
//////////////////////////////////////////////////////////////////////////////
//
// destroy_alloc_n
@@ -1006,6 +1061,31 @@ BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_trivially_destructible<I, vo
destroy_alloc_n(Allocator &, I, U)
{}
//////////////////////////////////////////////////////////////////////////////
//
// destroy_alloc
//
//////////////////////////////////////////////////////////////////////////////
template
<typename Allocator
,typename I> // I models InputIterator
inline typename dtl::disable_if_trivially_destructible<I, void>::type
destroy_alloc(Allocator &a, I f, I l)
{
while(f != l){
allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(f));
++f;
}
}
template
<typename Allocator
,typename I > // I models InputIterator
BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_trivially_destructible<I, void>::type
destroy_alloc(Allocator &, I, I)
{}
//////////////////////////////////////////////////////////////////////////////
//
// deep_swap_alloc_n
@@ -1088,7 +1168,7 @@ inline typename dtl::enable_if_c
//Loop unrolling using Duff's device, as it seems it helps on some architectures
const std::size_t Unroll = 4;
std::size_t n = (szt_times + (Unroll-1))/Unroll;
const std::size_t branch_number = (!szt_times)*Unroll + (szt_times % Unroll);
const std::size_t branch_number = (szt_times == 0)*Unroll + (szt_times % Unroll);
switch(branch_number){
case 4:
break;
@@ -1177,10 +1257,10 @@ void move_assign_range_alloc_n( Allocator &a, I inp_start, std::size_t n_i, O ou
}
}
template<class Allocator, class Iterator>
template<class Allocator>
struct array_destructor
{
typedef typename ::boost::container::iterator_traits<Iterator>::value_type value_type;
typedef typename ::boost::container::allocator_traits<Allocator>::value_type value_type;
typedef typename dtl::if_c
<dtl::is_trivially_destructible<value_type>::value
,dtl::null_scoped_destructor_range<Allocator>
@@ -1188,6 +1268,17 @@ struct array_destructor
>::type type;
};
template<class Allocator>
struct value_destructor
{
typedef typename ::boost::container::allocator_traits<Allocator>::value_type value_type;
typedef typename dtl::if_c
<dtl::is_trivially_destructible<value_type>::value
, dtl::null_scoped_destructor<Allocator>
, dtl::scoped_destructor<Allocator>
>::type type;
};
template
<typename Allocator
,typename F // F models ForwardIterator
@@ -1201,9 +1292,9 @@ void uninitialized_move_and_insert_alloc
, F last
, O d_first
, std::size_t n
, InsertionProxy insert_range_proxy)
, InsertionProxy insertion_proxy)
{
typedef typename array_destructor<Allocator, F>::type array_destructor_t;
typedef typename array_destructor<Allocator>::type array_destructor_t;
//Anti-exception rollbacks
array_destructor_t new_values_destroyer(d_first, d_first, a);
@@ -1213,7 +1304,7 @@ void uninitialized_move_and_insert_alloc
O d_last = ::boost::container::uninitialized_move_alloc(a, first, pos, d_first);
new_values_destroyer.set_end(d_last);
//Initialize new objects, starting from previous point
insert_range_proxy.uninitialized_copy_n_and_update(a, d_last, n);
insertion_proxy.uninitialized_copy_n_and_update(a, d_last, n);
d_last += n;
new_values_destroyer.set_end(d_last);
//Initialize from the rest of the old buffer,
@@ -1223,50 +1314,663 @@ void uninitialized_move_and_insert_alloc
new_values_destroyer.release();
}
template
<typename Allocator
,typename F // F models ForwardIterator
,typename InsertionProxy
>
void expand_forward_and_insert_alloc
typename dtl::enable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
expand_backward_and_insert_nonempty_middle_alloc
( Allocator &a
, F const first
, F const pos
, std::size_t const
, InsertionProxy insertion_proxy)
{
BOOST_ASSERT(first != pos);
typedef typename value_destructor<Allocator>::type value_destructor_t;
F aux = first; --aux;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(aux), boost::move(*first));
value_destructor_t on_exception(a, boost::movelib::iterator_to_raw_pointer(aux));
//Copy previous to last objects to the initialized end
aux = first; ++aux;
aux = boost::container::move(aux, pos, first);
//Insert new objects in the pos
insertion_proxy.copy_n_and_update(a, aux, 1u);
on_exception.release();
}
template
<typename Allocator
,typename F // F models ForwardIterator
,typename InsertionProxy
>
typename dtl::disable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
expand_backward_and_insert_nonempty_middle_alloc
( Allocator &a
, F first
, F pos
, std::size_t const n
, InsertionProxy insertion_proxy)
{
BOOST_ASSERT(first != pos);
BOOST_ASSERT(n != 0);
typedef typename array_destructor<Allocator>::type array_destructor_t;
const std::size_t elems_before = iterator_udistance(first, pos);
if(elems_before >= n){
//New elements can be just copied.
//Move to uninitialized memory last objects
F const first_less_n = first - n;
F nxt = ::boost::container::uninitialized_move_alloc_n_source(a, first, n, first_less_n);
array_destructor_t on_exception(first_less_n, first, a);
//Copy previous to last objects to the initialized end
nxt = boost::container::move(nxt, pos, first);
//Insert new objects in the pos
insertion_proxy.copy_n_and_update(a, nxt, n);
on_exception.release();
}
else {
//The new elements don't fit in the [pos, end()) range.
//Copy old [pos, end()) elements to the uninitialized memory (a gap is created)
F aux = ::boost::container::uninitialized_move_alloc(a, first, pos, first - n);
array_destructor_t on_exception(first -n, aux, a);
//Copy to the beginning of the unallocated zone the last new elements (the gap is closed).
insertion_proxy.uninitialized_copy_n_and_update(a, aux, std::size_t(n - elems_before));
insertion_proxy.copy_n_and_update(a, first, elems_before);
on_exception.release();
}
}
template
<typename Allocator
,typename F // F models ForwardIterator
,typename InsertionProxy
>
typename dtl::enable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
expand_forward_and_insert_nonempty_middle_alloc
( Allocator &a
, F pos
, F last
, std::size_t n
, InsertionProxy insert_range_proxy)
, std::size_t const
, InsertionProxy insertion_proxy)
{
typedef typename array_destructor<Allocator, F>::type array_destructor_t;
BOOST_ASSERT(last != pos);
typedef typename value_destructor<Allocator>::type value_destructor_t;
F last_m_n = last; --last_m_n;
allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(last), boost::move(*last_m_n));
value_destructor_t on_exception(a, boost::movelib::iterator_to_raw_pointer(last));
//Copy previous to last objects to the initialized end
boost::container::move_backward(pos, last_m_n, last);
//Insert new objects in the pos
insertion_proxy.copy_n_and_update(a, pos, 1);
on_exception.release();
}
if (BOOST_UNLIKELY(!n)){
return;
template
<typename Allocator
,typename F // F models ForwardIterator
,typename InsertionProxy
>
typename dtl::disable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
expand_forward_and_insert_nonempty_middle_alloc
( Allocator &a
, F pos
, F last
, std::size_t const n
, InsertionProxy insertion_proxy)
{
BOOST_ASSERT(last != pos);
BOOST_ASSERT(n != 0);
typedef typename array_destructor<Allocator>::type array_destructor_t;
const std::size_t elems_after = iterator_udistance(pos, last);
if(elems_after >= n){
//New elements can be just copied.
//Move to uninitialized memory last objects
F const last_m_n = last - n;
F const nxt = ::boost::container::uninitialized_move_alloc_n(a, last_m_n, n, last);
array_destructor_t on_exception(last, nxt, a);
//Copy previous to last objects to the initialized end
boost::container::move_backward(pos, last_m_n, last);
//Insert new objects in the pos
insertion_proxy.copy_n_and_update(a, pos, n);
on_exception.release();
}
else if (last == pos){
insert_range_proxy.uninitialized_copy_n_and_update(a, last, n);
else {
//The new elements don't fit in the [pos, end()) range.
//Copy old [pos, end()) elements to the uninitialized memory (a gap is created)
F new_last = ::boost::container::uninitialized_move_alloc(a, pos, last, pos + n);
array_destructor_t on_exception(pos + n, new_last, a);
//Copy first new elements in pos (gap is still there)
insertion_proxy.copy_n_and_update(a, pos, elems_after);
//Copy to the beginning of the unallocated zone the last new elements (the gap is closed).
insertion_proxy.uninitialized_copy_n_and_update(a, last, std::size_t(n - elems_after));
on_exception.release();
}
}
template
<typename Allocator
, typename F // F models ForwardIterator
, typename InsertionProxy
>
BOOST_CONTAINER_FORCEINLINE void expand_forward_and_insert_alloc
( Allocator& a
, F pos
, F last
, std::size_t const n
, InsertionProxy insertion_proxy)
{
if (last == pos) {
insertion_proxy.uninitialized_copy_n_and_update(a, last, n);
}
else{
const std::size_t elems_after = static_cast<std::size_t>(last - pos);
if(elems_after >= n){
//New elements can be just copied.
//Move to uninitialized memory last objects
::boost::container::uninitialized_move_alloc_n(a, last - n, n, last);
array_destructor_t on_exception(last, last, a);
//Copy previous to last objects to the initialized end
boost::container::move_backward(pos, last - n, last);
//Insert new objects in the pos
insert_range_proxy.copy_n_and_update(a, pos, n);
on_exception.release();
const bool single_value = dtl::is_single_value_proxy<InsertionProxy>::value;
BOOST_IF_CONSTEXPR(!single_value){
if (BOOST_UNLIKELY(!n)) {
return;
}
}
expand_forward_and_insert_nonempty_middle_alloc(a, pos, last, n, insertion_proxy);
}
}
template <class B, class InsertionProxy, class Allocator>
void expand_backward_forward_and_insert_alloc_move_backward
( B const old_start
, std::size_t const old_size
, B const new_start
, B const pos
, std::size_t const n
, InsertionProxy insertion_proxy
, Allocator& a)
{
typedef std::size_t size_type;
typedef typename allocator_traits<Allocator>::value_type value_type;
static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
typedef typename dtl::if_c
<trivial_dctr
, dtl::null_scoped_destructor_n<Allocator, B>
, dtl::scoped_destructor_n<Allocator, B>
>::type array_destructor_t;
//n can be zero to just expand capacity
B old_finish = make_iterator_uadvance(old_start, old_size);
//We can have 8 possibilities:
const size_type elemsbefore = static_cast<size_type>(iterator_udistance(old_start, pos));
const size_type raw_before = static_cast<size_type>(iterator_udistance(new_start, old_start));
const size_type before_plus_new = size_type(elemsbefore + n);
//Check if raw_before is big enough to hold the beginning of old data + new data
if (raw_before >= before_plus_new) {
//If anything goes wrong, this object will destroy
//all the old objects to fulfill previous vector state
array_destructor_t old_values_destroyer(old_start, a, old_size);
// _________________________________________________________
//| raw_mem | old_begin | old_end | //Old situation
//| __________________________________|___________|_________|
// _________________________________________________________
//| old_begin | new | raw_mem | old_begin | old_end | //First step
//|___________|__________|____________|___________|_________|
//Copy first old values before pos, after that the new objects
B const new_elem_pos = ::boost::container::uninitialized_move_alloc(a, old_start, pos, new_start);
array_destructor_t new_values_destroyer(new_start, a, elemsbefore);
insertion_proxy.uninitialized_copy_n_and_update(a, new_elem_pos, n);
new_values_destroyer.set_size(before_plus_new);
const size_type new_size = size_type(old_size + n);
//Check if raw_before is so big that even copying the old data + new data
//there is a gap between the new data and the old data
if (raw_before >= new_size) {
// _______________________________________________________
//| raw_mem | old_begin | old_end | //Old situation
//|_________________________________|___________|_________|
// _______________________________________________________
//| old_begin | new | raw_mem | old_begin | old_end | //First step
//|___________|________|____________|___________|_________|
// _______________________________________________________
//| old_begin | new | old_end | raw_mem | //New situation
//|___________|________|_________|________________________|
//
//Now initialize the rest of memory with the last old values
if (before_plus_new != new_size) { //Special case to avoid operations in back insertion
B new_start_end(make_iterator_uadvance(new_start, before_plus_new));
::boost::container::uninitialized_move_alloc(a, pos, old_finish, new_start_end);
}
//All new elements correctly constructed, avoid new element destruction
new_values_destroyer.release();
//Old values destroyed automatically with "old_values_destroyer"
//when "old_values_destroyer" goes out of scope unless the have trivial
//destructor after move.
if(trivial_dctr_after_move)
old_values_destroyer.release();
}
//raw_before is so big that divides old_end
else {
// _________________________________________________
//| raw | old_beg | old_end | //Old situation
//|_____________________________|_________|_________|
// _________________________________________________
//| old_begin | new | raw | old_beg | old_end | //First step
//|___________|__________|______|_________|_________|
// _________________________________________________
//| old_begin | new | old_end | raw_mem | //New situation
//|___________|__________|_________|________________|
//Now initialize the rest of memory with the last old values
//All new elements correctly constructed, avoid new element destruction
BOOST_IF_CONSTEXPR(!trivial_dctr) {
//Now initialize the rest of raw_before memory with the
//first of elements after new values
const size_type raw_gap = raw_before - before_plus_new;
B new_start_plus(make_iterator_uadvance(new_start, before_plus_new));
::boost::container::uninitialized_move_alloc_n(a, pos, raw_gap, new_start_plus);
new_values_destroyer.release();
old_values_destroyer.increment_size_backwards(raw_before);
//Now move remaining last objects in the old buffer begin
B remaining_pos(make_iterator_uadvance(pos, raw_gap));
remaining_pos = ::boost::container::move_forward_overlapping(remaining_pos, old_finish, old_start);
(void)remaining_pos;
//Once moved, avoid calling the destructors if trivial after move
if(!trivial_dctr_after_move) {
boost::container::destroy_alloc(a, remaining_pos, old_finish);
}
}
else { //If trivial destructor, we can uninitialized copy + copy in a single uninitialized copy
::boost::container::uninitialized_move_alloc_n
(a, pos, static_cast<size_type>(old_finish - pos), make_iterator_uadvance(new_start, before_plus_new));
}
old_values_destroyer.release();
}
}
else {
//If anything goes wrong, this object will destroy
//all the old objects to fulfill previous vector state
array_destructor_t old_values_destroyer(old_start, a, old_size);
//Check if we have to do the insertion in two phases
//since maybe raw_before is not big enough and
//the buffer was expanded both sides
// _________________________________________________
//| raw_mem | old_begin + old_end | raw_mem | //Old situation
//|_________|_____________________|_________________|
// _________________________________________________
//| old_begin + new + old_end | raw_mem | //New situation with do_after
//|___________________________________|_____________|
// _________________________________________________
//| old_begin + new + old_end | raw_mem | //New without do_after
//|____________________________|____________________|
//
const bool do_after = n > raw_before;
//Now we can have two situations: the raw_mem of the
//beginning divides the old_begin, or the new elements:
if (raw_before <= elemsbefore) {
//The raw memory divides the old_begin group:
//
//If we need two phase construction (do_after)
//new group is divided in new = new_beg + new_end groups
//In this phase only new_beg will be inserted
//
// _________________________________________________
//| raw_mem | old_begin | old_end | raw_mem | //Old situation
//|_________|___________|_________|_________________|
// _________________________________________________
//| old_begin | new_beg | old_end | raw_mem | //New situation with do_after(1),
//|___________|_________|_________|_________________| //not definitive, pending operations
// _________________________________________________
//| old_begin | new | old_end | raw_mem | //New situation without do_after,
//|___________|_____|_________|_____________________| //definitive.
//
//Copy the first part of old_begin to raw_mem
::boost::container::uninitialized_move_alloc_n(a, old_start, raw_before, new_start);
//The buffer is all constructed until old_end,
//so program trailing destruction and assign final size
//if !do_after, raw_before+n otherwise.
size_type new_1st_range;
old_values_destroyer.increment_size_backwards(raw_before);
new_1st_range = do_after ? raw_before : n;
//Now copy the second part of old_begin overwriting itself
B const old_next(make_iterator_uadvance(old_start, raw_before));
B const next = ::boost::container::move(old_next, pos, old_start);
//Now copy the new_beg elements
insertion_proxy.copy_n_and_update(a, next, new_1st_range);
//If there is no after work and the last old part needs to be moved to front, do it
if (!do_after) {
//Now displace old_end elements and destroy trailing
B const new_first(make_iterator_uadvance(next, new_1st_range));
B const p = ::boost::container::move_forward_overlapping(pos, old_finish, new_first);
(void)p;
if(!trivial_dctr_after_move)
boost::container::destroy_alloc(a, p, old_finish);
}
}
else {
//The new elements don't fit in the [pos, end()) range.
//Copy old [pos, end()) elements to the uninitialized memory (a gap is created)
F new_last = ::boost::container::uninitialized_move_alloc(a, pos, last, pos + n);
array_destructor_t on_exception(pos + n, new_last, a);
//Copy first new elements in pos (gap is still there)
insert_range_proxy.copy_n_and_update(a, pos, elems_after);
//Copy to the beginning of the unallocated zone the last new elements (the gap is closed).
insert_range_proxy.uninitialized_copy_n_and_update(a, last, std::size_t(n - elems_after));
on_exception.release();
//If we have to expand both sides,
//we will play if the first new values so
//calculate the upper bound of new values
//The raw memory divides the new elements
//
//If we need two phase construction (do_after)
//new group is divided in new = new_beg + new_end groups
//In this phase only new_beg will be inserted
//
// ____________________________________________________
//| raw_mem | old_begin | old_end | raw_mem | //Old situation
//|_______________|___________|_________|______________|
// ____________________________________________________
//| old_begin | new_beg | old_end | raw_mem | //New situation with do_after(),
//|___________|_______________|_________|______________| //not definitive, pending operations
// ____________________________________________________
//| old_begin | new | old_end | raw_mem | //New situation without do_after,
//|___________|_____|_________|________________________| //definitive
//
//First copy whole old_begin and part of new to raw_mem
B const new_pos = ::boost::container::uninitialized_move_alloc(a, old_start, pos, new_start);
array_destructor_t new_values_destroyer(new_start, a, elemsbefore);
const size_type mid_n = size_type(raw_before - elemsbefore);
insertion_proxy.uninitialized_copy_n_and_update(a, new_pos, mid_n);
new_values_destroyer.release();
//The buffer is all constructed until old_end
old_values_destroyer.increment_size_backwards(raw_before);
if (do_after) {
//Copy new_beg part
insertion_proxy.copy_n_and_update(a, old_start, elemsbefore);
}
else {
//Copy all new elements
const size_type rest_new = size_type(n - mid_n);
insertion_proxy.copy_n_and_update(a, old_start, rest_new);
B move_start(make_iterator_uadvance(old_start, rest_new));
//Displace old_end, but make sure data has to be moved
B const move_end = ::boost::container::move_forward_overlapping(pos, old_finish, move_start);
(void)move_end; //To avoid warnings of unused initialization for move_end in case
//trivial_dctr_after_move is true
//Destroy remaining moved elements from old_end except if they
//have trivial destructor after being moved
if(!trivial_dctr_after_move) {
boost::container::destroy_alloc(a, move_end, old_finish);
}
}
}
//This is only executed if two phase construction is needed
if (do_after) {
//The raw memory divides the new elements
// ______________________________________________________
//| raw_mem | old_begin | old_end | raw_mem | //Old situation
//|______________|___________|____________|______________|
// _______________________________________________________
//| old_begin + new_beg | new_end |old_end | rawmem | //New situation with do_after(1)
//|__________________________|_________|________|________|
// ______________________________________________________
//| old_begin + new | old_end |raw | //New situation with do_after(2)
//|_______________________________________|_________|____|
const size_type n_after = size_type(n - raw_before);
const size_type elemsafter = size_type(old_size - elemsbefore);
//We can have two situations:
if (elemsafter >= n_after) {
//The raw_mem from end will divide displaced old_end
//
//Old situation:
// ______________________________________________________
//| raw_mem | old_begin | old_end | raw_mem |
//|______________|___________|____________|______________|
//
//New situation with do_after(1):
// _______________________________________________________
//| old_begin + new_beg | new_end |old_end | raw_mem |
//|__________________________|_________|________|_________|
//
//First copy the part of old_end raw_mem
B finish_n = make_iterator_advance(old_finish, -std::ptrdiff_t(n_after));
::boost::container::uninitialized_move_alloc(a, finish_n, old_finish, old_finish);
old_values_destroyer.increment_size(n_after);
//Displace the rest of old_end to the new position
boost::container::move_backward_overlapping(pos, finish_n, old_finish);
//Now overwrite with new_end
//The new_end part is [first + (n - n_after), last)
insertion_proxy.copy_n_and_update(a, pos, n_after);
}
else {
//The raw_mem from end will divide new_end part
// _____________________________________________________________
//| raw_mem | old_begin | old_end | raw_mem | //Old situation
//|______________|___________|____________|_____________________|
// _____________________________________________________________
//| old_begin + new_beg | new_end |old_end | raw_mem | //New situation with do_after(2)
//|__________________________|_______________|________|_________|
//First initialize data in raw memory
const size_type mid_last_dist = size_type(n_after - elemsafter);
//Copy to the old_end part to the uninitialized zone leaving a gap.
B const mid_last(make_iterator_uadvance(old_finish, mid_last_dist));
::boost::container::uninitialized_move_alloc(a, pos, old_finish, mid_last);
array_destructor_t old_end_destroyer(mid_last, a, iterator_udistance(pos, old_finish));
//Copy the first part to the already constructed old_end zone
insertion_proxy.copy_n_and_update(a, pos, elemsafter);
//Copy the rest to the uninitialized zone filling the gap
insertion_proxy.uninitialized_copy_n_and_update(a, old_finish, mid_last_dist);
old_end_destroyer.release();
}
}
old_values_destroyer.release();
}
}
template
<typename Allocator
, typename B // B models BidirIterator
, typename InsertionProxy
>
BOOST_CONTAINER_FORCEINLINE void expand_backward_forward_and_insert_alloc_move_forward
( B const old_start
, std::size_t const old_size
, B const new_start
, B const pos
, std::size_t const n
, InsertionProxy insertion_proxy
, Allocator& a)
{
typedef std::size_t size_type;
typedef typename allocator_traits<Allocator>::value_type value_type;
static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
typedef typename dtl::if_c
<trivial_dctr
, dtl::null_scoped_destructor_n<Allocator, B>
, dtl::scoped_destructor_n<Allocator, B>
>::type array_destructor_t;
//n can be zero to just expand capacity
B const old_finish = make_iterator_uadvance(old_start, old_size);
const size_type new_size = size_type(old_size + n);
B const new_finish = make_iterator_uadvance(new_start, new_size);
//We can have 8 possibilities:
const size_type elemsafter = static_cast<size_type>(iterator_udistance(pos, old_finish));
const size_type raw_after = static_cast<size_type>(iterator_udistance(old_finish, new_finish));
const size_type after_plus_new = size_type(elemsafter + n);
//Check if raw_before is big enough to hold the new data + the end of old data
if (raw_after >= after_plus_new) {
//If anything goes wrong, this object will destroy
//all the old objects to fulfill previous vector state
array_destructor_t old_values_destroyer(old_start, a, old_size);
//______________________ __________________________________
//| old_begin | old_end | raw_mem //Old situation
//|___________|_________|__________________________________
// _____________________ _________________________________
//| old_begin | old_end | raw_mem | new | old_end | //First step
//|___________|_________|__________|__________|___________|
//Copy first new objects, after that old values after pos
B new_elem_pos = new_finish - after_plus_new;
insertion_proxy.uninitialized_copy_n_and_update(a, new_elem_pos, n);
array_destructor_t new_values_destroyer(new_elem_pos, a, n);
::boost::container::uninitialized_move_alloc(a, pos, old_finish, new_elem_pos+n);
new_values_destroyer.set_size(after_plus_new);
//Check if raw_before is so big that even copying the old data + new data
//there is a gap between the new data and the old data
if (raw_after >= new_size) {
//______________________ __________________________________
//| old_begin | old_end | raw_mem //Old situation
//|___________|_________|__________________________________
// _____________________ _________________________________
//| old_begin | old_end | raw_mem | new | old_end | //First step
//|___________|_________|______________|________|_________|
// _____________________V_________________________________
//| raw_mem | old_begin | new | old_end | //New situation
//|________________________|___________|________|_________|
//
//Now initialize the rest of memory with the last old values
::boost::container::uninitialized_move_alloc(a, old_start, pos, new_start);
//All new elements correctly constructed, avoid new element destruction
new_values_destroyer.release();
//Old values destroyed automatically with "old_values_destroyer"
//when "old_values_destroyer" goes out of scope unless the have trivial
//destructor after move.
if(trivial_dctr_after_move)
old_values_destroyer.release();
}
//raw_before is so big that divides old_end
else {
//______________________ ____________________________
//| old_begin | old_end | raw_mem //Old situation
//|___________|_________|____________________________
// _____________________ ____________________________
//| old_begin | old_end | raw_mem | new | old_end | //First step
//|___________|_________|_________|________|_________|
// _________________________________________________
//| raw_mem | old_begin | new | old_end | //New situation
//|___________________|___________|________|_________|
//Now initialize the rest of raw_before memory with the
//last elements before new values
const size_type raw_gap = raw_after - after_plus_new;
B const pre_pos_raw = pos - raw_gap;
::boost::container::uninitialized_move_alloc_n(a, pre_pos_raw, raw_gap, old_finish);
new_values_destroyer.release();
old_values_destroyer.increment_size(raw_after);
//Now move remaining last objects in the old buffer begin
BOOST_ASSERT(old_start != old_finish);
boost::container::move_backward_overlapping(old_start, pre_pos_raw, old_finish);
old_values_destroyer.release();
if (!trivial_dctr_after_move) {
boost::container::destroy_alloc(a, old_start, new_start);
}
}
}
else{
//If anything goes wrong, this object will destroy
//all the old objects to fulfill previous vector state
array_destructor_t old_values_destroyer(old_start, a, old_size);
//Now we can have two situations: the raw_mem of the
//end divides the new elements or the old_end
if (raw_after > elemsafter) {
//The raw memory divides the new elements
//__________________________________
//| old_begin | old_end | raw | //Old situation
//|___________|_________|___________|
// _____ ___________________________
//| raw | old_begin | new | old_end | //New situation
//|_____|___________|_____|_________|
//First copy whole old_end and part of new to raw_mem
B p = new_finish - elemsafter;
::boost::container::uninitialized_move_alloc(a, pos, old_finish, p);
array_destructor_t new_values_destroyer(p, a, elemsafter);
//Copy all new elements
const size_type mid_n = size_type(raw_after - elemsafter);
const size_type rest_new = size_type(n - mid_n);
B new_rng_start = old_finish - rest_new;
insertion_proxy.copy_n_and_update(a, new_rng_start, rest_new);
insertion_proxy.uninitialized_copy_n_and_update(a, old_finish, mid_n);
new_values_destroyer.release();
old_values_destroyer.increment_size_backwards(raw_after);
//Displace old_end, but make sure data has to be moved
p = ::boost::container::move_backward_overlapping(old_start, pos, new_rng_start);
//Destroy remaining moved elements from old_begin except if they
//have trivial destructor after being moved
old_values_destroyer.release();
if (!trivial_dctr_after_move) {
boost::container::destroy_alloc(a, old_start, p);
}
}
else {
//The raw memory divides the old_end group:
//________________________________________
//| old_begin | old_end | raw | //Old situation
//|___________|_______________|___________|
// _____ __________________________________
//| raw | old_begin | new | old_end | //New situation
//|_____|___________|_____|_______________|
//
//Copy the last part of old_end to raw_mem
const B old_end_pivot = old_finish - raw_after;
::boost::container::uninitialized_move_alloc_n(a, old_end_pivot, raw_after, old_finish);
//The buffer is all constructed
old_values_destroyer.increment_size_backwards(raw_after);
//Now copy the first part of old_end overwriting itself
B const new_end_pos = ::boost::container::move_backward_overlapping(pos, old_end_pivot, old_finish);
B const new_beg_pos = new_end_pos - n;
//Now copy the new_beg elements
insertion_proxy.copy_n_and_update(a, new_beg_pos, n);
B const p = ::boost::container::move_backward_overlapping(old_start, pos, new_beg_pos);
old_values_destroyer.release();
if (!trivial_dctr_after_move) {
(void)p;
boost::container::destroy_alloc(a, old_start, p);
}
}
}
}
template <class R, class InsertionProxy, class Allocator>
void expand_backward_forward_and_insert_alloc
( R const old_start
, std::size_t const old_size
, R const new_start
, R const pos
, std::size_t const n
, InsertionProxy insertion_proxy
, Allocator& a)
{
if(new_start < old_start){
expand_backward_forward_and_insert_alloc_move_backward(old_start, old_size, new_start, pos, n, insertion_proxy, a);
}
else{
expand_backward_forward_and_insert_alloc_move_forward(old_start, old_size, new_start, pos, n, insertion_proxy, a);
}
}

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

@@ -98,7 +98,7 @@
#define BOOST_CONTAINER_FORCEINLINE inline
#elif defined(BOOST_CONTAINER_FORCEINLINE_IS_BOOST_FORCELINE)
#define BOOST_CONTAINER_FORCEINLINE BOOST_FORCEINLINE
#elif defined(BOOST_MSVC) && (_MSC_VER < 1900 || defined(_DEBUG))
#elif defined(BOOST_MSVC) && (_MSC_VER <= 1900 || defined(_DEBUG))
//"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode
#define BOOST_CONTAINER_FORCEINLINE inline
#elif defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__))

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

File diff suppressed because it is too large Load Diff

92
include/boost/container/options.hpp
View File

@@ -232,24 +232,17 @@ class default_next_capacity;
typedef vector_opt<void, void> vector_null_opt;
template<class GrowthType, class StoredSizeType>
struct devector_opt
: vector_opt<GrowthType, StoredSizeType>
{};
typedef devector_opt<void, void> devector_null_opt;
#else //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
//!This growth factor argument specifies that the container should increase it's
//!This growth factor argument specifies that the container should increase its
//!capacity a 50% when existing capacity is exhausted.
struct growth_factor_50{};
//!This growth factor argument specifies that the container should increase it's
//!This growth factor argument specifies that the container should increase its
//!capacity a 60% when existing capacity is exhausted.
struct growth_factor_60{};
//!This growth factor argument specifies that the container should increase it's
//!This growth factor argument specifies that the container should increase its
//!capacity a 100% (doubling its capacity) when existing capacity is exhausted.
struct growth_factor_100{};
@@ -466,9 +459,82 @@ using static_vector_options_t = typename boost::container::static_vector_options
#endif
////////////////////////////////////////////////////////////////
//
//
// OPTIONS FOR DEVECTOR CONTAINER
//
//
////////////////////////////////////////////////////////////////
//!This option setter specifies the relocation strategy of the underlying devector.
//!
//!\tparam RelocationLimit A predefined occupation limit, used in insertions, that will determine
//! if the currently used memory buffer will be reused relocating all elements to the middle. If
//! the new occupation ratio (size()/current_buffer_size) is lower or equal than the limit, relocation
//! is performed reusing the same buffer. If the ratio is higher, a new buffer is allocated to hold
//! elements.
//!
//!Predefined relocation limits that can be passed as arguments to this option are:
//!\c boost::container::relocation_limit_66
//!\c boost::container::relocation_limit_75
//!\c boost::container::relocation_limit_80
//!\c boost::container::relocation_limit_86
//!\c boost::container::relocation_limit_90
//!
//!If this option is not specified, a default will be used by the container.
//!
//!Note: Repeated insertions at only one end (only back insertions or only front insertions) usually will
//!lead to a single relocation when `relocation_limit_66` is used and two relocations when `relocation_limit_90`
//!is used.
BOOST_INTRUSIVE_OPTION_TYPE(relocation_limit, RelocLimit, RelocLimit, relocation_limit_type)
#if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
template<class GrowthType, class StoredSizeType, class RelocLimit>
struct devector_opt
: vector_opt<GrowthType, StoredSizeType>
{
typedef RelocLimit relocation_limit_type;
};
typedef devector_opt<void, void, void> devector_null_opt;
#else
//!This relocation limit argument specifies that the container will relocate
//!all elements when there is no space at the side the insertion should
//!take place and memory usage is below 66% (2/3)
struct relocation_limit_66{};
//!This relocation limit argument specifies that the container will relocate
//!all elements when there is no space at the side the insertion should
//!take place and memory usage is below 75% (3/4)
struct relocation_limit_75 {};
//!This relocation limit argument specifies that the container will relocate
//!all elements when there is no space at the side the insertion should
//!take place and memory usage is below 80% (4/5)
struct relocation_limit_80 {};
//!This relocation limit argument specifies that the container will relocate
//!all elements when there is no space at the side the insertion should
//!take place and memory usage is below 86% (6/7)
struct relocation_limit_86 {};
//!This relocation limit argument specifies that the container will relocate
//!all elements when there is no space at the side the insertion should
//!take place and memory usage is below 90% (9/10)
struct relocation_limit_90 {};
#endif
//! Helper metafunction to combine options into a single type to be used
//! by \c boost::container::devector.
//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
//! Supported options are: \c boost::container::growth_factor, \c boost::container::stored_size
//! and \c boost::container::relocation_limit
#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
template<class ...Options>
#else
@@ -486,7 +552,9 @@ struct devector_options
#endif
>::type packed_options;
typedef devector_opt< typename packed_options::growth_factor_type
, typename packed_options::stored_size_type> implementation_defined;
, typename packed_options::stored_size_type
, typename packed_options::relocation_limit_type
> implementation_defined;
/// @endcond
typedef implementation_defined type;
};

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

@@ -353,7 +353,7 @@ struct vector_alloc_holder
, m_size(static_cast<stored_size_type>(initial_size))
, m_capacity()
{
if (initial_size > size_type(-1)){
if (BOOST_UNLIKELY(initial_size > size_type(-1))){
boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
}
else if(initial_size){
@@ -373,7 +373,7 @@ struct vector_alloc_holder
, m_size(static_cast<stored_size_type>(initial_size))
, m_capacity()
{
if (initial_size > size_type(-1)){
if (BOOST_UNLIKELY(initial_size > size_type(-1))){
boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
}
else if(initial_size){
@@ -437,11 +437,11 @@ struct vector_alloc_holder
return this->priv_allocation_command(alloc_version(), command, limit_size, prefer_in_recvd_out_size, reuse);
}
pointer allocate(size_type n)
BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type n)
{
const size_type max_alloc = allocator_traits_type::max_size(this->alloc());
const size_type max = max_alloc <= stored_size_type(-1) ? max_alloc : stored_size_type(-1);
if ( max < n )
if (BOOST_UNLIKELY(max < n) )
boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
return allocator_traits_type::allocate(this->alloc(), n);
@@ -544,7 +544,7 @@ struct vector_alloc_holder
BOOST_ASSERT( (command & allocate_new));
BOOST_ASSERT(!(command & nothrow_allocation));
//First detect overflow on smaller stored_size_types
if (limit_size > stored_size_type(-1)){
if (BOOST_UNLIKELY(limit_size > stored_size_type(-1))){
boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
}
(clamp_by_stored_size_type<size_type>)(prefer_in_recvd_out_size, stored_size_type());
@@ -559,7 +559,7 @@ struct vector_alloc_holder
pointer &reuse)
{
//First detect overflow on smaller stored_size_types
if (limit_size > stored_size_type(-1)){
if (BOOST_UNLIKELY(limit_size > stored_size_type(-1))){
boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
}
(clamp_by_stored_size_type<size_type>)(prefer_in_recvd_out_size, stored_size_type());
@@ -724,6 +724,7 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
};
struct growth_factor_60;
struct growth_factor_100;
template<class Options, class AllocatorSizeType>
struct get_vector_opt
@@ -1296,7 +1297,7 @@ private:
//For Fwd iterators the standard only requires EmplaceConstructible and assignable from *first
//so we can't do any backwards allocation
const it_size_type sz = boost::container::iterator_udistance(first, last);
if (sz > size_type(-1)){
if (BOOST_UNLIKELY(sz > size_type(-1))){
boost::container::throw_length_error("vector::assign, FwdIt's max length reached");
}
@@ -1819,7 +1820,7 @@ private:
return *p;
}
else{
typedef dtl::insert_emplace_proxy<allocator_type, T*, Args...> proxy_t;
typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
return *this->priv_insert_forward_range_no_capacity
(p, 1, proxy_t(::boost::forward<Args>(args)...), alloc_version());
}
@@ -1860,7 +1861,7 @@ private:
{
BOOST_ASSERT(this->priv_in_range_or_end(position));
//Just call more general insert(pos, size, value) and return iterator
typedef dtl::insert_emplace_proxy<allocator_type, T*, Args...> proxy_t;
typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
return this->priv_insert_forward_range( vector_iterator_get_ptr(position), 1
, proxy_t(::boost::forward<Args>(args)...));
}
@@ -1879,7 +1880,7 @@ private:
return *p;\
}\
else{\
typedef dtl::insert_emplace_proxy_arg##N<allocator_type, T* BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
typedef dtl::insert_emplace_proxy_arg##N<allocator_type BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
return *this->priv_insert_forward_range_no_capacity\
( p, 1, proxy_t(BOOST_MOVE_FWD##N), alloc_version());\
}\
@@ -1901,7 +1902,7 @@ private:
BOOST_CONTAINER_FORCEINLINE iterator emplace(const_iterator pos BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
{\
BOOST_ASSERT(this->priv_in_range_or_end(pos));\
typedef dtl::insert_emplace_proxy_arg##N<allocator_type, T* BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
typedef dtl::insert_emplace_proxy_arg##N<allocator_type BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
return this->priv_insert_forward_range(vector_iterator_get_ptr(pos), 1, proxy_t(BOOST_MOVE_FWD##N));\
}\
//
@@ -1967,7 +1968,7 @@ private:
BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, size_type n, const T& x)
{
BOOST_ASSERT(this->priv_in_range_or_end(p));
dtl::insert_n_copies_proxy<allocator_type, T*> proxy(x);
dtl::insert_n_copies_proxy<allocator_type> proxy(x);
return this->priv_insert_forward_range(vector_iterator_get_ptr(p), n, proxy);
}
@@ -2015,11 +2016,11 @@ private:
typedef typename iter_size<FwdIt>::type it_size_type;
BOOST_ASSERT(this->priv_in_range_or_end(pos));
const it_size_type sz = boost::container::iterator_udistance(first, last);
if (sz > size_type(-1)){
if (BOOST_UNLIKELY(sz > size_type(-1))){
boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
}
dtl::insert_range_proxy<allocator_type, FwdIt, T*> proxy(first);
dtl::insert_range_proxy<allocator_type, FwdIt> proxy(first);
return this->priv_insert_forward_range(vector_iterator_get_ptr(pos), static_cast<size_type>(sz), proxy);
}
#endif
@@ -2047,7 +2048,7 @@ private:
BOOST_ASSERT(dtl::is_input_iterator<InIt>::value ||
num == boost::container::iterator_udistance(first, last));
(void)last;
dtl::insert_range_proxy<allocator_type, InIt, T*> proxy(first);
dtl::insert_range_proxy<allocator_type, InIt> proxy(first);
return this->priv_insert_forward_range(vector_iterator_get_ptr(pos), num, proxy);
}
#endif
@@ -2591,9 +2592,9 @@ private:
BOOST_CONTAINER_FORCEINLINE void priv_move_to_new_buffer(size_type, version_0)
{ alloc_holder_t::on_capacity_overflow(); }
BOOST_CONTAINER_FORCEINLINE dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*>, T*> priv_dummy_empty_proxy()
BOOST_CONTAINER_FORCEINLINE dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*> > priv_dummy_empty_proxy()
{
return dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*>, T*>
return dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*> >
(::boost::make_move_iterator((T *)0));
}
@@ -2688,14 +2689,14 @@ private:
BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator, ::boost::move_detail::nat)
{ return iterator(); }
BOOST_CONTAINER_FORCEINLINE dtl::insert_n_copies_proxy<allocator_type, T*> priv_resize_proxy(const T &x)
{ return dtl::insert_n_copies_proxy<allocator_type, T*>(x); }
BOOST_CONTAINER_FORCEINLINE dtl::insert_n_copies_proxy<allocator_type> priv_resize_proxy(const T &x)
{ return dtl::insert_n_copies_proxy<allocator_type>(x); }
BOOST_CONTAINER_FORCEINLINE dtl::insert_default_initialized_n_proxy<allocator_type, T*> priv_resize_proxy(default_init_t)
{ return dtl::insert_default_initialized_n_proxy<allocator_type, T*>(); }
BOOST_CONTAINER_FORCEINLINE dtl::insert_default_initialized_n_proxy<allocator_type> priv_resize_proxy(default_init_t)
{ return dtl::insert_default_initialized_n_proxy<allocator_type>(); }
BOOST_CONTAINER_FORCEINLINE dtl::insert_value_initialized_n_proxy<allocator_type, T*> priv_resize_proxy(value_init_t)
{ return dtl::insert_value_initialized_n_proxy<allocator_type, T*>(); }
BOOST_CONTAINER_FORCEINLINE dtl::insert_value_initialized_n_proxy<allocator_type> priv_resize_proxy(value_init_t)
{ return dtl::insert_value_initialized_n_proxy<allocator_type>(); }
BOOST_CONTAINER_FORCEINLINE void priv_shrink_to_fit(version_0) BOOST_NOEXCEPT_OR_NOTHROW
{}
@@ -2986,7 +2987,8 @@ private:
}
template <class InsertionProxy>
BOOST_CONTAINER_FORCEINLINE void priv_insert_forward_range_expand_forward(T* const raw_pos, const size_type n, InsertionProxy insert_range_proxy, dtl::false_type)
BOOST_CONTAINER_FORCEINLINE void priv_insert_forward_range_expand_forward
(T* const raw_pos, const size_type n, InsertionProxy insert_range_proxy, dtl::false_type)
{
//There is enough memory
boost::container::expand_forward_and_insert_alloc
@@ -3024,321 +3026,19 @@ private:
(T* const new_start, const size_type new_capacity,
T* const pos, const size_type n, InsertionProxy insert_range_proxy)
{
//n can be zero to just expand capacity
//Backup old data
T* const old_start = this->priv_raw_begin();
T* const old_start = this->priv_raw_begin();
const size_type old_size = this->m_holder.m_size;
T* const old_finish = old_start + old_size;
allocator_type &a = this->m_holder.alloc();
allocator_type& a = this->m_holder.alloc();
//Update the vector buffer information to a safe state
this->m_holder.start(new_start);
this->m_holder.capacity(new_capacity);
this->m_holder.m_size = 0;
//We can have 8 possibilities:
const size_type elemsbefore = static_cast<size_type>(pos - old_start);
const size_type s_before = static_cast<size_type>(old_start - new_start);
const size_type before_plus_new = size_type(elemsbefore + n);
expand_backward_forward_and_insert_alloc(old_start, old_size, new_start, pos, n, insert_range_proxy, a);
typedef typename value_traits::ArrayDestructor array_destructor_t;
//If anything goes wrong, this object will destroy
//all the old objects to fulfill previous vector state
array_destructor_t old_values_destroyer(old_start, a, old_size);
//Check if s_before is big enough to hold the beginning of old data + new data
if(s_before >= before_plus_new){
//Copy first old values before pos, after that the new objects
T *const new_elem_pos =
::boost::container::uninitialized_move_alloc(a, old_start, pos, new_start);
this->m_holder.set_stored_size(elemsbefore);
insert_range_proxy.uninitialized_copy_n_and_update(a, new_elem_pos, n);
this->m_holder.set_stored_size(before_plus_new);
const size_type new_size = size_type(old_size + n);
//Check if s_before is so big that even copying the old data + new data
//there is a gap between the new data and the old data
if(s_before >= new_size){
//Old situation:
// _________________________________________________________
//| raw_mem | old_begin | old_end |
//| __________________________________|___________|_________|
//
//New situation:
// _________________________________________________________
//| old_begin | new | old_end | raw_mem |
//|___________|__________|_________|________________________|
//
//Now initialize the rest of memory with the last old values
if(before_plus_new != new_size){ //Special case to avoid operations in back insertion
::boost::container::uninitialized_move_alloc(a, pos, old_finish, new_start + before_plus_new);
//All new elements correctly constructed, avoid new element destruction
this->m_holder.set_stored_size(new_size);
}
//Old values destroyed automatically with "old_values_destroyer"
//when "old_values_destroyer" goes out of scope unless the have trivial
//destructor after move.
BOOST_IF_CONSTEXPR(value_traits::trivial_dctr_after_move)
old_values_destroyer.release();
}
//s_before is so big that divides old_end
else{
//Old situation:
// __________________________________________________
//| raw_mem | old_begin | old_end |
//| ___________________________|___________|_________|
//
//New situation:
// __________________________________________________
//| old_begin | new | old_end | raw_mem |
//|___________|__________|_________|_________________|
//
//Now initialize the rest of memory with the last old values
//All new elements correctly constructed, avoid new element destruction
BOOST_IF_CONSTEXPR(!value_traits::trivial_dctr){
const size_type raw_gap = s_before - before_plus_new;
//Now initialize the rest of s_before memory with the
//first of elements after new values
::boost::container::uninitialized_move_alloc_n(a, pos, raw_gap, new_start + before_plus_new);
//Now we have a contiguous buffer so program trailing element destruction
//and update size to the final size.
old_values_destroyer.shrink_forward(new_size-s_before);
this->m_holder.set_stored_size(new_size);
//Now move remaining last objects in the old buffer begin
T * const remaining_pos = pos + raw_gap;
if(remaining_pos != old_start){ //Make sure data has to be moved
::boost::container::move(remaining_pos, old_finish, old_start);
}
//Once moved, avoid calling the destructors if trivial after move
BOOST_IF_CONSTEXPR(value_traits::trivial_dctr_after_move){
old_values_destroyer.release();
}
}
else{ //If trivial destructor, we can uninitialized copy + copy in a single uninitialized copy
::boost::container::uninitialized_move_alloc_n
(a, pos, static_cast<size_type>(old_finish - pos), new_start + before_plus_new);
this->m_holder.set_stored_size(new_size);
old_values_destroyer.release();
}
}
}
else{
//Check if we have to do the insertion in two phases
//since maybe s_before is not big enough and
//the buffer was expanded both sides
//
//Old situation:
// _________________________________________________
//| raw_mem | old_begin + old_end | raw_mem |
//|_________|_____________________|_________________|
//
//New situation with do_after:
// _________________________________________________
//| old_begin + new + old_end | raw_mem |
//|___________________________________|_____________|
//
//New without do_after:
// _________________________________________________
//| old_begin + new + old_end | raw_mem |
//|____________________________|____________________|
//
const bool do_after = n > s_before;
//Now we can have two situations: the raw_mem of the
//beginning divides the old_begin, or the new elements:
if (s_before <= elemsbefore) {
//The raw memory divides the old_begin group:
//
//If we need two phase construction (do_after)
//new group is divided in new = new_beg + new_end groups
//In this phase only new_beg will be inserted
//
//Old situation:
// _________________________________________________
//| raw_mem | old_begin | old_end | raw_mem |
//|_________|___________|_________|_________________|
//
//New situation with do_after(1):
//This is not definitive situation, the second phase
//will include
// _________________________________________________
//| old_begin | new_beg | old_end | raw_mem |
//|___________|_________|_________|_________________|
//
//New situation without do_after:
// _________________________________________________
//| old_begin | new | old_end | raw_mem |
//|___________|_____|_________|_____________________|
//
//Copy the first part of old_begin to raw_mem
::boost::container::uninitialized_move_alloc_n(a, old_start, s_before, new_start);
//The buffer is all constructed until old_end,
//so program trailing destruction and assign final size
//if !do_after, s_before+n otherwise.
size_type new_1st_range;
if(do_after){
new_1st_range = s_before;
//release destroyer and update size
old_values_destroyer.release();
}
else{
new_1st_range = n;
BOOST_IF_CONSTEXPR(value_traits::trivial_dctr_after_move){
old_values_destroyer.release();
}
else{
old_values_destroyer.shrink_forward(old_size - (s_before - n));
}
}
this->m_holder.set_stored_size(size_type(old_size + new_1st_range));
//Now copy the second part of old_begin overwriting itself
T *const next = ::boost::container::move(old_start + s_before, pos, old_start);
//Now copy the new_beg elements
insert_range_proxy.copy_n_and_update(a, next, new_1st_range);
//If there is no after work and the last old part needs to be moved to front, do it
if(!do_after && (n != s_before)){
//Now displace old_end elements
::boost::container::move(pos, old_finish, next + new_1st_range);
}
}
else {
//If we have to expand both sides,
//we will play if the first new values so
//calculate the upper bound of new values
//The raw memory divides the new elements
//
//If we need two phase construction (do_after)
//new group is divided in new = new_beg + new_end groups
//In this phase only new_beg will be inserted
//
//Old situation:
// _______________________________________________________
//| raw_mem | old_begin | old_end | raw_mem |
//|_______________|___________|_________|_________________|
//
//New situation with do_after():
// ____________________________________________________
//| old_begin | new_beg | old_end | raw_mem |
//|___________|_______________|_________|______________|
//
//New situation without do_after:
// ______________________________________________________
//| old_begin | new | old_end | raw_mem |
//|___________|_____|_________|__________________________|
//
//First copy whole old_begin and part of new to raw_mem
T * const new_pos = ::boost::container::uninitialized_move_alloc
(a, old_start, pos, new_start);
this->m_holder.set_stored_size(elemsbefore);
const size_type mid_n = size_type(s_before - elemsbefore);
insert_range_proxy.uninitialized_copy_n_and_update(a, new_pos, mid_n);
//The buffer is all constructed until old_end,
//release destroyer
this->m_holder.set_stored_size(size_type(old_size + s_before));
old_values_destroyer.release();
if(do_after){
//Copy new_beg part
insert_range_proxy.copy_n_and_update(a, old_start, elemsbefore);
}
else{
//Copy all new elements
const size_type rest_new = size_type(n - mid_n);
insert_range_proxy.copy_n_and_update(a, old_start, rest_new);
T* const move_start = old_start + rest_new;
//Displace old_end, but make sure data has to be moved
T* const move_end = move_start != pos ? ::boost::container::move(pos, old_finish, move_start)
: old_finish;
(void)move_end; //To avoid warnings of unused initialization for move_end in case
//trivial_dctr_after_move is true
//Destroy remaining moved elements from old_end except if they
//have trivial destructor after being moved
const size_type n_destroy = size_type(s_before - n);
BOOST_IF_CONSTEXPR(!value_traits::trivial_dctr_after_move){
boost::container::destroy_alloc_n(a, move_end, n_destroy);
}
this->m_holder.dec_stored_size(n_destroy);
}
}
//This is only executed if two phase construction is needed
if(do_after){
//The raw memory divides the new elements
//
//Old situation:
// ______________________________________________________
//| raw_mem | old_begin | old_end | raw_mem |
//|______________|___________|____________|______________|
//
//New situation with do_after(1):
// _______________________________________________________
//| old_begin + new_beg | new_end |old_end | raw_mem |
//|__________________________|_________|________|_________|
//
//New situation with do_after(2):
// ______________________________________________________
//| old_begin + new | old_end |raw |
//|_______________________________________|_________|____|
//
const size_type n_after = size_type(n - s_before);
const size_type elemsafter = size_type(old_size - elemsbefore);
//We can have two situations:
if (elemsafter >= n_after){
//The raw_mem from end will divide displaced old_end
//
//Old situation:
// ______________________________________________________
//| raw_mem | old_begin | old_end | raw_mem |
//|______________|___________|____________|______________|
//
//New situation with do_after(1):
// _______________________________________________________
//| old_begin + new_beg | new_end |old_end | raw_mem |
//|__________________________|_________|________|_________|
//
//First copy the part of old_end raw_mem
T* finish_n = old_finish - n_after;
::boost::container::uninitialized_move_alloc(a, finish_n, old_finish, old_finish);
this->m_holder.inc_stored_size(n_after);
//Displace the rest of old_end to the new position
boost::container::move_backward(pos, finish_n, old_finish);
//Now overwrite with new_end
//The new_end part is [first + (n - n_after), last)
insert_range_proxy.copy_n_and_update(a, pos, n_after);
}
else {
//The raw_mem from end will divide new_end part
//
//Old situation:
// _____________________________________________________________
//| raw_mem | old_begin | old_end | raw_mem |
//|______________|___________|____________|_____________________|
//
//New situation with do_after(2):
// _____________________________________________________________
//| old_begin + new_beg | new_end |old_end | raw_mem |
//|__________________________|_______________|________|_________|
//First initialize data in raw memory
const size_type mid_last_dist = size_type(n_after - elemsafter);
//Copy to the old_end part to the uninitialized zone leaving a gap.
::boost::container::uninitialized_move_alloc(a, pos, old_finish, old_finish + mid_last_dist);
array_destructor_t old_end_destroyer(old_finish + mid_last_dist, a, static_cast<size_type>(old_finish - pos));
//Copy the first part to the already constructed old_end zone
insert_range_proxy.copy_n_and_update(a, pos, elemsafter);
//Copy the rest to the uninitialized zone filling the gap
insert_range_proxy.uninitialized_copy_n_and_update(a, old_finish, mid_last_dist);
this->m_holder.inc_stored_size(n_after);
old_end_destroyer.release();
}
}
}
//Update the vector buffer information to a safe state
this->m_holder.m_size = stored_size_type(old_size + n);
}
void priv_throw_if_out_of_range(size_type n) const

54
proj/vs/container.sln
View File

@@ -1,6 +1,6 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.30204.135
# Visual Studio Version 17
VisualStudioVersion = 17.2.32526.322
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_containerlib", "container.vcxproj", "{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}"
EndProject
@@ -198,6 +198,16 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "boost_iterator_comp_test",
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "common_iterator_test", "common_iterator_test.vcxproj", "{3E10C8C3-4F8E-96A0-4FA2-32BA7AE46392}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hash_map_string_test", "hash_map_string_test.vcxproj", "{58CCE183-6092-48FE-A4F7-B6979D8A0642}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hash_map_uint32_test", "hash_map_uint32_test.vcxproj", "{58CCE183-6092-48FE-A4F7-B7946A2D3A06}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hash_map_uint64_test", "hash_map_uint64_test.vcxproj", "{58CCE183-6092-48FE-F7A4-B6946A5D3A06}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hash_map_test", "hash_map_test.vcxproj", "{58CCE183-6092-48FE-FA47-B792603093A6}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "copy_move_algo_test", "copy_move_algo_test.vcxproj", "{5CE11C83-84A7-093A-4FA2-A6BA20A30592}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
@@ -946,6 +956,46 @@ Global
{3E10C8C3-4F8E-96A0-4FA2-32BA7AE46392}.Release|x64.Build.0 = Release|x64
{3E10C8C3-4F8E-96A0-4FA2-32BA7AE46392}.Release|x86.ActiveCfg = Release|Win32
{3E10C8C3-4F8E-96A0-4FA2-32BA7AE46392}.Release|x86.Build.0 = Release|Win32
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Debug|x64.ActiveCfg = Debug|x64
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Debug|x64.Build.0 = Debug|x64
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Debug|x86.ActiveCfg = Debug|Win32
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Debug|x86.Build.0 = Debug|Win32
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Release|x64.ActiveCfg = Release|x64
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Release|x64.Build.0 = Release|x64
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Release|x86.ActiveCfg = Release|Win32
{58CCE183-6092-48FE-A4F7-B6979D8A0642}.Release|x86.Build.0 = Release|Win32
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Debug|x64.ActiveCfg = Debug|x64
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Debug|x64.Build.0 = Debug|x64
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Debug|x86.ActiveCfg = Debug|Win32
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Debug|x86.Build.0 = Debug|Win32
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Release|x64.ActiveCfg = Release|x64
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Release|x64.Build.0 = Release|x64
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Release|x86.ActiveCfg = Release|Win32
{58CCE183-6092-48FE-A4F7-B7946A2D3A06}.Release|x86.Build.0 = Release|Win32
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Debug|x64.ActiveCfg = Debug|x64
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Debug|x64.Build.0 = Debug|x64
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Debug|x86.ActiveCfg = Debug|Win32
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Debug|x86.Build.0 = Debug|Win32
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Release|x64.ActiveCfg = Release|x64
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Release|x64.Build.0 = Release|x64
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Release|x86.ActiveCfg = Release|Win32
{58CCE183-6092-48FE-F7A4-B6946A5D3A06}.Release|x86.Build.0 = Release|Win32
{58CCE183-6092-48FE-FA47-B792603093A6}.Debug|x64.ActiveCfg = Debug|x64
{58CCE183-6092-48FE-FA47-B792603093A6}.Debug|x64.Build.0 = Debug|x64
{58CCE183-6092-48FE-FA47-B792603093A6}.Debug|x86.ActiveCfg = Debug|Win32
{58CCE183-6092-48FE-FA47-B792603093A6}.Debug|x86.Build.0 = Debug|Win32
{58CCE183-6092-48FE-FA47-B792603093A6}.Release|x64.ActiveCfg = Release|x64
{58CCE183-6092-48FE-FA47-B792603093A6}.Release|x64.Build.0 = Release|x64
{58CCE183-6092-48FE-FA47-B792603093A6}.Release|x86.ActiveCfg = Release|Win32
{58CCE183-6092-48FE-FA47-B792603093A6}.Release|x86.Build.0 = Release|Win32
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Debug|x64.ActiveCfg = Debug|x64
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Debug|x64.Build.0 = Debug|x64
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Debug|x86.ActiveCfg = Debug|Win32
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Debug|x86.Build.0 = Debug|Win32
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Release|x64.ActiveCfg = Release|x64
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Release|x64.Build.0 = Release|x64
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Release|x86.ActiveCfg = Release|Win32
{5CE11C83-84A7-093A-4FA2-A6BA20A30592}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

127
test/devector_options_test.cpp
View File

@@ -53,6 +53,13 @@ void test_stored_size_type()
typedef devector<unsigned char, allocator<unsigned char>, options_t> devector_t;
test_stored_size_type_impl<Unsigned, devector_t>();
}
//Test size reduction
{
typedef devector<unsigned char, void, options_t> devector_t;
BOOST_STATIC_ASSERT( sizeof(Unsigned) >= sizeof(std::size_t) ||
sizeof(devector_t) < sizeof(devector<unsigned char>) );
}
}
void test_growth_factor_50()
@@ -64,13 +71,10 @@ void test_growth_factor_50()
< growth_factor<growth_factor_50> >::type options_t;
#endif
devector<int, new_allocator<int>, options_t> v;
v.resize(5);
v.resize(v.capacity());
std::size_t old_capacity = v.capacity();
devector<int, new_allocator<int>, options_t> v(5u, 0);
std::size_t old_capacity = v.size() + v.back_free_capacity() + v.front_free_capacity();
v.push_back(0);
std::size_t new_capacity = v.capacity();
std::size_t new_capacity = v.size() + v.back_free_capacity() + v.front_free_capacity();
BOOST_TEST(new_capacity == old_capacity + old_capacity/2);
}
@@ -83,13 +87,11 @@ void test_growth_factor_60()
< growth_factor<growth_factor_60> >::type options_t;
#endif
devector<int, new_allocator<int>, options_t> v;
devector<int, new_allocator<int>, options_t> v(5u, 0);
v.resize(5);
v.resize(v.capacity());
std::size_t old_capacity = v.capacity();
std::size_t old_capacity = v.size()+v.back_free_capacity()+v.front_free_capacity();
v.push_back(0);
std::size_t new_capacity = v.capacity();
std::size_t new_capacity = v.size() + v.back_free_capacity() + v.front_free_capacity();
BOOST_TEST(new_capacity == old_capacity + 3*old_capacity/5);
}
@@ -102,16 +104,105 @@ void test_growth_factor_100()
< growth_factor<growth_factor_100> >::type options_t;
#endif
devector<int, new_allocator<int>, options_t> v;
v.resize(5);
v.resize(v.capacity());
std::size_t old_capacity = v.capacity();
devector<int, new_allocator<int>, options_t> v(5,0);
std::size_t old_capacity = v.size() + v.back_free_capacity() + v.front_free_capacity();
v.push_back(0);
std::size_t new_capacity = v.capacity();
std::size_t new_capacity = v.size() + v.back_free_capacity() + v.front_free_capacity();
BOOST_TEST(new_capacity == 2*old_capacity);
}
void test_stored_relloc_limit_66()
{
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
using options_t = devector_options_t< relocation_limit<relocation_limit_66> >;
#else
typedef devector_options
< relocation_limit<relocation_limit_66> >::type options_t;
#endif
const std::size_t buffer_size = 32u;
const std::size_t initial_side = buffer_size/2u;
devector<int, new_allocator<int>, options_t> v(initial_side, initial_side, reserve_only_tag_t());
const int* buffer = v.data();
const int* buffer_start = v.data() - initial_side;
std::size_t old_cp = v.capacity();
for ( int i = 0u; i != (int)initial_side; ++i) {
v.push_back(i);
}
BOOST_TEST(v.back_free_capacity() == 0);
BOOST_TEST(buffer == v.data());
v.push_back(0);
BOOST_TEST(v.size() == initial_side + 1u);
//Relocation -> 9 elements on the left, 8 elements on the right
BOOST_TEST(v.front_free_capacity() == (buffer_size - v.size())/2u);
BOOST_TEST(v.data() == buffer_start + v.front_free_capacity());
BOOST_TEST(v.capacity() == old_cp);
//Reach the back limit again
for (int i = 0u, max = (int)v.back_free_capacity(); i != max; ++i) {
v.push_back(-i);
}
BOOST_TEST(v.back_free_capacity() == 0);
//New insertion should reallocate
v.push_back(-1);
BOOST_TEST(v.back_free_capacity() > 8);
BOOST_TEST(v.capacity() > old_cp);
}
void test_stored_relloc_limit_90()
{
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
using options_t = devector_options_t< relocation_limit<relocation_limit_90> >;
#else
typedef devector_options
< relocation_limit<relocation_limit_90> >::type options_t;
#endif
const std::size_t buffer_size = 32u;
const std::size_t initial_side = buffer_size/2u;
devector<int, new_allocator<int>, options_t> v(initial_side, initial_side, reserve_only_tag_t());
const int* buffer = v.data();
const int* buffer_start = v.data() - initial_side;
std::size_t old_cp = v.capacity();
for ( int i = 0u; i != (int)initial_side; ++i) {
v.push_back(i);
}
BOOST_TEST(v.back_free_capacity() == 0);
BOOST_TEST(buffer == v.data());
v.push_back(0);
BOOST_TEST(v.size() == initial_side + 1u);
//Relocation -> 9 elements on the left, 8 elements on the right
BOOST_TEST(v.front_free_capacity() == (buffer_size - v.size())/2u);
BOOST_TEST(v.data() == buffer_start + v.front_free_capacity());
BOOST_TEST(v.capacity() == old_cp);
//Reach the back limit again
for (int i = 0u, max = (int)v.back_free_capacity(); i != max; ++i) {
v.push_back(-i);
}
BOOST_TEST(v.back_free_capacity() == 0);
//New insertion should relocate again
v.push_back(-1);
BOOST_TEST(v.capacity() == old_cp);
BOOST_TEST(v.front_free_capacity() == (buffer_size - v.size()) / 2u);
BOOST_TEST(v.data() == buffer_start + v.front_free_capacity());
//Reach the back limit again
for (int i = 0u, max = (int)v.back_free_capacity(); i != max; ++i) {
v.push_back(-i);
}
BOOST_TEST(v.back_free_capacity() == 0);
//Last insertion should reallocate
v.push_back(-1);
BOOST_TEST(v.capacity() > old_cp);
}
int main()
{
test_growth_factor_50();
@@ -119,5 +210,7 @@ int main()
test_growth_factor_100();
test_stored_size_type<unsigned char>();
test_stored_size_type<unsigned short>();
test_stored_relloc_limit_66();
test_stored_relloc_limit_90();
return ::boost::report_errors();
}

432
test/devector_test.cpp
View File

@@ -14,7 +14,9 @@
#include <iostream>
#include <algorithm>
#include <limits>
#include <memory>
#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>
@@ -23,6 +25,7 @@
#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>
@@ -33,6 +36,9 @@
#include "test_util.hpp"
#include "test_elem.hpp"
#include "input_iterator.hpp"
#include "vector_test.hpp"
#include "default_init_test.hpp"
#include "../../intrusive/test/iterator_test.hpp"
using namespace boost::container;
@@ -109,7 +115,8 @@ template <class Devector> void test_constructor_reserve_only_front_back()
{
Devector a(8, 8, reserve_only_tag_t());
BOOST_TEST(a.size() == 0u);
BOOST_TEST(a.capacity() >= 16u);
BOOST_TEST(a.front_free_capacity() >= 8u);
BOOST_TEST(a.back_free_capacity() >= 8u);
for (int i = 8; i; --i)
{
@@ -474,6 +481,7 @@ template <class Devector> void test_assignment()
BOOST_TEST(a.get_alloc_count() == alloc_count);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
typedef typename Devector::value_type T;
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
@@ -491,6 +499,7 @@ template <class Devector> void test_assignment()
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
*/
}
template <class Devector> void test_move_assignment_throwing(dtl::true_)
@@ -551,7 +560,7 @@ template <class Devector> void test_move_assignment()
test_equal_range(b);
}
typedef typename Devector::value_type T;
typedef typename Devector::value_type T;
test_move_assignment_throwing<Devector>
(boost::move_detail::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
}
@@ -566,12 +575,15 @@ template <class Devector> void test_il_assignment()
test_equal_range(a, {1, 2, 3, 4, 5, 6});
}
//Visual 2013 has some problems with empty initializer lists.
#if defined(_MSC_VER) && (_MSC_VER > 1800)
{ // assign from empty
Devector a; get_range<Devector>(6, a);
a = {};
test_equal_range(a);
}
#endif
{ // assign to non-empty
Devector a; get_range<Devector>(11, 15, 15, 19, a);
@@ -614,10 +626,10 @@ template <class Devector> void test_il_assignment()
test_equal_range(a, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
typedef typename Devector::value_type T;
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -635,7 +647,7 @@ template <class Devector> void test_il_assignment()
test_equal_range(a, {1, 2, 3, 4, 5, 6});
}
#endif //BOOST_NO_EXCEPTIONS
#endif //BOOST_NO_EXCEPTIONS*/
#endif //#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
}
@@ -734,8 +746,9 @@ template <class Devector> void test_assign_input_range()
test_equal_range(a, expected);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
@@ -753,6 +766,7 @@ template <class Devector> void test_assign_input_range()
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
*/
}
template <class Devector> void test_assign_forward_range_throwing(dtl::false_)
@@ -847,7 +861,7 @@ template <class Devector> void test_assign_forward_range()
test_equal_range(a, expected);
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
BOOST_IF_CONSTEXPR(! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
@@ -861,7 +875,7 @@ template <class Devector> void test_assign_forward_range()
const int expected [] = {1, 2, 3, 4, 5, 6};
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
#endif //#ifndef BOOST_NO_EXCEPTIONS*/
}
template <class Devector> void test_assign_pointer_range()
@@ -935,9 +949,9 @@ template <class Devector> void test_assign_pointer_range()
test_equal_range(a, expected);
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -949,7 +963,7 @@ template <class Devector> void test_assign_pointer_range()
const int expected[] = {1, 2, 3, 4, 5, 6};
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
#endif //#ifndef BOOST_NO_EXCEPTIONS*/
}
template <class Devector> void test_assign_n()
@@ -1018,9 +1032,9 @@ template <class Devector> void test_assign_n()
test_equal_range(a, expected);
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -1033,6 +1047,7 @@ template <class Devector> void test_assign_n()
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
*/
}
template <class Devector> void test_assign_il()
@@ -1096,10 +1111,10 @@ template <class Devector> void test_assign_il()
test_equal_range(a, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
typedef typename Devector::value_type T;
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -1110,7 +1125,7 @@ template <class Devector> void test_assign_il()
test_equal_range(a, {1, 2, 3, 4, 5, 6});
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
#endif //#ifndef BOOST_NO_EXCEPTIONS*/
#endif //#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
}
@@ -1394,7 +1409,7 @@ template <class Devector> void test_resize_front_copy()
// size < required, tmp is already inserted
{
Devector f; get_range<Devector>(8, f);
const T& tmp = *(f.begin() + 1);
T tmp = *(f.begin() + 1);
f.resize_front(16, tmp);
const int expected[] = {2,2,2,2,2,2,2,2,1,2,3,4,5,6,7,8};
test_equal_range(f, expected);
@@ -1587,7 +1602,7 @@ template <class Devector> void test_resize_back_copy()
// size < required, tmp is already inserted
{
Devector f; get_range<Devector>(8, f);
const T& tmp = *(f.begin() + 1);
T tmp = *(f.begin() + 1);
f.resize_back(16, tmp);
const int expected [] = {1,2,3,4,5,6,7,8,2,2,2,2,2,2,2,2};
test_equal_range(f, expected);
@@ -1997,7 +2012,7 @@ template <class Devector> void test_push_front()
// test when tmp is already inserted
{
Devector c; get_range<Devector>(4, c);
const T& tmp = *(c.begin() + 1);
T tmp = *(c.begin() + 1);
c.push_front(tmp);
const int expected[] = {2, 1, 2, 3, 4};
test_equal_range(c, expected);
@@ -2045,7 +2060,7 @@ template <class Devector> void test_push_front_rvalue()
test_equal_range(a, expected);
}
test_push_front_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
//test_push_front_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
}
template <class Devector> void test_pop_front()
@@ -2104,8 +2119,6 @@ template <class Devector> void test_emplace_back_throwing(dtl::false_)
template <class Devector> void test_emplace_back()
{
typedef typename Devector::value_type T;
{
Devector a;
@@ -2117,9 +2130,9 @@ template <class Devector> void test_emplace_back()
test_equal_range<Devector>(a, expected);
}
test_emplace_back_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
//typedef typename Devector::value_type T;
//test_emplace_back_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
}
template <class Devector> void test_push_back_throwing(dtl::true_)
@@ -2157,18 +2170,19 @@ template <class Devector> void test_push_back()
for (int i = 1; i <= 16; ++i)
{
T elem(i);
a.push_back(elem);
}
test_equal_range(a, expected);
}
test_push_back_throwing<Devector>(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
//test_push_back_throwing<Devector>(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
// test when tmp is already inserted
{
Devector c; get_range<Devector>(4, c);
const T& tmp = *(c.begin() + 1);
T tmp = *(c.begin() + 1);
c.push_back(tmp);
const int expected[] = {1, 2, 3, 4, 2};
test_equal_range(c, expected);
@@ -2215,131 +2229,9 @@ template <class Devector> void test_push_back_rvalue()
test_equal_range(a, expected);
}
test_push_back_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
//test_push_back_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
}
/*
template <class Devector> void test_unsafe_push_front()
{
typedef typename Devector::value_type T;
typedef typename Devector::iterator iterator;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
std::reverse(expected.begin(), expected.end());
Devector a;
a.reserve_front(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_front(elem);
}
test_equal_range(a, expected);
}
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
Devector b; get_range<Devector>(4, b);
b.reserve_front(5);
iterator origi_begin = b.begin();
const T elem(404);
test_elem_throw::on_copy_after(1);
BOOST_TEST_THROWS(b.unsafe_push_front(elem), test_exception);
test_elem_throw::do_not_throw();
iterator new_begin = b.begin();
BOOST_TEST(origi_begin == new_begin);
BOOST_TEST(b.size() == 4u);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
}
template <class Devector> void test_unsafe_push_front_rvalue()
{
typedef typename Devector::value_type T;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
std::reverse(expected.begin(), expected.end());
Devector a;
a.reserve_front(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_front(boost::move(elem));
}
test_equal_range(a, expected);
}
}
*/
/*
template <class Devector> void test_unsafe_push_back()
{
typedef typename Devector::value_type T;
typedef typename Devector::iterator iterator;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
Devector a;
a.reserve(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_back(elem);
}
test_equal_range(a, expected);
}
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
Devector b; get_range<Devector>(4, b);
b.reserve(5);
iterator origi_begin = b.begin();
const T elem(404);
test_elem_throw::on_copy_after(1);
BOOST_TEST_THROWS(b.unsafe_push_back(elem), test_exception);
test_elem_throw::do_not_throw();
iterator new_begin = b.begin();
BOOST_TEST(origi_begin == new_begin);
BOOST_TEST(b.size() == 4u);
}
#endif
}
template <class Devector> void test_unsafe_push_back_rvalue()
{
typedef typename Devector::value_type T;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
Devector a;
a.reserve(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_back(boost::move(elem));
}
test_equal_range(a, expected);
}
}
*/
template <class Devector> void test_pop_back()
{
{
@@ -2384,8 +2276,8 @@ template <class Devector> void test_emplace_throwing(dtl::true_)
BOOST_TEST_THROWS(j.emplace(j.begin() + 2, 404), test_exception);
test_elem_throw::do_not_throw();
const int expected[] = {1, 2, 3, 4};
test_equal_range(j, expected);
//const int expected[] = {1, 2, 3, 4};
//test_equal_range(j, expected);
BOOST_TEST(origi_begin == j.begin());
#endif
}
@@ -2468,7 +2360,8 @@ template <class Devector> void test_emplace()
Devector h; get_range<Devector>(16, h);
h.pop_front();
h.pop_back();
iterator valid = h.begin() + 7;
//Inserting in the middle, leads to back insertion
iterator valid = h.begin() + 8;
typename Devector::iterator it = h.emplace(h.begin() + 7, 123);
const int expected[] = {2, 3, 4, 5, 6, 7, 8, 123, 9, 10, 11, 12, 13, 14, 15};
test_equal_range(h, expected);
@@ -2488,9 +2381,9 @@ template <class Devector> void test_emplace()
test_equal_range(i, expected);
}
typedef typename Devector::value_type T;
test_emplace_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
//typedef typename Devector::value_type T;
//test_emplace_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
}
template <class Devector> void test_insert_throwing(dtl::true_)
@@ -2508,8 +2401,8 @@ template <class Devector> void test_insert_throwing(dtl::true_)
BOOST_TEST_THROWS(j.insert(j.begin() + 2, test_elem), test_exception);
test_elem_throw::do_not_throw();
const int expected[] = {1, 2, 3, 4};
test_equal_range(j, expected);
//const int expected[] = {1, 2, 3, 4};
//test_equal_range(j, expected);
BOOST_TEST(origi_begin == j.begin());
#endif //#ifndef BOOST_NO_EXCEPTIONS
}
@@ -2594,7 +2487,8 @@ template <class Devector> void test_insert()
Devector h; get_range<Devector>(16, h);
h.pop_front();
h.pop_back();
iterator valid = h.begin() + 7;
//Inserting in the middle, leads to back insertion
iterator valid = h.begin() + 8;
typename Devector::iterator it = h.insert(h.begin() + 7, test_elem);
const int expected[] = {2, 3, 4, 5, 6, 7, 8, 123, 9, 10, 11, 12, 13, 14, 15};
test_equal_range(h, expected);
@@ -2614,23 +2508,24 @@ template <class Devector> void test_insert()
test_equal_range(i, expected);
}
test_insert_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
//test_insert_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
// test when tmp is already inserted and there's free capacity
{
Devector c; get_range<Devector>(6, c);
c.pop_back();
const T& tmp = *(c.begin() + 2);
c.pop_back();
T tmp = *(c.begin() + 2);
c.insert(c.begin() + 1, tmp);
const int expected[] = {1, 3, 2, 3, 4, 5};
const int expected[] = {1, 3, 2, 3, 4};
test_equal_range(c, expected);
}
// test when tmp is already inserted and maybe there's no free capacity
{
Devector c; get_range<Devector>(6, c);
const T& tmp = *(c.begin() + 2);
const T tmp = *(c.begin() + 2);
c.insert(c.begin() + 1, tmp);
const int expected[] = {1, 3, 2, 3, 4, 5, 6};
test_equal_range(c, expected);
@@ -2735,7 +2630,8 @@ template <class Devector> void test_insert_rvalue()
Devector h; get_range<Devector>(16, h);
h.pop_front();
h.pop_back();
iterator valid = h.begin() + 7;
//Inserting in the middle, leads to back insertion
iterator valid = h.begin() + 8;
typename Devector::iterator it = h.insert(h.begin() + 7, T(123));
const int expected[] = {2, 3, 4, 5, 6, 7, 8, 123, 9, 10, 11, 12, 13, 14, 15};
test_equal_range(h, expected);
@@ -2755,8 +2651,8 @@ template <class Devector> void test_insert_rvalue()
test_equal_range(i, expected);
}
test_insert_rvalue_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
//test_insert_rvalue_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
}
template <class Devector> void test_insert_n_throwing(dtl::true_)
@@ -2931,7 +2827,7 @@ template <class Devector> void test_insert_n()
i.pop_front();
i.pop_front();
iterator ret = i.insert(i.end() - 1, 2, *i.begin());
iterator ret = i.insert(i.end() - 1, 2, typename Devector::value_type(*i.begin()));
const int expected[] = {3, 4, 5, 6, 7, 3, 3, 8};
test_equal_range(i, expected);
@@ -2939,8 +2835,8 @@ template <class Devector> void test_insert_n()
BOOST_TEST(ret == i.begin() + 5);
}
test_insert_n_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
//test_insert_n_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
}
template <class Devector> void test_insert_input_range()
@@ -3160,6 +3056,7 @@ template <class Devector> void test_insert_range()
typename Vector::iterator xb = x.begin();
//Insert from empty
{
Devector a;
iterator ret = a.insert(a.end(), xb, xb+5);
@@ -3168,20 +3065,90 @@ template <class Devector> void test_insert_range()
BOOST_TEST(ret == a.begin());
}
{
Devector a;
iterator ret = a.insert(a.begin(), xb, xb + 5);
const int expected[] = { 9, 10, 11, 12, 13 };
test_equal_range(a, expected);
BOOST_TEST(ret == a.begin());
}
//Insert at both ends
{
Devector c; get_range<Devector>(8, c);
iterator ret = c.insert(c.end(), xb, xb + 3);
const int expected[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
test_equal_range(c, expected);
BOOST_TEST(ret == c.begin() + 8);
}
{
Devector b; get_range<Devector>(8, b);
iterator ret = b.insert(b.begin(), xb, xb+3);
const int expected [] = {9, 10, 11, 1, 2, 3, 4, 5, 6, 7, 8};
const int expected [] = {9, 10, 11, 1, 2, 3, 4, 5, 6, 7, 8 };
test_equal_range(b, expected);
BOOST_TEST(ret == b.begin());
}
//Insert without full data movement
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin(), b.begin() + 3);
iterator old_end = b.end();
iterator ret = b.insert(b.begin()+1u, xb, xb + 3);
const int expected[] = { 4, 9, 10, 11, 5, 6, 7, 8 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin() + 1u));
BOOST_TEST(old_end == b.end());
}
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin()+5, b.end());
iterator old_beg = b.begin();
iterator ret = b.insert(b.end() - 1u, xb, xb + 3);
const int expected[] = { 1, 2, 3, 4, 9, 10, 11, 5 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin() + 4u));
BOOST_TEST(old_beg == b.begin());
}
//Full data movement
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin(), b.begin() + 4);
iterator ret = b.insert(b.end(), xb, xb + 3);
const int expected[] = { 5, 6, 7, 8, 9, 10, 11 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin()+4));
}
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin(), b.begin() + 3);
b.pop_back();
iterator ret = b.insert(b.end() - 1, xb, xb + 3);
const int expected[] = { 4, 5, 6, 9, 10, 11, 7 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin()+3));
}
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin()+4, b.end());
iterator ret = b.insert(b.begin(), xb, xb + 3);
const int expected[] = { 9, 10, 11, 1, 2, 3, 4 };
test_equal_range(b, expected);
BOOST_TEST(ret == b.begin());
}
{
Devector c; get_range<Devector>(8, c);
iterator ret = c.insert(c.end(), xb, xb+3);
const int expected [] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
test_equal_range(c, expected);
BOOST_TEST(ret == c.begin() + 8);
Devector b; get_range<Devector>(8, b);
b.erase(b.begin() + 5, b.end());
b.pop_front();
iterator ret = b.insert(b.begin()+1, xb, xb + 3);
const int expected[] = { 2, 9, 10, 11, 3, 4, 5 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin()+1));
}
{
@@ -3951,16 +3918,16 @@ struct GetAllocatorCont
void test_all()
{/*
test_recursive_devector();
{
test_recursive_devector();/*
test_max_size();
test_exceeding_max_size();
shrink_to_fit();
shrink_to_fit();*/
test_data();
test_il_assignment< devector<int> >();
test_assign_forward_range< devector<int> >();
test_assign_il<devector<int> >();
*/
//test_devector< devector<int> >();
test_devector< devector<regular_elem> >();
test_devector< devector<noex_move> >();
@@ -3990,11 +3957,110 @@ boost::container::vector<boost::container::test::movable_int> get()
return BOOST_MOVE_RET(V, v);
}
template<class VoidAllocator>
int test_cont_variants()
{
typedef typename GetAllocatorCont<VoidAllocator>::template apply<int>::type MyCont;
typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_int>::type MyMoveCont;
typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_and_copyable_int>::type MyCopyMoveCont;
typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::copyable_int>::type MyCopyCont;
if(test::vector_test<MyCont>())
return 1;
if(test::vector_test<MyMoveCont>())
return 1;
if(test::vector_test<MyCopyMoveCont>())
return 1;
if(test::vector_test<MyCopyCont>())
return 1;
return 0;
}
int main()
{
// boost::container::vector<boost::container::test::movable_int>a(get());
//boost::container::vector<only_movable> b(getom());
//boost::container::vector<only_movable> c(get_range< boost::container::vector<only_movable> >(1, 5, 5, 9));
// boost::container::devector<boost::container::test::movable_int>a(get());
//boost::container::devector<only_movable> b(getom());
//boost::container::devector<only_movable> c(get_range< boost::container::devector<only_movable> >(1, 5, 5, 9));
test_all();
////////////////////////////////////
// Allocator implementations
////////////////////////////////////
// std:allocator
if (test_cont_variants< std::allocator<void> >()) {
std::cerr << "test_cont_variants< std::allocator<void> > failed" << std::endl;
return 1;
}
// boost::container::allocator
if (test_cont_variants< allocator<void> >()) {
std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
return 1;
}
////////////////////////////////////
// Default init test
////////////////////////////////////
if (!test::default_init_test< devector<int, test::default_init_allocator<int> > >()) {
std::cerr << "Default init test failed" << std::endl;
return 1;
}
////////////////////////////////////
// Emplace testing
////////////////////////////////////
const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
if (!boost::container::test::test_emplace< devector<test::EmplaceInt>, Options>())
return 1;
////////////////////////////////////
// Allocator propagation testing
////////////////////////////////////
if (!boost::container::test::test_propagate_allocator<boost_container_devector>())
return 1;
////////////////////////////////////
// Initializer lists testing
////////////////////////////////////
if (!boost::container::test::test_vector_methods_with_initializer_list_as_argument_for
< boost::container::devector<int> >()) {
return 1;
}
////////////////////////////////////
// Iterator testing
////////////////////////////////////
{
typedef boost::container::devector<int> cont_int;
cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
boost::intrusive::test::test_iterator_random< cont_int >(a);
if (boost::report_errors() != 0) {
return 1;
}
}
////////////////////////////////////
// has_trivial_destructor_after_move testing
////////////////////////////////////
// default allocator
{
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::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");
}
// std::allocator
{
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::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");
}
return boost::report_errors();
}

1
test/test_util.hpp
View File

@@ -36,6 +36,7 @@ template <typename Container>
void get_range(int count, Container &c)
{
c.clear();
c.reserve(static_cast<std::size_t>(count));
for (int i = 1; i <= count; ++i)
{