passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/container/detail/dispatch_uses_allocator.hpp

@@ -110,7 +110,7 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-inline typename dtl::enable_if_and
+BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
    , dtl::not_< uses_allocator<T, ArgAlloc> >
@@ -127,7 +127,7 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-inline typename dtl::enable_if_and
+BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
    , uses_allocator<T, ArgAlloc>
@@ -146,7 +146,7 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-inline typename dtl::enable_if_and
+BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
    , uses_allocator<T, ArgAlloc>
@@ -162,7 +162,7 @@ inline typename dtl::enable_if_and
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template <typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   inline typename dtl::enable_if_and\
+   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
       , dtl::not_<uses_allocator<T, ArgAlloc> >\
@@ -179,7 +179,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template < typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   inline typename dtl::enable_if_and\
+   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
       , uses_allocator<T, ArgAlloc>\
@@ -197,7 +197,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template < typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   inline typename dtl::enable_if_and\
+   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
       , uses_allocator<T, ArgAlloc>\
@@ -219,7 +219,7 @@ template < typename ConstructAlloc
          , typename ArgAlloc
          , typename Pair
          > inline 
-BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> >::type)
+BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MOVE_I void >::type)
    dispatch_uses_allocator
    ( ConstructAlloc & construct_alloc
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
@@ -240,7 +240,7 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> >::type)
 template < typename ConstructAlloc
          , typename ArgAlloc
          , class Pair, class U, class V>
-BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> >::type)
+BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MOVE_I void>::type)
    dispatch_uses_allocator
    ( ConstructAlloc & construct_alloc
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
@@ -260,7 +260,7 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> >::type)
 template < typename ConstructAlloc
          , typename ArgAlloc
          , class Pair, class Pair2>
-BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if< dtl::is_pair<Pair> >::type)
+BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if< dtl::is_pair<Pair> BOOST_MOVE_I void >::type)
    dispatch_uses_allocator
    (ConstructAlloc & construct_alloc
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
@@ -286,7 +286,7 @@ typename dtl::enable_if_and
 template< typename ConstructAlloc, typename ArgAlloc, class Pair \
         , template<class, class, class, class, class, class, class, class, class, class> class BoostTuple \
          BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
-typename dtl::enable_if< dtl::is_pair<Pair> >::type\
+typename dtl::enable_if< dtl::is_pair<Pair> BOOST_MOVE_I void>::type\
    dispatch_uses_allocator( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
       , BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> p\
       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q)\
@@ -330,7 +330,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
 
    template< typename ConstructAlloc, typename ArgAlloc, class Pair
            , template<class ...> class Tuple, class... Args1, class... Args2>
-   typename dtl::enable_if< dtl::is_pair<Pair> >::type
+   typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
       dispatch_uses_allocator( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t
                              , Tuple<Args1...> t1, Tuple<Args2...> t2)
    {
@@ -346,7 +346,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
    template< typename ConstructAlloc, typename ArgAlloc, class Pair\
            , template<class, class, class, class, class, class, class, class, class, class> class StdTuple\
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
-   typename dtl::enable_if< dtl::is_pair<Pair> >::type\
+   typename dtl::enable_if< dtl::is_pair<Pair> BOOST_MOVE_I void>::type\
       dispatch_uses_allocator(ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
                            , StdTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::std::tr1::_Nil)> p\
                            , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::std::tr1::_Nil)> q)\
@@ -380,7 +380,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
    template< typename ConstructAlloc, typename ArgAlloc, class Pair\
             , template<BOOST_MOVE_REPEAT(_VARIADIC_MAX, class), class, class, class> class StdTuple \
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
-   typename dtl::enable_if< dtl::is_pair<Pair> >::type\
+   typename dtl::enable_if< dtl::is_pair<Pair> BOOST_MOVE_I void>::type\
       dispatch_uses_allocator\
          ( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
          , StdTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),N),::std::_Nil) > p\
@@ -431,7 +431,7 @@ typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
 #define BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE_CODE(N) \
    template <typename ConstructAlloc, typename ArgAlloc, class Pair, class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
    inline typename dtl::enable_if\
-      < dtl::is_pair<Pair>, void >::type\
+      < dtl::is_pair<Pair> BOOST_MOVE_I void >::type\
       dispatch_uses_allocator\
       (ConstructAlloc &construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* p, try_emplace_t, \
        BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\

data/src/cxx_supportlib/vendor-modified/boost/container/detail/flat_tree.hpp

@@ -205,7 +205,7 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique  //has_merge_unique == f
 
    size_type const old_sz = dest.size();
    iterator const first_new = dest.insert(dest.cend(), first, last );
-   iterator e = boost::movelib::inplace_set_difference(first_new, dest.end(), dest.begin(), first_new, comp);
+   iterator e = boost::movelib::inplace_set_unique_difference(first_new, dest.end(), dest.begin(), first_new, comp);
    dest.erase(e, dest.end());
    dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
    (flat_tree_container_inplace_merge)(dest, dest.begin()+old_sz, comp, contiguous_tag);
@@ -427,13 +427,15 @@ class flat_tree_value_compare
       {  return *this;  }
 };
 
+
 ///////////////////////////////////////
 //
 //       select_container_type
 //
 ///////////////////////////////////////
 template < class Value, class AllocatorOrContainer
-         , bool = boost::container::dtl::is_container<AllocatorOrContainer>::value >
+         , bool = boost::container::dtl::is_container<AllocatorOrContainer>::value
+         >
 struct select_container_type
 {
    typedef AllocatorOrContainer type;
@@ -442,7 +444,7 @@ struct select_container_type
 template <class Value, class AllocatorOrContainer>
 struct select_container_type<Value, AllocatorOrContainer, false>
 {
-   typedef boost::container::vector<Value, AllocatorOrContainer> type;
+   typedef boost::container::vector<Value, typename real_allocator<Value, AllocatorOrContainer>::type> type;
 };
 
 
@@ -881,10 +883,14 @@ class flat_tree
       //Step 3: only left unique values from the back not already present in the original range
       typename container_type::iterator const e = boost::movelib::inplace_set_unique_difference
          (it, seq.end(), seq.begin(), it, val_cmp);
-      seq.erase(e, seq.cend());
 
-      //Step 4: merge both ranges
-      (flat_tree_container_inplace_merge)(seq, it, this->priv_value_comp(), contiguous_tag);
+      seq.erase(e, seq.cend());
+      //it might be invalidated by erasing [e, seq.end) if e == it
+      if (it != e)
+      {
+         //Step 4: merge both ranges
+         (flat_tree_container_inplace_merge)(seq, it, this->priv_value_comp(), contiguous_tag);
+      }
    }
 
    template <class InIt>
@@ -920,7 +926,7 @@ class flat_tree
    template <class... Args>
    std::pair<iterator, bool> emplace_unique(BOOST_FWD_REF(Args)... args)
    {
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
@@ -932,7 +938,7 @@ class flat_tree
    iterator emplace_hint_unique(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
       //hint checked in insert_unique
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
@@ -943,7 +949,7 @@ class flat_tree
    template <class... Args>
    iterator emplace_equal(BOOST_FWD_REF(Args)... args)
    {
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
@@ -955,7 +961,7 @@ class flat_tree
    iterator emplace_hint_equal(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
       //hint checked in insert_equal
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
@@ -992,7 +998,7 @@ class flat_tree
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    std::pair<iterator, bool> emplace_unique(BOOST_MOVE_UREF##N)\
    {\
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
@@ -1003,7 +1009,7 @@ class flat_tree
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    iterator emplace_hint_unique(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
@@ -1014,7 +1020,7 @@ class flat_tree
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    iterator emplace_equal(BOOST_MOVE_UREF##N)\
    {\
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
@@ -1025,7 +1031,7 @@ class flat_tree
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    iterator emplace_hint_equal(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      typename aligned_storage <sizeof(value_type), alignment_of<value_type>::value>::type v;\
+      typename dtl::aligned_storage <sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
@@ -1213,15 +1219,15 @@ class flat_tree
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge_unique(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
    {
-      this->insert( boost::make_move_iterator(source.begin())
-                  , boost::make_move_iterator(source.end()));
+      this->insert_unique( boost::make_move_iterator(source.begin())
+                         , boost::make_move_iterator(source.end()));
    }
 
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge_equal(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
    {
-      this->insert( boost::make_move_iterator(source.begin())
-                  , boost::make_move_iterator(source.end()));
+      this->insert_equal( boost::make_move_iterator(source.begin())
+                        , boost::make_move_iterator(source.end()));
    }
 
    BOOST_CONTAINER_FORCEINLINE void merge_unique(flat_tree& source)
@@ -1599,7 +1605,7 @@ class flat_tree
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;
       RanIt lb(this->priv_lower_bound(first, last, k)), ub(lb);
-      if(lb != last && static_cast<difference_type>(!key_cmp(k, key_extract(*lb)))){
+      if(lb != last && !key_cmp(k, key_extract(*lb))){
          ++ub;
       }
       return std::pair<RanIt, RanIt>(lb, ub);
@@ -1616,11 +1622,11 @@ template <class T, class KeyOfValue,
 class Compare, class AllocatorOrContainer>
 struct has_trivial_destructor_after_move<boost::container::dtl::flat_tree<T, KeyOfValue, Compare, AllocatorOrContainer> >
 {
-   typedef typename boost::container::dtl::select_container_type<T, AllocatorOrContainer>::type container_type;
-   typedef typename container_type::allocator_type allocator_t;
-   typedef typename ::boost::container::allocator_traits<allocator_t>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_t>::value &&
-                             ::boost::has_trivial_destructor_after_move<pointer>::value;
+   typedef boost::container::dtl::flat_tree<T, KeyOfValue, Compare, AllocatorOrContainer> flat_tree;
+   typedef typename flat_tree::container_type container_type;
+   typedef typename flat_tree::key_compare key_compare;
+   static const bool value = ::boost::has_trivial_destructor_after_move<container_type>::value &&
+                             ::boost::has_trivial_destructor_after_move<key_compare>::value;
 };
 
 }  //namespace boost {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/is_container.hpp

@@ -48,6 +48,13 @@ struct is_container
          has_member_function_callable_with_empty<const Container>::value;
 };
 
+template <>
+struct is_container<void>
+{
+   static const bool value = false;
+};
+
+
 }  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/iterators.hpp

@@ -49,106 +49,106 @@ class constant_iterator
    typedef  constant_iterator<T, Difference> this_type;
 
    public:
-   explicit constant_iterator(const T &ref, Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit constant_iterator(const T &ref, Difference range_size)
       :  m_ptr(&ref), m_num(range_size){}
 
    //Constructors
-   constant_iterator()
+   BOOST_CONTAINER_FORCEINLINE constant_iterator()
       :  m_ptr(0), m_num(0){}
 
-   constant_iterator& operator++()
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator++()
    { increment();   return *this;   }
 
-   constant_iterator operator++(int)
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator++(int)
    {
       constant_iterator result (*this);
       increment();
       return result;
    }
 
-   constant_iterator& operator--()
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator--()
    { decrement();   return *this;   }
 
-   constant_iterator operator--(int)
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator--(int)
    {
       constant_iterator result (*this);
       decrement();
       return result;
    }
 
-   friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
    { return i.equal(i2); }
 
-   friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
    { return !(i == i2); }
 
-   friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
    { return i.less(i2); }
 
-   friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
    { return i2 < i; }
 
-   friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
    { return !(i > i2); }
 
-   friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
    { return !(i < i2); }
 
-   friend Difference operator- (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const constant_iterator& i, const constant_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   constant_iterator& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator+=(Difference off)
    {  this->advance(off); return *this;   }
 
-   constant_iterator operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator+(Difference off) const
    {
       constant_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   friend constant_iterator operator+(Difference off, const constant_iterator& right)
+   BOOST_CONTAINER_FORCEINLINE friend constant_iterator operator+(Difference off, const constant_iterator& right)
    {  return right + off; }
 
-   constant_iterator& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator-=(Difference off)
    {  this->advance(-off); return *this;   }
 
-   constant_iterator operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator-(Difference off) const
    {  return *this + (-off);  }
 
-   const T& operator*() const
+   BOOST_CONTAINER_FORCEINLINE const T& operator*() const
    { return dereference(); }
 
-   const T& operator[] (Difference ) const
+   BOOST_CONTAINER_FORCEINLINE const T& operator[] (Difference ) const
    { return dereference(); }
 
-   const T* operator->() const
+   BOOST_CONTAINER_FORCEINLINE const T* operator->() const
    { return &(dereference()); }
 
    private:
    const T *   m_ptr;
    Difference  m_num;
 
-   void increment()
+   BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
 
-   void decrement()
+   BOOST_CONTAINER_FORCEINLINE void decrement()
    { ++m_num; }
 
-   bool equal(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   bool less(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   const T & dereference() const
+   BOOST_CONTAINER_FORCEINLINE const T & dereference() const
    { return *m_ptr; }
 
-   void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
    {  m_num -= n; }
 
-   Difference distance_to(const this_type &other)const
+   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other)const
    {  return m_num - other.m_num;   }
 };
 
@@ -160,72 +160,72 @@ class value_init_construct_iterator
    typedef  value_init_construct_iterator<T, Difference> this_type;
 
    public:
-   explicit value_init_construct_iterator(Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit value_init_construct_iterator(Difference range_size)
       :  m_num(range_size){}
 
    //Constructors
-   value_init_construct_iterator()
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator()
       :  m_num(0){}
 
-   value_init_construct_iterator& operator++()
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator++()
    { increment();   return *this;   }
 
-   value_init_construct_iterator operator++(int)
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator++(int)
    {
       value_init_construct_iterator result (*this);
       increment();
       return result;
    }
 
-   value_init_construct_iterator& operator--()
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator--()
    { decrement();   return *this;   }
 
-   value_init_construct_iterator operator--(int)
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator--(int)
    {
       value_init_construct_iterator result (*this);
       decrement();
       return result;
    }
 
-   friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i.equal(i2); }
 
-   friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return !(i == i2); }
 
-   friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i.less(i2); }
 
-   friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i2 < i; }
 
-   friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return !(i > i2); }
 
-   friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return !(i < i2); }
 
-   friend Difference operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   value_init_construct_iterator& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator+=(Difference off)
    {  this->advance(off); return *this;   }
 
-   value_init_construct_iterator operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator+(Difference off) const
    {
       value_init_construct_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   friend value_init_construct_iterator operator+(Difference off, const value_init_construct_iterator& right)
+   BOOST_CONTAINER_FORCEINLINE friend value_init_construct_iterator operator+(Difference off, const value_init_construct_iterator& right)
    {  return right + off; }
 
-   value_init_construct_iterator& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator-=(Difference off)
    {  this->advance(-off); return *this;   }
 
-   value_init_construct_iterator operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator-(Difference off) const
    {  return *this + (-off);  }
 
    //This pseudo-iterator's dereference operations have no sense since value is not
@@ -238,28 +238,28 @@ class value_init_construct_iterator
    private:
    Difference  m_num;
 
-   void increment()
+   BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
 
-   void decrement()
+   BOOST_CONTAINER_FORCEINLINE void decrement()
    { ++m_num; }
 
-   bool equal(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   bool less(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   const T & dereference() const
+   BOOST_CONTAINER_FORCEINLINE const T & dereference() const
    {
       static T dummy;
       return dummy;
    }
 
-   void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
    {  m_num -= n; }
 
-   Difference distance_to(const this_type &other)const
+   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other)const
    {  return m_num - other.m_num;   }
 };
 
@@ -271,72 +271,72 @@ class default_init_construct_iterator
    typedef  default_init_construct_iterator<T, Difference> this_type;
 
    public:
-   explicit default_init_construct_iterator(Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit default_init_construct_iterator(Difference range_size)
       :  m_num(range_size){}
 
    //Constructors
-   default_init_construct_iterator()
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator()
       :  m_num(0){}
 
-   default_init_construct_iterator& operator++()
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator++()
    { increment();   return *this;   }
 
-   default_init_construct_iterator operator++(int)
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator++(int)
    {
       default_init_construct_iterator result (*this);
       increment();
       return result;
    }
 
-   default_init_construct_iterator& operator--()
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator--()
    { decrement();   return *this;   }
 
-   default_init_construct_iterator operator--(int)
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator--(int)
    {
       default_init_construct_iterator result (*this);
       decrement();
       return result;
    }
 
-   friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i.equal(i2); }
 
-   friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return !(i == i2); }
 
-   friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i.less(i2); }
 
-   friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i2 < i; }
 
-   friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return !(i > i2); }
 
-   friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return !(i < i2); }
 
-   friend Difference operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   default_init_construct_iterator& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator+=(Difference off)
    {  this->advance(off); return *this;   }
 
-   default_init_construct_iterator operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator+(Difference off) const
    {
       default_init_construct_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   friend default_init_construct_iterator operator+(Difference off, const default_init_construct_iterator& right)
+   BOOST_CONTAINER_FORCEINLINE friend default_init_construct_iterator operator+(Difference off, const default_init_construct_iterator& right)
    {  return right + off; }
 
-   default_init_construct_iterator& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator-=(Difference off)
    {  this->advance(-off); return *this;   }
 
-   default_init_construct_iterator operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator-(Difference off) const
    {  return *this + (-off);  }
 
    //This pseudo-iterator's dereference operations have no sense since value is not
@@ -349,28 +349,28 @@ class default_init_construct_iterator
    private:
    Difference  m_num;
 
-   void increment()
+   BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
 
-   void decrement()
+   BOOST_CONTAINER_FORCEINLINE void decrement()
    { ++m_num; }
 
-   bool equal(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   bool less(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   const T & dereference() const
+   BOOST_CONTAINER_FORCEINLINE const T & dereference() const
    {
       static T dummy;
       return dummy;
    }
 
-   void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
    {  m_num -= n; }
 
-   Difference distance_to(const this_type &other)const
+   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other) const
    {  return m_num - other.m_num;   }
 };
 
@@ -382,106 +382,106 @@ class repeat_iterator
 {
    typedef repeat_iterator<T, Difference> this_type;
    public:
-   explicit repeat_iterator(T &ref, Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit repeat_iterator(T &ref, Difference range_size)
       :  m_ptr(&ref), m_num(range_size){}
 
    //Constructors
-   repeat_iterator()
+   BOOST_CONTAINER_FORCEINLINE repeat_iterator()
       :  m_ptr(0), m_num(0){}
 
-   this_type& operator++()
+   BOOST_CONTAINER_FORCEINLINE this_type& operator++()
    { increment();   return *this;   }
 
-   this_type operator++(int)
+   BOOST_CONTAINER_FORCEINLINE this_type operator++(int)
    {
       this_type result (*this);
       increment();
       return result;
    }
 
-   this_type& operator--()
+   BOOST_CONTAINER_FORCEINLINE this_type& operator--()
    { increment();   return *this;   }
 
-   this_type operator--(int)
+   BOOST_CONTAINER_FORCEINLINE this_type operator--(int)
    {
       this_type result (*this);
       increment();
       return result;
    }
 
-   friend bool operator== (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const this_type& i, const this_type& i2)
    { return i.equal(i2); }
 
-   friend bool operator!= (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const this_type& i, const this_type& i2)
    { return !(i == i2); }
 
-   friend bool operator< (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const this_type& i, const this_type& i2)
    { return i.less(i2); }
 
-   friend bool operator> (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const this_type& i, const this_type& i2)
    { return i2 < i; }
 
-   friend bool operator<= (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const this_type& i, const this_type& i2)
    { return !(i > i2); }
 
-   friend bool operator>= (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const this_type& i, const this_type& i2)
    { return !(i < i2); }
 
-   friend Difference operator- (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const this_type& i, const this_type& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   this_type& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE this_type& operator+=(Difference off)
    {  this->advance(off); return *this;   }
 
-   this_type operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE this_type operator+(Difference off) const
    {
       this_type other(*this);
       other.advance(off);
       return other;
    }
 
-   friend this_type operator+(Difference off, const this_type& right)
+   BOOST_CONTAINER_FORCEINLINE friend this_type operator+(Difference off, const this_type& right)
    {  return right + off; }
 
-   this_type& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE this_type& operator-=(Difference off)
    {  this->advance(-off); return *this;   }
 
-   this_type operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE this_type operator-(Difference off) const
    {  return *this + (-off);  }
 
-   T& operator*() const
+   BOOST_CONTAINER_FORCEINLINE T& operator*() const
    { return dereference(); }
 
-   T& operator[] (Difference ) const
+   BOOST_CONTAINER_FORCEINLINE T& operator[] (Difference ) const
    { return dereference(); }
 
-   T *operator->() const
+   BOOST_CONTAINER_FORCEINLINE T *operator->() const
    { return &(dereference()); }
 
    private:
    T *         m_ptr;
    Difference  m_num;
 
-   void increment()
+   BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
 
-   void decrement()
+   BOOST_CONTAINER_FORCEINLINE void decrement()
    { ++m_num; }
 
-   bool equal(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   bool less(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   T & dereference() const
+   BOOST_CONTAINER_FORCEINLINE T & dereference() const
    { return *m_ptr; }
 
-   void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
    {  m_num -= n; }
 
-   Difference distance_to(const this_type &other)const
+   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other)const
    {  return m_num - other.m_num;   }
 };
 
@@ -503,7 +503,7 @@ class emplace_iterator
    BOOST_CONTAINER_FORCEINLINE this_type& operator++()
    { increment();   return *this;   }
 
-   this_type operator++(int)
+   BOOST_CONTAINER_FORCEINLINE this_type operator++(int)
    {
       this_type result (*this);
       increment();
@@ -513,7 +513,7 @@ class emplace_iterator
    BOOST_CONTAINER_FORCEINLINE this_type& operator--()
    { decrement();   return *this;   }
 
-   this_type operator--(int)
+   BOOST_CONTAINER_FORCEINLINE this_type operator--(int)
    {
       this_type result (*this);
       decrement();
@@ -545,7 +545,7 @@ class emplace_iterator
    BOOST_CONTAINER_FORCEINLINE this_type& operator+=(difference_type off)
    {  this->advance(off); return *this;   }
 
-   this_type operator+(difference_type off) const
+   BOOST_CONTAINER_FORCEINLINE this_type operator+(difference_type off) const
    {
       this_type other(*this);
       other.advance(off);
@@ -571,11 +571,11 @@ class emplace_iterator
 
    public:
    template<class Allocator>
-   void construct_in_place(Allocator &a, T* ptr)
+   BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T* ptr)
    {  (*m_pe)(a, ptr);  }
 
    template<class DestIt>
-   void assign_in_place(DestIt dest)
+   BOOST_CONTAINER_FORCEINLINE void assign_in_place(DestIt dest)
    {  (*m_pe)(dest);  }
 
    private:
@@ -614,7 +614,7 @@ struct emplace_functor
 {
    typedef typename dtl::build_number_seq<sizeof...(Args)>::type index_tuple_t;
 
-   emplace_functor(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE emplace_functor(BOOST_FWD_REF(Args)... args)
       : args_(args...)
    {}
 
@@ -661,15 +661,15 @@ struct emplace_functor_type;
 BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
 struct emplace_functor##N\
 {\
-   explicit emplace_functor##N( BOOST_MOVE_UREF##N )\
+   BOOST_CONTAINER_FORCEINLINE explicit emplace_functor##N( BOOST_MOVE_UREF##N )\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N{}\
    \
    template<class Allocator, class T>\
-   void operator()(Allocator &a, T *ptr)\
+   BOOST_CONTAINER_FORCEINLINE void operator()(Allocator &a, T *ptr)\
    {  allocator_traits<Allocator>::construct(a, ptr BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);  }\
    \
    template<class DestIt>\
-   void operator()(DestIt dest)\
+   BOOST_CONTAINER_FORCEINLINE void operator()(DestIt dest)\
    {\
       typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;\
       BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), dtl::value_init<value_type> tmp) ;\
@@ -799,7 +799,16 @@ struct iterator_types<IIterator, false>
 template<class IIterator, bool IsConst>
 class iterator_from_iiterator
 {
-   typedef typename iterator_types<IIterator, IsConst>::type types_t;
+   typedef typename iterator_types<IIterator, IsConst>::type   types_t;
+   class nat
+   {
+      public:
+      IIterator get() const
+      {  return IIterator(); }
+   };
+   typedef typename dtl::if_c< IsConst
+                             , iterator_from_iiterator<IIterator, false>
+                             , nat>::type                      nonconst_iterator;
 
    public:
    typedef typename types_t::pointer             pointer;
@@ -816,10 +825,17 @@ class iterator_from_iiterator
       : m_iit(iit)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator(iterator_from_iiterator<IIterator, false> const& other) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW
       :  m_iit(other.get())
    {}
 
+   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator(const nonconst_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW
+      :  m_iit(other.get())
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator& operator=(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW
+   {  m_iit = other.get(); return *this;  }
+
    BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
    {  ++this->m_iit;   return *this;  }