Files

557 lines
20 KiB
C++

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2008-2013. 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 ACTIV_BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
#define ACTIV_BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
#ifndef ACTIV_BOOST_CONFIG_HPP
# include <ActivBoost/config.hpp>
#endif
#if defined(ACTIV_BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
#include <ActivBoost/container/detail/config_begin.hpp>
#include <ActivBoost/container/detail/workaround.hpp>
// container
#include <ActivBoost/container/allocator_traits.hpp>
// container/detail
#include <ActivBoost/container/detail/copy_move_algo.hpp>
#include <ActivBoost/container/detail/destroyers.hpp>
#include <ActivBoost/container/detail/mpl.hpp>
#include <ActivBoost/container/detail/type_traits.hpp>
#include <ActivBoost/container/detail/iterator.hpp>
#include <ActivBoost/container/detail/iterators.hpp>
#include <ActivBoost/move/detail/iterator_to_raw_pointer.hpp>
#if defined(ACTIV_BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <ActivBoost/move/detail/fwd_macros.hpp>
#endif
// move
#include <ActivBoost/move/utility_core.hpp>
// other
#include <ActivBoost/assert.hpp>
#include <ActivBoost/core/no_exceptions_support.hpp>
namespace Boost { namespace container { namespace dtl {
template<class Allocator, class FwdIt, class Iterator>
struct move_insert_range_proxy
{
typedef typename allocator_traits<Allocator>::value_type value_type;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit move_insert_range_proxy(FwdIt first)
: first_(first)
{}
ACTIV_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);
}
ACTIV_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);
}
FwdIt first_;
};
template<class Allocator, class FwdIt, class Iterator>
struct insert_range_proxy
{
typedef typename allocator_traits<Allocator>::value_type value_type;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_range_proxy(FwdIt first)
: first_(first)
{}
ACTIV_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);
}
ACTIV_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);
}
FwdIt first_;
};
template<class Allocator, class Iterator>
struct insert_n_copies_proxy
{
typedef typename allocator_traits<Allocator>::value_type value_type;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_n_copies_proxy(const value_type &v)
: v_(v)
{}
ACTIV_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); }
ACTIV_BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
{
while (n){
--n;
*p = v_;
++p;
}
}
const value_type &v_;
};
template<class Allocator, class Iterator>
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;
ACTIV_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); }
void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
while (n){
--n;
storage_t v;
value_type *vp = reinterpret_cast<value_type *>(v.data);
alloc_traits::construct(a, vp);
value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
*p = ::Boost::move(*vp);
++p;
}
}
};
template<class Allocator, class Iterator>
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;
ACTIV_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); }
void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
if(!is_pod<value_type>::value){
while (n){
--n;
typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
value_type *vp = reinterpret_cast<value_type *>(v.data);
alloc_traits::construct(a, vp, default_init);
value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
*p = ::Boost::move(*vp);
++p;
}
}
}
};
template<class Allocator, class Iterator>
struct insert_copy_proxy
{
typedef Boost::container::allocator_traits<Allocator> alloc_traits;
typedef typename alloc_traits::value_type value_type;
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_copy_proxy(const value_type &v)
: v_(v)
{}
ACTIV_BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
ACTIV_BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a, Boost::movelib::iterator_to_raw_pointer(p), v_);
}
ACTIV_BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
{
ACTIV_BOOST_ASSERT(n == 1); (void)n;
*p = v_;
}
const value_type &v_;
};
template<class Allocator, class Iterator>
struct insert_move_proxy
{
typedef Boost::container::allocator_traits<Allocator> alloc_traits;
typedef typename alloc_traits::value_type value_type;
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_move_proxy(value_type &v)
: v_(v)
{}
ACTIV_BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
{
ACTIV_BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a, Boost::movelib::iterator_to_raw_pointer(p), ::Boost::move(v_) );
}
ACTIV_BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
{
ACTIV_BOOST_ASSERT(n == 1); (void)n;
*p = ::Boost::move(v_);
}
value_type &v_;
};
template<class It, class Allocator>
ACTIV_BOOST_CONTAINER_FORCEINLINE insert_move_proxy<Allocator, It> get_insert_value_proxy(ACTIV_BOOST_RV_REF(typename Boost::container::iterator_traits<It>::value_type) v)
{
return insert_move_proxy<Allocator, It>(v);
}
template<class It, class Allocator>
ACTIV_BOOST_CONTAINER_FORCEINLINE insert_copy_proxy<Allocator, It> get_insert_value_proxy(const typename Boost::container::iterator_traits<It>::value_type &v)
{
return insert_copy_proxy<Allocator, It>(v);
}
}}} //namespace Boost { namespace container { namespace dtl {
#if !defined(ACTIV_BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <ActivBoost/container/detail/variadic_templates_tools.hpp>
#include <ActivBoost/move/utility_core.hpp>
namespace Boost {
namespace container {
namespace dtl {
template<class Allocator, class Iterator, class ...Args>
struct insert_nonmovable_emplace_proxy
{
typedef Boost::container::allocator_traits<Allocator> alloc_traits;
typedef typename alloc_traits::value_type value_type;
typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy(ACTIV_BOOST_FWD_REF(Args)... args)
: args_(args...)
{}
ACTIV_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>
ACTIV_BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
{
ACTIV_BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a, Boost::movelib::iterator_to_raw_pointer(p), ::Boost::forward<Args>(get<IdxPack>(this->args_))... );
}
protected:
tuple<Args&...> args_;
};
template<class Allocator, class Iterator, class ...Args>
struct insert_emplace_proxy
: public insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...>
{
typedef insert_nonmovable_emplace_proxy<Allocator, Iterator, 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;
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(ACTIV_BOOST_FWD_REF(Args)... args)
: base_t(::Boost::forward<Args>(args)...)
{}
ACTIV_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>
ACTIV_BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
{
ACTIV_BOOST_ASSERT(n ==1); (void)n;
typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
value_type *vp = reinterpret_cast<value_type *>(v.data);
alloc_traits::construct(a, vp, ::Boost::forward<Args>(get<IdxPack>(this->args_))...);
ACTIV_BOOST_TRY{
*p = ::Boost::move(*vp);
}
ACTIV_BOOST_CATCH(...){
alloc_traits::destroy(a, vp);
ACTIV_BOOST_RETHROW
}
ACTIV_BOOST_CATCH_END
alloc_traits::destroy(a, vp);
}
};
//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>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(typename Boost::container::allocator_traits<Allocator>::value_type &&v)
: insert_move_proxy<Allocator, Iterator>(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
, typename Boost::container::dtl::add_const<typename Boost::container::allocator_traits<Allocator>::value_type>::type
>
: public insert_copy_proxy<Allocator, Iterator>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(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>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
{}
};
template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator
, typename Boost::container::dtl::add_const<typename Boost::container::allocator_traits<Allocator>::value_type>::type &
>
: public insert_copy_proxy<Allocator, Iterator>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
{}
};
}}} //namespace Boost { namespace container { namespace dtl {
#else // !defined(ACTIV_BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <ActivBoost/container/detail/value_init.hpp>
namespace Boost {
namespace container {
namespace dtl {
#define ACTIV_BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE(N) \
template< class Allocator, class Iterator ACTIV_BOOST_MOVE_I##N ACTIV_BOOST_MOVE_CLASS##N >\
struct insert_nonmovable_emplace_proxy##N\
{\
typedef Boost::container::allocator_traits<Allocator> alloc_traits;\
typedef typename alloc_traits::value_type value_type;\
\
static const bool single_value = true;\
\
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy##N(ACTIV_BOOST_MOVE_UREF##N)\
ACTIV_BOOST_MOVE_COLON##N ACTIV_BOOST_MOVE_FWD_INIT##N {}\
\
ACTIV_BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
{\
ACTIV_BOOST_ASSERT(n == 1); (void)n;\
alloc_traits::construct(a, Boost::movelib::iterator_to_raw_pointer(p) ACTIV_BOOST_MOVE_I##N ACTIV_BOOST_MOVE_MFWD##N);\
}\
\
ACTIV_BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, std::size_t)\
{ ACTIV_BOOST_ASSERT(false); }\
\
protected:\
ACTIV_BOOST_MOVE_MREF##N\
};\
\
template< class Allocator, class Iterator ACTIV_BOOST_MOVE_I##N ACTIV_BOOST_MOVE_CLASS##N >\
struct insert_emplace_proxy_arg##N\
: insert_nonmovable_emplace_proxy##N< Allocator, Iterator ACTIV_BOOST_MOVE_I##N ACTIV_BOOST_MOVE_TARG##N >\
{\
typedef insert_nonmovable_emplace_proxy##N\
< Allocator, Iterator ACTIV_BOOST_MOVE_I##N ACTIV_BOOST_MOVE_TARG##N > base_t;\
typedef typename base_t::value_type value_type;\
typedef Boost::container::allocator_traits<Allocator> alloc_traits;\
\
static const bool single_value = true;\
\
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg##N(ACTIV_BOOST_MOVE_UREF##N)\
: base_t(ACTIV_BOOST_MOVE_FWD##N){}\
\
ACTIV_BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
{\
ACTIV_BOOST_ASSERT(n == 1); (void)n;\
typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
value_type *vp = reinterpret_cast<value_type *>(v.data);\
alloc_traits::construct(a, vp ACTIV_BOOST_MOVE_I##N ACTIV_BOOST_MOVE_MFWD##N);\
ACTIV_BOOST_TRY{\
*p = ::Boost::move(*vp);\
}\
ACTIV_BOOST_CATCH(...){\
alloc_traits::destroy(a, vp);\
ACTIV_BOOST_RETHROW\
}\
ACTIV_BOOST_CATCH_END\
alloc_traits::destroy(a, vp);\
}\
};\
//
ACTIV_BOOST_MOVE_ITERATE_0TO9(ACTIV_BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE)
#undef ACTIV_BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE
#if defined(ACTIV_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>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_move_proxy<Allocator, Iterator>(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>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(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>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename Boost::container::allocator_traits<Allocator>::value_type &&v)
: insert_move_proxy<Allocator, Iterator>(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
, typename Boost::container::dtl::add_const<typename Boost::container::allocator_traits<Allocator>::value_type>::type
>
: public insert_copy_proxy<Allocator, Iterator>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(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>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
{}
};
template<class Allocator, class Iterator>
struct insert_emplace_proxy_arg1<Allocator, Iterator
, typename Boost::container::dtl::add_const<typename Boost::container::allocator_traits<Allocator>::value_type>::type &
>
: public insert_copy_proxy<Allocator, Iterator>
{
static const bool single_value = true;
ACTIV_BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename Boost::container::allocator_traits<Allocator>::value_type &v)
: insert_copy_proxy<Allocator, Iterator>(v)
{}
};
#endif
}}} //namespace Boost { namespace container { namespace dtl {
#endif // !defined(ACTIV_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 <ActivBoost/container/detail/config_end.hpp>
#endif //#ifndef ACTIV_BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP