/usr/include/boost/container/detail
Edit: /usr/include/boost/container/detail/copy_move_algo.hpp (38531B)
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2005-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 BOOST_CONTAINER_DETAIL_COPY_MOVE_ALGO_HPP
#define BOOST_CONTAINER_DETAIL_COPY_MOVE_ALGO_HPP
#ifndef BOOST_CONFIG_HPP
# include
#endif
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
// container
#include
// container/detail
#include
#include
#include
#include
#include
// move
#include
#include
#include
// other
#include
// std
#include //for memmove/memcpy
#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
#pragma GCC diagnostic push
//pair memcpy optimizations rightfully detected by GCC
# if defined(BOOST_GCC) && (BOOST_GCC >= 80000)
# pragma GCC diagnostic ignored "-Wclass-memaccess"
# endif
//GCC 8 seems a bit confused about array access error with static_vector
//when out of bound exceptions are being thrown.
# if defined(BOOST_GCC) && (BOOST_GCC >= 80000) && (BOOST_GCC < 80200)
# pragma GCC diagnostic ignored "-Wstringop-overflow"
# endif
# pragma GCC diagnostic ignored "-Warray-bounds"
#endif
namespace boost {
namespace container {
namespace dtl {
template
struct are_elements_contiguous
{
static const bool value = false;
};
/////////////////////////
// raw pointers
/////////////////////////
template
struct are_elements_contiguous
{
static const bool value = true;
};
/////////////////////////
// move iterators
/////////////////////////
template
struct are_elements_contiguous< ::boost::move_iterator >
: are_elements_contiguous
{};
} //namespace dtl {
/////////////////////////
// predeclarations
/////////////////////////
template
class vec_iterator;
} //namespace container {
namespace interprocess {
template
class offset_ptr;
} //namespace interprocess {
namespace container {
namespace dtl {
/////////////////////////
//vector_[const_]iterator
/////////////////////////
template
struct are_elements_contiguous >
{
static const bool value = true;
};
/////////////////////////
// offset_ptr
/////////////////////////
template
struct are_elements_contiguous< ::boost::interprocess::offset_ptr >
{
static const bool value = true;
};
template
struct are_contiguous_and_same
: boost::move_detail::and_
< are_elements_contiguous
, are_elements_contiguous
, is_same< typename remove_const< typename ::boost::container::iterator_traits::value_type >::type
, typename ::boost::container::iterator_traits::value_type
>
>
{};
template
struct is_memtransfer_copy_assignable
: boost::move_detail::and_
< are_contiguous_and_same
, dtl::is_trivially_copy_assignable< typename ::boost::container::iterator_traits::value_type >
>
{};
template
struct is_memtransfer_copy_constructible
: boost::move_detail::and_
< are_contiguous_and_same
, dtl::is_trivially_copy_constructible< typename ::boost::container::iterator_traits::value_type >
>
{};
template
struct enable_if_memtransfer_copy_constructible
: enable_if, R>
{};
template
struct disable_if_memtransfer_copy_constructible
: disable_if, R>
{};
template
struct enable_if_memtransfer_copy_assignable
: enable_if, R>
{};
template
struct disable_if_memtransfer_copy_assignable
: disable_if, R>
{};
template
// F models ForwardIterator
inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
{
typedef typename boost::container::iterator_traits::value_type value_type;
value_type *const dest_raw = boost::movelib::iterator_to_raw_pointer(r);
const value_type *const beg_raw = boost::movelib::iterator_to_raw_pointer(f);
const value_type *const end_raw = boost::movelib::iterator_to_raw_pointer(l);
if(BOOST_LIKELY(beg_raw != end_raw && dest_raw && beg_raw)){
const typename boost::container::iterator_traits::difference_type n = end_raw - beg_raw;
std::memmove(dest_raw, beg_raw, sizeof(value_type)*n);
boost::container::iterator_advance(r, n);
}
return r;
}
template
// F models ForwardIterator
F memmove_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{
typedef typename boost::container::iterator_traits::value_type value_type;
if(BOOST_LIKELY(n)){
std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
boost::container::iterator_advance(r, n);
}
return r;
}
template
// F models ForwardIterator
I memmove_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{
if(BOOST_LIKELY(n)){
typedef typename boost::container::iterator_traits::value_type value_type;
std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
boost::container::iterator_advance(f, n);
}
return f;
}
template
// F models ForwardIterator
I memmove_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
{
typedef typename boost::container::iterator_traits::value_type value_type;
if(BOOST_LIKELY(n)){
std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
boost::container::iterator_advance(f, n);
boost::container::iterator_advance(r, n);
}
return f;
}
template
struct is_memzero_initializable
{
typedef typename ::boost::container::iterator_traits::value_type value_type;
static const bool value = are_elements_contiguous::value &&
( dtl::is_integral::value || dtl::is_enum::value
#if defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
|| dtl::is_pointer::value
#endif
#if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO)
|| dtl::is_floating_point::value
#endif
#if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO) && defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
|| dtl::is_pod::value
#endif
);
};
template
struct enable_if_memzero_initializable
: enable_if_c::value, R>
{};
template
struct disable_if_memzero_initializable
: enable_if_c::value, R>
{};
template
struct enable_if_trivially_destructible
: enable_if_c < dtl::is_trivially_destructible
::value_type>::value
, R>
{};
template
struct disable_if_trivially_destructible
: enable_if_c ::value_type>::value
, R>
{};
} //namespace dtl {
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_move_alloc
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; f != l; ++r, ++f)
//! allocator_traits::construct(a, &*r, boost::move(*f));
//! \endcode
//!
//! Returns: r
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_constructible::type
uninitialized_move_alloc(Allocator &a, I f, I l, F r)
{
F back = r;
BOOST_TRY{
while (f != l) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_constructible::type
uninitialized_move_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove(f, l, r); }
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_move_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; n--; ++r, ++f)
//! allocator_traits::construct(a, &*r, boost::move(*f));
//! \endcode
//!
//! Returns: r
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_constructible::type
uninitialized_move_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits::size_type n, F r)
{
F back = r;
BOOST_TRY{
while (n--) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_constructible::type
uninitialized_move_alloc_n(Allocator &, I f, typename boost::container::allocator_traits::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_move_alloc_n_source
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; n--; ++r, ++f)
//! allocator_traits::construct(a, &*r, boost::move(*f));
//! \endcode
//!
//! Returns: f (after incremented)
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_constructible::type
uninitialized_move_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits::size_type n, F r)
{
F back = r;
BOOST_TRY{
while (n--) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return f;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_constructible::type
uninitialized_move_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n_source(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_copy_alloc
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; f != l; ++r, ++f)
//! allocator_traits::construct(a, &*r, *f);
//! \endcode
//!
//! Returns: r
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_constructible::type
uninitialized_copy_alloc(Allocator &a, I f, I l, F r)
{
F back = r;
BOOST_TRY{
while (f != l) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
++f; ++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_constructible::type
uninitialized_copy_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove(f, l, r); }
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_copy_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; n--; ++r, ++f)
//! allocator_traits::construct(a, &*r, *f);
//! \endcode
//!
//! Returns: r
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_constructible::type
uninitialized_copy_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits::size_type n, F r)
{
F back = r;
BOOST_TRY{
while (n--) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
++f; ++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_constructible::type
uninitialized_copy_alloc_n(Allocator &, I f, typename boost::container::allocator_traits::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_copy_alloc_n_source
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; n--; ++r, ++f)
//! allocator_traits::construct(a, &*r, *f);
//! \endcode
//!
//! Returns: f (after incremented)
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_constructible::type
uninitialized_copy_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits::size_type n, F r)
{
F back = r;
BOOST_TRY{
while (n) {
boost::container::construct_in_place(a, boost::movelib::iterator_to_raw_pointer(r), f);
++f; ++r; --n;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return f;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_constructible::type
uninitialized_copy_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n_source(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_value_init_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; n--; ++r, ++f)
//! allocator_traits::construct(a, &*r);
//! \endcode
//!
//! Returns: r
template
// F models ForwardIterator
inline typename dtl::disable_if_memzero_initializable::type
uninitialized_value_init_alloc_n(Allocator &a, typename boost::container::allocator_traits::size_type n, F r)
{
F back = r;
BOOST_TRY{
while (n--) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r));
++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memzero_initializable::type
uninitialized_value_init_alloc_n(Allocator &, typename boost::container::allocator_traits::size_type n, F r)
{
typedef typename boost::container::iterator_traits::value_type value_type;
if (BOOST_LIKELY(n)){
std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
boost::container::iterator_advance(r, n);
}
return r;
}
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_default_init_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; n--; ++r, ++f)
//! allocator_traits::construct(a, &*r);
//! \endcode
//!
//! Returns: r
template
// F models ForwardIterator
inline F uninitialized_default_init_alloc_n(Allocator &a, typename boost::container::allocator_traits::size_type n, F r)
{
F back = r;
BOOST_TRY{
while (n--) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r), default_init);
++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
}
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_fill_alloc
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; f != l; ++r, ++f)
//! allocator_traits::construct(a, &*r, *f);
//! \endcode
//!
//! Returns: r
template
inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
{
F back = f;
BOOST_TRY{
while (f != l) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(f), t);
++f;
}
}
BOOST_CATCH(...){
for (; back != l; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
}
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_fill_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
//! Effects:
//! \code
//! for (; n--; ++r, ++f)
//! allocator_traits::construct(a, &*r, v);
//! \endcode
//!
//! Returns: r
template
// F models ForwardIterator
inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename boost::container::allocator_traits::size_type n, F r)
{
F back = r;
BOOST_TRY{
while (n--) {
allocator_traits::construct(a, boost::movelib::iterator_to_raw_pointer(r), v);
++r;
}
}
BOOST_CATCH(...){
for (; back != r; ++back){
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
}
BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
}
//////////////////////////////////////////////////////////////////////////////
//
// copy
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
copy(I f, I l, F r)
{
while (f != l) {
*r = *f;
++f; ++r;
}
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
copy(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove(f, l, r); }
//////////////////////////////////////////////////////////////////////////////
//
// copy_n
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
copy_n(I f, U n, F r)
{
while (n) {
--n;
*r = *f;
++f; ++r;
}
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
copy_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// copy_n_source
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
copy_n_source(I f, U n, F r)
{
while (n--) {
boost::container::assign_in_place(r, f);
++f; ++r;
}
return f;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
copy_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n_source(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// copy_n_source_dest
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
copy_n_source_dest(I f, U n, F &r)
{
while (n--) {
*r = *f;
++f; ++r;
}
return f;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
copy_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n_source_dest(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// move
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
move(I f, I l, F r)
{
while (f != l) {
*r = ::boost::move(*f);
++f; ++r;
}
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
move(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove(f, l, r); }
//////////////////////////////////////////////////////////////////////////////
//
// move_n
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
move_n(I f, U n, F r)
{
while (n--) {
*r = ::boost::move(*f);
++f; ++r;
}
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
move_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// move_backward
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
move_backward(I f, I l, F r)
{
while (f != l) {
--l; --r;
*r = ::boost::move(*l);
}
return r;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
move_backward(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
{
typedef typename boost::container::iterator_traits::value_type value_type;
const typename boost::container::iterator_traits::difference_type n = boost::container::iterator_distance(f, l);
if (BOOST_LIKELY(n)){
r -= n;
std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
}
return r;
}
//////////////////////////////////////////////////////////////////////////////
//
// move_n_source_dest
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
move_n_source_dest(I f, U n, F &r)
{
while (n--) {
*r = ::boost::move(*f);
++f; ++r;
}
return f;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
move_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n_source_dest(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// move_n_source
//
//////////////////////////////////////////////////////////////////////////////
template
// F models ForwardIterator
inline typename dtl::disable_if_memtransfer_copy_assignable::type
move_n_source(I f, U n, F r)
{
while (n--) {
*r = ::boost::move(*f);
++f; ++r;
}
return f;
}
template
// F models ForwardIterator
inline typename dtl::enable_if_memtransfer_copy_assignable::type
move_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
{ return dtl::memmove_n_source(f, n, r); }
//////////////////////////////////////////////////////////////////////////////
//
// destroy_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
template
// U models unsigned integral constant
inline typename dtl::disable_if_trivially_destructible::type
destroy_alloc_n(Allocator &a, I f, U n)
{
while(n){
--n;
allocator_traits::destroy(a, boost::movelib::iterator_to_raw_pointer(f));
++f;
}
}
template
// U models unsigned integral constant
inline typename dtl::enable_if_trivially_destructible::type
destroy_alloc_n(Allocator &, I, U)
{}
//////////////////////////////////////////////////////////////////////////////
//
// deep_swap_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
template
inline typename dtl::disable_if_memtransfer_copy_assignable::type
deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits::size_type n_i
, G large_range_f, typename allocator_traits::size_type n_j)
{
typename allocator_traits::size_type n = 0;
for (; n != n_i ; ++short_range_f, ++large_range_f, ++n){
boost::adl_move_swap(*short_range_f, *large_range_f);
}
boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f); // may throw
boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
}
static const std::size_t DeepSwapAllocNMaxStorage = std::size_t(1) << std::size_t(11); //2K bytes
template
inline typename dtl::enable_if_c
< dtl::is_memtransfer_copy_assignable::value && (MaxTmpBytes <= DeepSwapAllocNMaxStorage) && false
, void>::type
deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits::size_type n_i
, G large_range_f, typename allocator_traits::size_type n_j)
{
typedef typename allocator_traits::value_type value_type;
typedef typename dtl::aligned_storage
::value>::type storage_type;
storage_type storage;
const std::size_t n_i_bytes = sizeof(value_type)*n_i;
void *const large_ptr = static_cast(boost::movelib::iterator_to_raw_pointer(large_range_f));
void *const short_ptr = static_cast(boost::movelib::iterator_to_raw_pointer(short_range_f));
void *const stora_ptr = static_cast(boost::movelib::iterator_to_raw_pointer(storage.data));
std::memcpy(stora_ptr, large_ptr, n_i_bytes);
std::memcpy(large_ptr, short_ptr, n_i_bytes);
std::memcpy(short_ptr, stora_ptr, n_i_bytes);
boost::container::iterator_advance(large_range_f, n_i);
boost::container::iterator_advance(short_range_f, n_i);
boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f); // may throw
boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
}
template
inline typename dtl::enable_if_c
< dtl::is_memtransfer_copy_assignable::value && true//(MaxTmpBytes > DeepSwapAllocNMaxStorage)
, void>::type
deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits::size_type n_i
, G large_range_f, typename allocator_traits::size_type n_j)
{
typedef typename allocator_traits::value_type value_type;
typedef typename dtl::aligned_storage
::value>::type storage_type;
storage_type storage;
const std::size_t sizeof_storage = sizeof(storage);
std::size_t n_i_bytes = sizeof(value_type)*n_i;
char *large_ptr = static_cast(static_cast(boost::movelib::iterator_to_raw_pointer(large_range_f)));
char *short_ptr = static_cast(static_cast(boost::movelib::iterator_to_raw_pointer(short_range_f)));
char *stora_ptr = static_cast(static_cast(storage.data));
std::size_t szt_times = n_i_bytes/sizeof_storage;
const std::size_t szt_rem = n_i_bytes%sizeof_storage;
//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);
switch(branch_number){
case 4:
break;
case 0: do{
std::memcpy(stora_ptr, large_ptr, sizeof_storage);
std::memcpy(large_ptr, short_ptr, sizeof_storage);
std::memcpy(short_ptr, stora_ptr, sizeof_storage);
large_ptr += sizeof_storage;
short_ptr += sizeof_storage;
BOOST_FALLTHROUGH;
case 3:
std::memcpy(stora_ptr, large_ptr, sizeof_storage);
std::memcpy(large_ptr, short_ptr, sizeof_storage);
std::memcpy(short_ptr, stora_ptr, sizeof_storage);
large_ptr += sizeof_storage;
short_ptr += sizeof_storage;
BOOST_FALLTHROUGH;
case 2:
std::memcpy(stora_ptr, large_ptr, sizeof_storage);
std::memcpy(large_ptr, short_ptr, sizeof_storage);
std::memcpy(short_ptr, stora_ptr, sizeof_storage);
large_ptr += sizeof_storage;
short_ptr += sizeof_storage;
BOOST_FALLTHROUGH;
case 1:
std::memcpy(stora_ptr, large_ptr, sizeof_storage);
std::memcpy(large_ptr, short_ptr, sizeof_storage);
std::memcpy(short_ptr, stora_ptr, sizeof_storage);
large_ptr += sizeof_storage;
short_ptr += sizeof_storage;
} while(--n);
}
std::memcpy(stora_ptr, large_ptr, szt_rem);
std::memcpy(large_ptr, short_ptr, szt_rem);
std::memcpy(short_ptr, stora_ptr, szt_rem);
boost::container::iterator_advance(large_range_f, n_i);
boost::container::iterator_advance(short_range_f, n_i);
boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f); // may throw
boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
}
//////////////////////////////////////////////////////////////////////////////
//
// copy_assign_range_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
template
void copy_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits::size_type n_i
, O out_start, typename allocator_traits::size_type n_o )
{
if (n_o < n_i){
inp_start = boost::container::copy_n_source_dest(inp_start, n_o, out_start); // may throw
boost::container::uninitialized_copy_alloc_n(a, inp_start, n_i - n_o, out_start);// may throw
}
else{
out_start = boost::container::copy_n(inp_start, n_i, out_start); // may throw
boost::container::destroy_alloc_n(a, out_start, n_o - n_i);
}
}
//////////////////////////////////////////////////////////////////////////////
//
// move_assign_range_alloc_n
//
//////////////////////////////////////////////////////////////////////////////
template
void move_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits::size_type n_i
, O out_start, typename allocator_traits::size_type n_o )
{
if (n_o < n_i){
inp_start = boost::container::move_n_source_dest(inp_start, n_o, out_start); // may throw
boost::container::uninitialized_move_alloc_n(a, inp_start, n_i - n_o, out_start); // may throw
}
else{
out_start = boost::container::move_n(inp_start, n_i, out_start); // may throw
boost::container::destroy_alloc_n(a, out_start, n_o - n_i);
}
}
} //namespace container {
} //namespace boost {
//#pragma GCC diagnostic ignored "-Wclass-memaccess"
#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
#pragma GCC diagnostic pop
#endif
#endif //#ifndef BOOST_CONTAINER_DETAIL_COPY_MOVE_ALGO_HPP