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

Merge branch 'develop'

Browse Source
This commit is contained in:
Ion Gaztañaga
2014-06-12 21:50:01 +02:00
parent 7f98fcb9bc ac7fb5a86b
commit b6f8b0fa90
6 changed files with 52 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1683,7 +1683,7 @@ class deque : protected deque_base<Allocator>
for(;p != p2; ++p){ for(;p != p2; ++p){
allocator_traits_type::destroy allocator_traits_type::destroy
( this->alloc() ( this->alloc()
, container_detail::to_raw_pointer(&*p) , container_detail::to_raw_pointer(container_detail::iterator_to_pointer(p))
); );
} }
} }
@@ -1693,7 +1693,7 @@ class deque : protected deque_base<Allocator>
for(;p != p2; ++p){ for(;p != p2; ++p){
allocator_traits_type::destroy allocator_traits_type::destroy
( this->alloc() ( this->alloc()
, container_detail::to_raw_pointer(&*p) , container_detail::to_raw_pointer(container_detail::iterator_to_pointer(p))
); );
} }
} }

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

@@ -482,7 +482,7 @@ class private_adaptive_node_pool_impl
free_nodes_iterator itf(nodes.begin()), itbf(itbb); free_nodes_iterator itf(nodes.begin()), itbf(itbb);
size_type splice_node_count = size_type(-1); size_type splice_node_count = size_type(-1);
while(itf != ite){ while(itf != ite){
void *pElem = container_detail::to_raw_pointer(&*itf); void *pElem = container_detail::to_raw_pointer(container_detail::iterator_to_pointer(itf));
block_info_t &block_info = *this->priv_block_from_node(pElem); block_info_t &block_info = *this->priv_block_from_node(pElem);
BOOST_ASSERT(block_info.free_nodes.size() < m_real_num_node); BOOST_ASSERT(block_info.free_nodes.size() < m_real_num_node);
++splice_node_count; ++splice_node_count;

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

@@ -138,7 +138,7 @@ struct insert_copy_proxy
void uninitialized_copy_n_and_update(A &a, Iterator p, size_type n) const void uninitialized_copy_n_and_update(A &a, Iterator p, size_type n) const
{ {
BOOST_ASSERT(n == 1); (void)n; BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a, container_detail::to_raw_pointer(&*p), v_); alloc_traits::construct( a, iterator_to_raw_pointer(p), v_);
} }
void copy_n_and_update(A &, Iterator p, size_type n) const void copy_n_and_update(A &, Iterator p, size_type n) const
@@ -165,10 +165,7 @@ struct insert_move_proxy
void uninitialized_copy_n_and_update(A &a, Iterator p, size_type n) const void uninitialized_copy_n_and_update(A &a, Iterator p, size_type n) const
{ {
BOOST_ASSERT(n == 1); (void)n; BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a alloc_traits::construct( a, iterator_to_raw_pointer(p), ::boost::move(v_) );
, container_detail::to_raw_pointer(&*p)
, ::boost::move(v_)
);
} }
void copy_n_and_update(A &, Iterator p, size_type n) const void copy_n_and_update(A &, Iterator p, size_type n) const
@@ -226,10 +223,7 @@ struct insert_non_movable_emplace_proxy
void priv_uninitialized_copy_some_and_update(A &a, const index_tuple<IdxPack...>&, Iterator p, size_type n) void priv_uninitialized_copy_some_and_update(A &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
{ {
BOOST_ASSERT(n == 1); (void)n; BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( a alloc_traits::construct( a, iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
, container_detail::to_raw_pointer(&*p)
, ::boost::forward<Args>(get<IdxPack>(this->args_))...
);
} }
protected: protected:
@@ -303,8 +297,7 @@ struct BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, N)
{ \ { \
BOOST_ASSERT(n == 1); (void)n; \ BOOST_ASSERT(n == 1); (void)n; \
alloc_traits::construct \ alloc_traits::construct \
( a \ ( a, iterator_to_raw_pointer(p) \
, container_detail::to_raw_pointer(&*p) \
BOOST_PP_ENUM_TRAILING(N, BOOST_CONTAINER_PP_MEMBER_FORWARD, _) \ BOOST_PP_ENUM_TRAILING(N, BOOST_CONTAINER_PP_MEMBER_FORWARD, _) \
); \ ); \
} \ } \
@@ -361,399 +354,3 @@ struct BOOST_PP_CAT(insert_emplace_proxy_arg, N)
#include <boost/container/detail/config_end.hpp> #include <boost/container/detail/config_end.hpp>
#endif //#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP #endif //#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
/*
//////////////////////////////////////////////////////////////////////////////
//
// (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 BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
#define BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/container/detail/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/utility.hpp>
#include <iterator> //std::iterator_traits
#include <boost/assert.hpp>
#include <boost/detail/no_exceptions_support.hpp>
namespace boost { namespace container { namespace container_detail {
template<class A, class FwdIt, class Iterator>
struct move_insert_range_proxy
{
typedef typename allocator_traits<A>::size_type size_type;
typedef typename allocator_traits<A>::value_type value_type;
move_insert_range_proxy(A& a, FwdIt first)
: a_(a), first_(first)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n)
{
this->first_ = ::boost::container::uninitialized_move_alloc_n_source
(this->a_, this->first_, n, p);
}
void copy_n_and_update(Iterator p, size_type n)
{
this->first_ = ::boost::container::move_n_source(this->first_, n, p);
}
A &a_;
FwdIt first_;
};
template<class A, class FwdIt, class Iterator>
struct insert_range_proxy
{
typedef typename allocator_traits<A>::size_type size_type;
typedef typename allocator_traits<A>::value_type value_type;
insert_range_proxy(A& a, FwdIt first)
: a_(a), first_(first)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n)
{
this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(this->a_, this->first_, n, p);
}
void copy_n_and_update(Iterator p, size_type n)
{
this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
}
A &a_;
FwdIt first_;
};
template<class A, class Iterator>
struct insert_n_copies_proxy
{
typedef typename allocator_traits<A>::size_type size_type;
typedef typename allocator_traits<A>::value_type value_type;
insert_n_copies_proxy(A& a, const value_type &v)
: a_(a), v_(v)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n) const
{ boost::container::uninitialized_fill_alloc_n(this->a_, v_, n, p); }
void copy_n_and_update(Iterator p, size_type n) const
{ std::fill_n(p, n, v_); }
A &a_;
const value_type &v_;
};
template<class A, class Iterator>
struct insert_value_initialized_n_proxy
{
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;
explicit insert_value_initialized_n_proxy(A &a)
: a_(a)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n) const
{ boost::container::uninitialized_value_init_alloc_n(this->a_, n, p); }
void copy_n_and_update(Iterator, size_type) const
{
BOOST_ASSERT(false);
}
private:
A &a_;
};
template<class A, class Iterator>
struct insert_default_initialized_n_proxy
{
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;
explicit insert_default_initialized_n_proxy(A &a)
: a_(a)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n) const
{ boost::container::uninitialized_default_init_alloc_n(this->a_, n, p); }
void copy_n_and_update(Iterator, size_type) const
{
BOOST_ASSERT(false);
}
private:
A &a_;
};
template<class A, class Iterator>
struct insert_copy_proxy
{
typedef boost::container::allocator_traits<A> alloc_traits;
typedef typename alloc_traits::size_type size_type;
typedef typename alloc_traits::value_type value_type;
insert_copy_proxy(A& a, const value_type &v)
: a_(a), v_(v)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n) const
{
BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( this->a_
, container_detail::to_raw_pointer(&*p)
, v_
);
}
void copy_n_and_update(Iterator p, size_type n) const
{
BOOST_ASSERT(n == 1); (void)n;
*p =v_;
}
A &a_;
const value_type &v_;
};
template<class A, class Iterator>
struct insert_move_proxy
{
typedef boost::container::allocator_traits<A> alloc_traits;
typedef typename alloc_traits::size_type size_type;
typedef typename alloc_traits::value_type value_type;
insert_move_proxy(A& a, value_type &v)
: a_(a), v_(v)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n) const
{
BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( this->a_
, container_detail::to_raw_pointer(&*p)
, ::boost::move(v_)
);
}
void copy_n_and_update(Iterator p, size_type n) const
{
BOOST_ASSERT(n == 1); (void)n;
*p = ::boost::move(v_);
}
A &a_;
value_type &v_;
};
template<class It, class A>
insert_move_proxy<A, It> get_insert_value_proxy(A& a, BOOST_RV_REF(typename std::iterator_traits<It>::value_type) v)
{
return insert_move_proxy<A, It>(a, v);
}
template<class It, class A>
insert_copy_proxy<A, It> get_insert_value_proxy(A& a, const typename std::iterator_traits<It>::value_type &v)
{
return insert_copy_proxy<A, It>(a, v);
}
}}} //namespace boost { namespace container { namespace container_detail {
#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
#include <boost/container/detail/variadic_templates_tools.hpp>
#include <boost/move/utility.hpp>
#include <typeinfo>
//#include <iostream> //For debugging purposes
namespace boost {
namespace container {
namespace container_detail {
template<class A, class Iterator, class ...Args>
struct insert_non_movable_emplace_proxy
{
typedef boost::container::allocator_traits<A> alloc_traits;
typedef typename alloc_traits::size_type size_type;
typedef typename alloc_traits::value_type value_type;
typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
explicit insert_non_movable_emplace_proxy(A &a, Args&&... args)
: a_(a), args_(args...)
{}
void uninitialized_copy_n_and_update(Iterator p, size_type n)
{ this->priv_uninitialized_copy_some_and_update(index_tuple_t(), p, n); }
private:
template<int ...IdxPack>
void priv_uninitialized_copy_some_and_update(const index_tuple<IdxPack...>&, Iterator p, size_type n)
{
BOOST_ASSERT(n == 1); (void)n;
alloc_traits::construct( this->a_
, container_detail::to_raw_pointer(&*p)
, ::boost::forward<Args>(get<IdxPack>(this->args_))...
);
}
protected:
A &a_;
tuple<Args&...> args_;
};
template<class A, class Iterator, class ...Args>
struct insert_emplace_proxy
: public insert_non_movable_emplace_proxy<A, Iterator, Args...>
{
typedef insert_non_movable_emplace_proxy<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::size_type size_type;
typedef typename base_t::index_tuple_t index_tuple_t;
explicit insert_emplace_proxy(A &a, Args&&... args)
: base_t(a, ::boost::forward<Args>(args)...)
{}
void copy_n_and_update(Iterator p, size_type n)
{ this->priv_copy_some_and_update(index_tuple_t(), p, n); }
private:
template<int ...IdxPack>
void priv_copy_some_and_update(const index_tuple<IdxPack...>&, Iterator p, size_type n)
{
BOOST_ASSERT(n ==1); (void)n;
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::forward<Args>(get<IdxPack>(this->args_))...);
BOOST_TRY{
*p = ::boost::move(*vp);
}
BOOST_CATCH(...){
alloc_traits::destroy(this->a_, vp);
BOOST_RETHROW
}
BOOST_CATCH_END
alloc_traits::destroy(this->a_, vp);
}
};
}}} //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(insert_non_movable_emplace_proxy_arg, N) \
{ \
typedef boost::container::allocator_traits<A> alloc_traits; \
typedef typename alloc_traits::size_type size_type; \
typedef typename alloc_traits::value_type value_type; \
\
BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, N) \
( A &a BOOST_PP_ENUM_TRAILING(N, BOOST_CONTAINER_PP_PARAM_LIST, _) ) \
: a_(a) \
BOOST_PP_ENUM_TRAILING(N, BOOST_CONTAINER_PP_PARAM_INIT, _) \
{} \
\
void uninitialized_copy_n_and_update(Iterator p, size_type n) \
{ \
BOOST_ASSERT(n == 1); (void)n; \
alloc_traits::construct \
( this->a_ \
, container_detail::to_raw_pointer(&*p) \
BOOST_PP_ENUM_TRAILING(N, BOOST_CONTAINER_PP_MEMBER_FORWARD, _) \
); \
} \
\
void copy_n_and_update(Iterator, size_type) \
{ BOOST_ASSERT(false); } \
\
protected: \
A &a_; \
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(insert_emplace_proxy_arg, N) \
: BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, N) \
< A, Iterator BOOST_PP_ENUM_TRAILING_PARAMS(N, P) > \
{ \
typedef BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, N) \
<A, Iterator BOOST_PP_ENUM_TRAILING_PARAMS(N, P) > base_t; \
typedef typename base_t::value_type value_type; \
typedef typename base_t::size_type size_type; \
typedef boost::container::allocator_traits<A> alloc_traits; \
\
BOOST_PP_CAT(insert_emplace_proxy_arg, N) \
( 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, _) ) \
{} \
\
void copy_n_and_update(Iterator p, size_type n) \
{ \
BOOST_ASSERT(n == 1); (void)n; \
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, _)); \
BOOST_TRY{ \
*p = ::boost::move(*vp); \
} \
BOOST_CATCH(...){ \
alloc_traits::destroy(this->a_, vp); \
BOOST_RETHROW \
} \
BOOST_CATCH_END \
alloc_traits::destroy(this->a_, vp); \
} \
}; \
//!
#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
*/

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

@@ -261,7 +261,7 @@ struct node_alloc_holder
Deallocator node_deallocator(NodePtr(), nalloc); Deallocator node_deallocator(NodePtr(), nalloc);
container_detail::scoped_destructor<NodeAlloc> sdestructor(nalloc, 0); container_detail::scoped_destructor<NodeAlloc> sdestructor(nalloc, 0);
while(n--){ while(n--){
p = container_detail::to_raw_pointer(&*itbeg); p = container_detail::to_raw_pointer(iterator_to_pointer(itbeg));
node_deallocator.set(p); node_deallocator.set(p);
++itbeg; ++itbeg;
//This can throw //This can throw

12
include/boost/container/detail/transform_iterator.hpp
View File

@@ -34,10 +34,10 @@ struct operator_arrow_proxy
: m_value(px) : m_value(px)
{} {}
typedef PseudoReference element_type;
PseudoReference* operator->() const { return &m_value; } PseudoReference* operator->() const { return &m_value; }
// This function is needed for MWCW and BCC, which won't call operator->
// again automatically per 13.3.1.2 para 8
// operator T*() const { return &m_value; }
mutable PseudoReference m_value; mutable PseudoReference m_value;
}; };
@@ -48,10 +48,10 @@ struct operator_arrow_proxy<T&>
: m_value(px) : m_value(px)
{} {}
typedef T element_type;
T* operator->() const { return const_cast<T*>(&m_value); } T* operator->() const { return const_cast<T*>(&m_value); }
// This function is needed for MWCW and BCC, which won't call operator->
// again automatically per 13.3.1.2 para 8
// operator T*() const { return &m_value; }
T &m_value; T &m_value;
}; };

59
include/boost/container/detail/utilities.hpp
View File

@@ -34,6 +34,7 @@
#include <boost/type_traits/has_trivial_copy.hpp> #include <boost/type_traits/has_trivial_copy.hpp>
#include <boost/type_traits/has_trivial_assign.hpp> #include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/container/detail/memory_util.hpp> #include <boost/container/detail/memory_util.hpp>
#include <boost/intrusive/pointer_traits.hpp>
#include <boost/aligned_storage.hpp> #include <boost/aligned_storage.hpp>
#include <algorithm> #include <algorithm>
#include <iterator> #include <iterator>
@@ -159,10 +160,26 @@ inline T* to_raw_pointer(T* p)
{ return p; } { return p; }
template <class Pointer> template <class Pointer>
inline typename Pointer::element_type* inline typename boost::intrusive::pointer_traits<Pointer>::element_type*
to_raw_pointer(const Pointer &p) to_raw_pointer(const Pointer &p)
{ return boost::container::container_detail::to_raw_pointer(p.operator->()); } { return boost::container::container_detail::to_raw_pointer(p.operator->()); }
template <class T>
inline T* iterator_to_pointer(T* i)
{ return i; }
template <class Iterator>
inline typename std::iterator_traits<Iterator>::pointer
iterator_to_pointer(const Iterator &i)
{ return i.operator->(); }
template <class Iterator>
inline
typename boost::intrusive::pointer_traits
<typename std::iterator_traits<Iterator>::pointer>::element_type*
iterator_to_raw_pointer(const Iterator &i)
{ return to_raw_pointer(iterator_to_pointer(i)); }
template<class AllocatorType> template<class AllocatorType>
inline void swap_alloc(AllocatorType &, AllocatorType &, container_detail::false_type) inline void swap_alloc(AllocatorType &, AllocatorType &, container_detail::false_type)
@@ -398,13 +415,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (f != l) { while (f != l) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), boost::move(*f)); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r; ++f; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -443,13 +460,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (n--) { while (n--) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), boost::move(*f)); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r; ++f; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -488,13 +505,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (n--) { while (n--) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), boost::move(*f)); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
++f; ++r; ++f; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -533,13 +550,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (f != l) { while (f != l) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), *f); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
++f; ++r; ++f; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -578,13 +595,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (n--) { while (n--) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), *f); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
++f; ++r; ++f; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -623,13 +640,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (n--) { while (n--) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), *f); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
++f; ++r; ++f; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -666,13 +683,13 @@ inline F uninitialized_value_init_alloc_n(A &a, typename allocator_traits<A>::di
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (n--) { while (n--) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r)); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r));
++r; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -701,13 +718,13 @@ inline F uninitialized_default_init_alloc_n(A &a, typename allocator_traits<A>::
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (n--) { while (n--) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), default_init); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), default_init);
++r; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -737,13 +754,13 @@ inline void uninitialized_fill_alloc(A &a, F f, F l, const T &t)
F back = f; F back = f;
BOOST_TRY{ BOOST_TRY{
while (f != l) { while (f != l) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*f), t); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(f), t);
++f; ++f;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != l; ++back){ for (; back != l; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }
@@ -773,13 +790,13 @@ inline F uninitialized_fill_alloc_n(A &a, const T &v, typename allocator_traits<
F back = r; F back = r;
BOOST_TRY{ BOOST_TRY{
while (n--) { while (n--) {
allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), v); allocator_traits<A>::construct(a, container_detail::iterator_to_raw_pointer(r), v);
++r; ++r;
} }
} }
BOOST_CATCH(...){ BOOST_CATCH(...){
for (; back != r; ++back){ for (; back != r; ++back){
allocator_traits<A>::destroy(a, container_detail::to_raw_pointer(&*back)); allocator_traits<A>::destroy(a, container_detail::iterator_to_raw_pointer(back));
} }
BOOST_RETHROW; BOOST_RETHROW;
} }