forked from boostorg/container
452 lines
21 KiB
C++
452 lines
21 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// (C) Copyright Ion Gaztanaga 2008-2012. Distributed under the Boost
|
|
// Software License, Version 1.0. (See accompanying file
|
|
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
// See http://www.boost.org/libs/container for documentation.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
|
|
#define BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
|
|
|
|
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
|
|
# pragma once
|
|
#endif
|
|
|
|
#include "config_begin.hpp"
|
|
#include <boost/container/detail/workaround.hpp>
|
|
#include <boost/container/allocator_traits.hpp>
|
|
#include <boost/container/detail/destroyers.hpp>
|
|
#include <boost/aligned_storage.hpp>
|
|
#include <boost/move/move.hpp>
|
|
#include <iterator> //std::iterator_traits
|
|
#include <boost/assert.hpp>
|
|
|
|
namespace boost { namespace container { namespace container_detail {
|
|
|
|
//This class will be interface for operations dependent on FwdIt types used advanced_insert_aux_impl
|
|
template<class Iterator>
|
|
struct advanced_insert_aux_int
|
|
{
|
|
typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
|
|
virtual void copy_remaining_to(Iterator p) = 0;
|
|
virtual void uninitialized_copy_remaining_to(Iterator p) = 0;
|
|
virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first) = 0;
|
|
virtual void copy_some_and_update(Iterator pos, difference_type division_count, bool first) = 0;
|
|
virtual ~advanced_insert_aux_int() {}
|
|
};
|
|
|
|
//This class template will adapt each FwIt types to advanced_insert_aux_int
|
|
template<class A, class FwdIt, class Iterator>
|
|
struct advanced_insert_aux_proxy
|
|
: public advanced_insert_aux_int<Iterator>
|
|
{
|
|
typedef typename allocator_traits<A>::size_type size_type;
|
|
typedef typename allocator_traits<A>::value_type value_type;
|
|
typedef typename advanced_insert_aux_int<Iterator>::difference_type difference_type;
|
|
|
|
advanced_insert_aux_proxy(A& a, FwdIt first, FwdIt last)
|
|
: a_(a), first_(first), last_(last)
|
|
{}
|
|
|
|
virtual ~advanced_insert_aux_proxy()
|
|
{}
|
|
|
|
virtual void copy_remaining_to(Iterator p)
|
|
{ ::boost::copy_or_move(this->first_, this->last_, p); }
|
|
|
|
virtual void uninitialized_copy_remaining_to(Iterator p)
|
|
{ ::boost::container::uninitialized_copy_or_move_alloc(this->a_, this->first_, this->last_, p); }
|
|
|
|
virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
|
|
{
|
|
FwdIt mid = this->first_;
|
|
std::advance(mid, division_count);
|
|
if(first_n){
|
|
::boost::container::uninitialized_copy_or_move_alloc(this->a_, this->first_, mid, pos);
|
|
this->first_ = mid;
|
|
}
|
|
else{
|
|
::boost::container::uninitialized_copy_or_move_alloc(this->a_, mid, this->last_, pos);
|
|
this->last_ = mid;
|
|
}
|
|
}
|
|
|
|
virtual void copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
|
|
{
|
|
FwdIt mid = this->first_;
|
|
std::advance(mid, division_count);
|
|
if(first_n){
|
|
::boost::copy_or_move(this->first_, mid, pos);
|
|
this->first_ = mid;
|
|
}
|
|
else{
|
|
::boost::copy_or_move(mid, this->last_, pos);
|
|
this->last_ = mid;
|
|
}
|
|
}
|
|
A &a_;
|
|
FwdIt first_, last_;
|
|
};
|
|
|
|
//This class template will adapt default construction insertions to advanced_insert_aux_int
|
|
template<class A, class Iterator>
|
|
struct default_construct_aux_proxy
|
|
: public advanced_insert_aux_int<Iterator>
|
|
{
|
|
typedef ::boost::container::allocator_traits<A> alloc_traits;
|
|
typedef typename allocator_traits<A>::size_type size_type;
|
|
typedef typename allocator_traits<A>::value_type value_type;
|
|
typedef typename advanced_insert_aux_int<Iterator>::difference_type difference_type;
|
|
|
|
default_construct_aux_proxy(A &a, size_type count)
|
|
: a_(a), count_(count)
|
|
{}
|
|
|
|
virtual ~default_construct_aux_proxy()
|
|
{}
|
|
|
|
virtual void copy_remaining_to(Iterator)
|
|
{ //This should never be called with any count
|
|
BOOST_ASSERT(this->count_ == 0);
|
|
}
|
|
|
|
virtual void uninitialized_copy_remaining_to(Iterator p)
|
|
{ this->priv_uninitialized_copy(p, this->count_); }
|
|
|
|
virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
|
|
{
|
|
size_type new_count;
|
|
if(first_n){
|
|
new_count = division_count;
|
|
}
|
|
else{
|
|
BOOST_ASSERT(difference_type(this->count_)>= division_count);
|
|
new_count = this->count_ - division_count;
|
|
}
|
|
this->priv_uninitialized_copy(pos, new_count);
|
|
}
|
|
|
|
virtual void copy_some_and_update(Iterator , difference_type division_count, bool first_n)
|
|
{
|
|
BOOST_ASSERT(this->count_ == 0);
|
|
size_type new_count;
|
|
if(first_n){
|
|
new_count = division_count;
|
|
}
|
|
else{
|
|
BOOST_ASSERT(difference_type(this->count_)>= division_count);
|
|
new_count = this->count_ - division_count;
|
|
}
|
|
//This function should never called with a count different to zero
|
|
BOOST_ASSERT(new_count == 0);
|
|
(void)new_count;
|
|
}
|
|
|
|
private:
|
|
void priv_uninitialized_copy(Iterator p, const size_type n)
|
|
{
|
|
BOOST_ASSERT(n <= this->count_);
|
|
Iterator orig_p = p;
|
|
size_type i = 0;
|
|
try{
|
|
for(; i < n; ++i, ++p){
|
|
alloc_traits::construct(this->a_, container_detail::to_raw_pointer(&*p));
|
|
}
|
|
}
|
|
catch(...){
|
|
while(i--){
|
|
alloc_traits::destroy(this->a_, container_detail::to_raw_pointer(&*orig_p++));
|
|
}
|
|
throw;
|
|
}
|
|
this->count_ -= n;
|
|
}
|
|
A &a_;
|
|
size_type count_;
|
|
};
|
|
|
|
}}} //namespace boost { namespace container { namespace container_detail {
|
|
|
|
#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
|
|
|
|
#include <boost/container/detail/variadic_templates_tools.hpp>
|
|
#include <boost/container/detail/stored_ref.hpp>
|
|
#include <boost/move/move.hpp>
|
|
#include <typeinfo>
|
|
//#include <iostream> //For debugging purposes
|
|
|
|
namespace boost {
|
|
namespace container {
|
|
namespace container_detail {
|
|
|
|
|
|
//This class template will adapt emplace construction insertions of movable types
|
|
//to advanced_insert_aux_int
|
|
template<class A, class Iterator, class ...Args>
|
|
struct advanced_insert_aux_non_movable_emplace
|
|
: public advanced_insert_aux_int<Iterator>
|
|
{
|
|
typedef boost::container::allocator_traits<A> alloc_traits;
|
|
typedef typename allocator_traits<A>::size_type size_type;
|
|
typedef typename allocator_traits<A>::value_type value_type;
|
|
typedef typename advanced_insert_aux_int<Iterator>::difference_type difference_type;
|
|
typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
|
|
|
|
explicit advanced_insert_aux_non_movable_emplace(A &a, Args&&... args)
|
|
: a_(a)
|
|
, args_(args...)
|
|
, used_(false)
|
|
{}
|
|
|
|
~advanced_insert_aux_non_movable_emplace()
|
|
{}
|
|
|
|
virtual void copy_remaining_to(Iterator)
|
|
//This code can't be called since value_type is not movable or copyable
|
|
{ BOOST_ASSERT(false); }
|
|
|
|
virtual void uninitialized_copy_remaining_to(Iterator p)
|
|
{ this->priv_uninitialized_copy_remaining_to(index_tuple_t(), p); }
|
|
|
|
virtual void uninitialized_copy_some_and_update(Iterator p, difference_type division_count, bool first_n)
|
|
{ this->priv_uninitialized_copy_some_and_update(index_tuple_t(), p, division_count, first_n); }
|
|
|
|
virtual void copy_some_and_update(Iterator, difference_type, bool )
|
|
//This code can't be called since value_type is not movable or copyable
|
|
{ BOOST_ASSERT(false); }
|
|
|
|
private:
|
|
template<int ...IdxPack>
|
|
void priv_uninitialized_copy_some_and_update(const index_tuple<IdxPack...>&, Iterator p, difference_type division_count, bool first_n)
|
|
{
|
|
BOOST_ASSERT(division_count <=1);
|
|
if((first_n && division_count == 1) || (!first_n && division_count == 0)){
|
|
if(!this->used_){
|
|
alloc_traits::construct( this->a_
|
|
, container_detail::to_raw_pointer(&*p)
|
|
, ::boost::container::container_detail::
|
|
stored_ref<Args>::forward(get<IdxPack>(this->args_))...
|
|
);
|
|
this->used_ = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<int ...IdxPack>
|
|
void priv_uninitialized_copy_remaining_to(const index_tuple<IdxPack...>&, Iterator p)
|
|
{
|
|
if(!this->used_){
|
|
alloc_traits::construct( this->a_
|
|
, container_detail::to_raw_pointer(&*p)
|
|
, ::boost::container::container_detail::
|
|
stored_ref<Args>::forward(get<IdxPack>(this->args_))...
|
|
);
|
|
this->used_ = true;
|
|
}
|
|
}
|
|
|
|
protected:
|
|
A &a_;
|
|
tuple<Args&...> args_;
|
|
bool used_;
|
|
};
|
|
|
|
//This class template will adapt emplace construction insertions of movable types
|
|
//to advanced_insert_aux_int
|
|
template<class A, class Iterator, class ...Args>
|
|
struct advanced_insert_aux_emplace
|
|
: public advanced_insert_aux_non_movable_emplace<A, Iterator, Args...>
|
|
{
|
|
typedef advanced_insert_aux_non_movable_emplace<A, Iterator, Args...> base_t;
|
|
typedef boost::container::allocator_traits<A> alloc_traits;
|
|
typedef typename base_t::value_type value_type;
|
|
typedef typename base_t::difference_type difference_type;
|
|
typedef typename base_t::index_tuple_t index_tuple_t;
|
|
|
|
explicit advanced_insert_aux_emplace(A &a, Args&&... args)
|
|
: base_t(a, ::boost::forward<Args>(args)...)
|
|
{}
|
|
|
|
~advanced_insert_aux_emplace()
|
|
{}
|
|
|
|
//Override only needed functions
|
|
virtual void copy_remaining_to(Iterator p)
|
|
{ this->priv_copy_remaining_to(index_tuple_t(), p); }
|
|
|
|
virtual void copy_some_and_update(Iterator p, difference_type division_count, bool first_n)
|
|
{ this->priv_copy_some_and_update(index_tuple_t(), p, division_count, first_n); }
|
|
|
|
private:
|
|
template<int ...IdxPack>
|
|
void priv_copy_remaining_to(const index_tuple<IdxPack...>&, Iterator p)
|
|
{
|
|
if(!this->used_){
|
|
aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
|
|
value_type *vp = static_cast<value_type *>(static_cast<void *>(&v));
|
|
alloc_traits::construct(this->a_, vp,
|
|
::boost::container::container_detail::stored_ref<Args>::forward(get<IdxPack>(this->args_))...);
|
|
scoped_destructor<A> d(this->a_, vp);
|
|
*p = ::boost::move(*vp);
|
|
d.release();
|
|
this->used_ = true;
|
|
}
|
|
}
|
|
|
|
template<int ...IdxPack>
|
|
void priv_copy_some_and_update(const index_tuple<IdxPack...>&, Iterator p, difference_type division_count, bool first_n)
|
|
{
|
|
BOOST_ASSERT(division_count <=1);
|
|
if((first_n && division_count == 1) || (!first_n && division_count == 0)){
|
|
if(!this->used_){
|
|
aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
|
|
value_type *vp = static_cast<value_type *>(static_cast<void *>(&v));
|
|
alloc_traits::construct(this->a_, vp,
|
|
::boost::container::container_detail::stored_ref<Args>::forward(get<IdxPack>(this->args_))...);
|
|
try {
|
|
*p = ::boost::move(*vp);
|
|
} catch (...) {
|
|
alloc_traits::destroy(this->a_, vp);
|
|
throw;
|
|
}
|
|
alloc_traits::destroy(this->a_, vp);
|
|
this->used_ = true;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
}}} //namespace boost { namespace container { namespace container_detail {
|
|
|
|
#else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
|
|
|
|
#include <boost/container/detail/preprocessor.hpp>
|
|
#include <boost/container/detail/value_init.hpp>
|
|
|
|
namespace boost {
|
|
namespace container {
|
|
namespace container_detail {
|
|
|
|
#define BOOST_PP_LOCAL_MACRO(n) \
|
|
template<class A, class Iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) > \
|
|
struct BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_non_movable_emplace, n), arg) \
|
|
: public advanced_insert_aux_int<Iterator> \
|
|
{ \
|
|
typedef boost::container::allocator_traits<A> alloc_traits; \
|
|
typedef typename allocator_traits<A>::size_type size_type; \
|
|
typedef typename allocator_traits<A>::value_type value_type; \
|
|
typedef typename advanced_insert_aux_int<Iterator>::difference_type \
|
|
difference_type; \
|
|
\
|
|
BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_non_movable_emplace, n), arg) \
|
|
( A &a BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _) ) \
|
|
: a_(a) \
|
|
, used_(false) \
|
|
BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_INIT, _) \
|
|
{} \
|
|
\
|
|
virtual void copy_remaining_to(Iterator) \
|
|
{ BOOST_ASSERT(false); } \
|
|
\
|
|
virtual void uninitialized_copy_remaining_to(Iterator p) \
|
|
{ \
|
|
if(!this->used_){ \
|
|
alloc_traits::construct \
|
|
( this->a_ \
|
|
, container_detail::to_raw_pointer(&*p) \
|
|
BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_MEMBER_FORWARD, _) \
|
|
); \
|
|
this->used_ = true; \
|
|
} \
|
|
} \
|
|
\
|
|
virtual void uninitialized_copy_some_and_update \
|
|
(Iterator p, difference_type division_count, bool first_n) \
|
|
{ \
|
|
BOOST_ASSERT(division_count <=1); \
|
|
if((first_n && division_count == 1) || (!first_n && division_count == 0)){ \
|
|
if(!this->used_){ \
|
|
alloc_traits::construct \
|
|
( this->a_ \
|
|
, container_detail::to_raw_pointer(&*p) \
|
|
BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_MEMBER_FORWARD, _) \
|
|
); \
|
|
this->used_ = true; \
|
|
} \
|
|
} \
|
|
} \
|
|
\
|
|
virtual void copy_some_and_update(Iterator, difference_type, bool) \
|
|
{ BOOST_ASSERT(false); } \
|
|
\
|
|
A &a_; \
|
|
bool used_; \
|
|
BOOST_PP_REPEAT(n, BOOST_CONTAINER_PP_PARAM_DEFINE, _) \
|
|
}; \
|
|
\
|
|
template<class A, class Iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) > \
|
|
struct BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
|
|
: BOOST_PP_CAT(BOOST_PP_CAT( \
|
|
advanced_insert_aux_non_movable_emplace, n), arg) \
|
|
< A, Iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P) > \
|
|
{ \
|
|
typedef BOOST_PP_CAT(BOOST_PP_CAT( \
|
|
advanced_insert_aux_non_movable_emplace, n), arg) \
|
|
<A, Iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P) > base_t; \
|
|
typedef typename base_t::value_type value_type; \
|
|
typedef typename base_t::difference_type difference_type; \
|
|
typedef boost::container::allocator_traits<A> alloc_traits; \
|
|
\
|
|
BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
|
|
( A &a BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _) ) \
|
|
: base_t(a BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) ) \
|
|
{} \
|
|
\
|
|
virtual void copy_remaining_to(Iterator p) \
|
|
{ \
|
|
if(!this->used_){ \
|
|
aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v; \
|
|
value_type *vp = static_cast<value_type *>(static_cast<void *>(&v)); \
|
|
alloc_traits::construct(this->a_, vp \
|
|
BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_MEMBER_FORWARD, _)); \
|
|
scoped_destructor<A> d(this->a_, vp); \
|
|
*p = ::boost::move(*vp); \
|
|
d.release(); \
|
|
this->used_ = true; \
|
|
} \
|
|
} \
|
|
\
|
|
virtual void copy_some_and_update \
|
|
(Iterator p, difference_type division_count, bool first_n) \
|
|
{ \
|
|
BOOST_ASSERT(division_count <=1); \
|
|
if((first_n && division_count == 1) || (!first_n && division_count == 0)){ \
|
|
if(!this->used_){ \
|
|
aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v; \
|
|
value_type *vp = static_cast<value_type *>(static_cast<void *>(&v)); \
|
|
alloc_traits::construct(this->a_, vp \
|
|
BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_MEMBER_FORWARD, _)); \
|
|
scoped_destructor<A> d(this->a_, vp); \
|
|
*p = ::boost::move(*vp); \
|
|
d.release(); \
|
|
this->used_ = true; \
|
|
} \
|
|
} \
|
|
} \
|
|
}; \
|
|
//!
|
|
|
|
#define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
|
|
#include BOOST_PP_LOCAL_ITERATE()
|
|
|
|
}}} //namespace boost { namespace container { namespace container_detail {
|
|
|
|
#endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
|
|
|
|
#include <boost/container/detail/config_end.hpp>
|
|
|
|
#endif //#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
|