passenger 6.0.8 → 6.0.9

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

@@ -183,28 +183,31 @@ struct scoped_destructor_n
    typedef typename AllocTraits::value_type value_type;
    typedef typename AllocTraits::size_type  size_type;
 
-   scoped_destructor_n(pointer p, Allocator& a, size_type n)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(pointer p, Allocator& a, size_type n)
       : m_p(p), m_a(a), m_n(n)
    {}
 
-   void release()
-   {  m_p = 0; }
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {  m_p = 0; m_n = 0; }
 
-   void increment_size(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type inc)
    {  m_n += inc;   }
 
-   void increment_size_backwards(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type inc)
    {  m_n += inc;   m_p -= inc;  }
 
-   void shrink_forward(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type inc)
    {  m_n -= inc;   m_p += inc;  }
 
    ~scoped_destructor_n()
    {
-      if(!m_p) return;
-      value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
-      while(m_n--){
-         AllocTraits::destroy(m_a, raw_ptr++);
+      if(m_n){
+         value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
+         do {
+            --m_n;
+            AllocTraits::destroy(m_a, raw_ptr);
+            ++raw_ptr;
+         } while(m_n);
       }
    }
 
@@ -223,46 +226,112 @@ struct null_scoped_destructor_n
    typedef typename AllocTraits::pointer pointer;
    typedef typename AllocTraits::size_type size_type;
 
-   null_scoped_destructor_n(pointer, Allocator&, size_type)
+   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(pointer, Allocator&, size_type)
    {}
 
-   void increment_size(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type)
    {}
 
-   void increment_size_backwards(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type)
    {}
 
-   void shrink_forward(size_type)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type)
    {}
 
-   void release()
+   BOOST_CONTAINER_FORCEINLINE void release()
    {}
 };
 
+
+//!A deleter for scoped_ptr that destroys
+//!an object using a STL allocator.
+template <class Allocator>
+struct scoped_destructor_range
+{
+   typedef boost::container::allocator_traits<Allocator> AllocTraits;
+   typedef typename AllocTraits::pointer    pointer;
+   typedef typename AllocTraits::value_type value_type;
+   
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor_range(pointer p, pointer e, Allocator& a)
+      : m_p(p), m_e(e), m_a(a)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {  m_p = pointer(); m_e = pointer(); }
+
+   BOOST_CONTAINER_FORCEINLINE void set_end(pointer e)
+   {  m_e = e;   }
+
+   BOOST_CONTAINER_FORCEINLINE void set_begin(pointer b)
+   {  m_p = b;  }
+
+   BOOST_CONTAINER_FORCEINLINE void set_range(pointer b, pointer e)
+   {  m_p = b; m_e = e;   }
+
+   ~scoped_destructor_range()
+   {
+      while(m_p != m_e){
+         value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
+         AllocTraits::destroy(m_a, raw_ptr);
+         ++m_p;
+      }
+   }
+
+   private:
+   pointer     m_p;
+   pointer     m_e;
+   Allocator & m_a;
+};
+
+//!A deleter for scoped_ptr that destroys
+//!an object using a STL allocator.
+template <class Allocator>
+struct null_scoped_destructor_range
+{
+   typedef boost::container::allocator_traits<Allocator> AllocTraits;
+   typedef typename AllocTraits::pointer pointer;
+
+   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_range(pointer, pointer, Allocator&)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void set_end(pointer)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void set_begin(pointer)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void set_range(pointer, pointer)
+   {}
+};
+
+
 template<class Allocator>
 class scoped_destructor
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef typename Allocator::value_type value_type;
-   scoped_destructor(Allocator &a, value_type *pv)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor(Allocator &a, value_type *pv)
       : pv_(pv), a_(a)
    {}
 
-   ~scoped_destructor()
+   BOOST_CONTAINER_FORCEINLINE ~scoped_destructor()
    {
       if(pv_){
          AllocTraits::destroy(a_, pv_);
       }
    }
 
-   void release()
+   BOOST_CONTAINER_FORCEINLINE void release()
    {  pv_ = 0; }
 
 
-   void set(value_type *ptr) { pv_ = ptr; }
+   BOOST_CONTAINER_FORCEINLINE void set(value_type *ptr) { pv_ = ptr; }
 
-   value_type *get() const { return pv_; }
+   BOOST_CONTAINER_FORCEINLINE value_type *get() const { return pv_; }
 
    private:
    value_type *pv_;
@@ -276,11 +345,11 @@ class value_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef Value value_type;
-   value_destructor(Allocator &a, value_type &rv)
+   BOOST_CONTAINER_FORCEINLINE value_destructor(Allocator &a, value_type &rv)
       : rv_(rv), a_(a)
    {}
 
-   ~value_destructor()
+   BOOST_CONTAINER_FORCEINLINE ~value_destructor()
    {
       AllocTraits::destroy(a_, &rv_);
    }
@@ -304,18 +373,18 @@ class allocator_destroyer
    Allocator & a_;
 
    private:
-   void priv_deallocate(const pointer &p, version_1)
+   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_1)
    {  AllocTraits::deallocate(a_,p, 1); }
 
-   void priv_deallocate(const pointer &p, version_2)
+   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_2)
    {  a_.deallocate_one(p); }
 
    public:
-   explicit allocator_destroyer(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE explicit allocator_destroyer(Allocator &a)
       : a_(a)
    {}
 
-   void operator()(const pointer &p)
+   BOOST_CONTAINER_FORCEINLINE void operator()(const pointer &p)
    {
       AllocTraits::destroy(a_, boost::movelib::to_raw_pointer(p));
       this->priv_deallocate(p, alloc_version());
@@ -333,11 +402,11 @@ class allocator_destroyer_and_chain_builder
    multiallocation_chain &c_;
 
    public:
-   allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
+   BOOST_CONTAINER_FORCEINLINE allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
       :  a_(a), c_(c)
    {}
 
-   void operator()(const typename Allocator::pointer &p)
+   BOOST_CONTAINER_FORCEINLINE void operator()(const typename Allocator::pointer &p)
    {
       allocator_traits<Allocator>::destroy(a_, boost::movelib::to_raw_pointer(p));
       c_.push_back(p);
@@ -356,14 +425,14 @@ class allocator_multialloc_chain_node_deallocator
    multiallocation_chain c_;
 
    public:
-   allocator_multialloc_chain_node_deallocator(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE allocator_multialloc_chain_node_deallocator(Allocator &a)
       :  a_(a), c_()
    {}
 
-   chain_builder get_chain_builder()
+   BOOST_CONTAINER_FORCEINLINE chain_builder get_chain_builder()
    {  return chain_builder(a_, c_);  }
 
-   ~allocator_multialloc_chain_node_deallocator()
+   BOOST_CONTAINER_FORCEINLINE ~allocator_multialloc_chain_node_deallocator()
    {
       a_.deallocate_individual(c_);
    }

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

@@ -113,7 +113,7 @@ template < typename ConstructAlloc
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
-   , dtl::not_< uses_allocator<T, ArgAlloc> >
+   , dtl::not_< uses_allocator<T, typename remove_cvref<ArgAlloc>::type > >
    >::type dispatch_uses_allocator
    ( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p, BOOST_FWD_REF(Args)...args)
 {
@@ -130,7 +130,7 @@ template < typename ConstructAlloc
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
-   , uses_allocator<T, ArgAlloc>
+   , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>
    , is_constructible_with_allocator_prefix<T, ArgAlloc, Args...>
    >::type dispatch_uses_allocator
    ( ConstructAlloc& construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p, BOOST_FWD_REF(Args) ...args)
@@ -149,7 +149,7 @@ template < typename ConstructAlloc
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
-   , uses_allocator<T, ArgAlloc>
+   , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>
    , dtl::not_<is_constructible_with_allocator_prefix<T, ArgAlloc, Args...> >
    >::type dispatch_uses_allocator
    ( ConstructAlloc& construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p, BOOST_FWD_REF(Args)...args)
@@ -165,7 +165,7 @@ BOOST_CONTAINER_FORCEINLINE 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> >\
+      , dtl::not_<uses_allocator<T, typename remove_cvref<ArgAlloc>::type> >\
       >::type\
       dispatch_uses_allocator\
       (ConstructAlloc &construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
@@ -182,7 +182,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
    BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
-      , uses_allocator<T, ArgAlloc>\
+      , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>\
       , is_constructible_with_allocator_prefix<T, ArgAlloc BOOST_MOVE_I##N BOOST_MOVE_TARG##N>\
       >::type\
       dispatch_uses_allocator\
@@ -200,7 +200,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
    BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
-      , uses_allocator<T, ArgAlloc>\
+      , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>\
       , dtl::not_<is_constructible_with_allocator_prefix<T, ArgAlloc BOOST_MOVE_I##N BOOST_MOVE_TARG##N> >\
       >::type\
       dispatch_uses_allocator\
@@ -225,9 +225,9 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MO
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
    , Pair* p)
 {
-   (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first));
+   dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first));
    BOOST_TRY{
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second));
+      dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second));
    }
    BOOST_CATCH(...) {
       allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
@@ -246,9 +246,9 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MO
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
    , Pair* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y)
 {
-   (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<U>(x));
+   dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<U>(x));
    BOOST_TRY{
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<V>(y));
+      dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<V>(y));
    }
    BOOST_CATCH(...){
       allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
@@ -265,7 +265,7 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if< dtl::is_pair<Pair> BOOST_M
    (ConstructAlloc & construct_alloc
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
    , Pair* p, Pair2& x)
-{  (dispatch_uses_allocator)(construct_alloc, arg_alloc, p, x.first, x.second);  }
+{  dispatch_uses_allocator(construct_alloc, arg_alloc, p, x.first, x.second);  }
 
 template < typename ConstructAlloc
          , typename ArgAlloc
@@ -278,7 +278,7 @@ typename dtl::enable_if_and
    (ConstructAlloc & construct_alloc
       , BOOST_FWD_REF(ArgAlloc) arg_alloc
       , Pair* p, BOOST_RV_REF_BEG Pair2 BOOST_RV_REF_END x)
-{  (dispatch_uses_allocator)(construct_alloc, arg_alloc, p, ::boost::move(x.first), ::boost::move(x.second));  }
+{  dispatch_uses_allocator(construct_alloc, arg_alloc, p, ::boost::move(x.first), ::boost::move(x.second));  }
 
 
 //piecewise construction from boost::tuple
@@ -292,10 +292,10 @@ typename dtl::enable_if< dtl::is_pair<Pair> BOOST_MOVE_I void>::type\
       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q)\
 {\
    (void)p; (void)q;\
-   (dispatch_uses_allocator)\
+   dispatch_uses_allocator\
       (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_TMPL_GET##N);\
    BOOST_TRY{\
-      (dispatch_uses_allocator)\
+      dispatch_uses_allocator\
          (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_TMPL_GETQ##M);\
    }\
    BOOST_CATCH(...) {\
@@ -317,9 +317,9 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
                                     , Tuple<Args1...>& t1, Tuple<Args2...>& t2, index_tuple<Indexes1...>, index_tuple<Indexes2...>)
    {
       (void)t1; (void)t2;
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(pair->first), ::boost::forward<Args1>(get<Indexes1>(t1))...);
+      dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(pair->first), ::boost::forward<Args1>(get<Indexes1>(t1))...);
       BOOST_TRY{
-         (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(pair->second), ::boost::forward<Args2>(get<Indexes2>(t2))...);
+         dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(pair->second), ::boost::forward<Args2>(get<Indexes2>(t2))...);
       }
       BOOST_CATCH(...){
          allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));
@@ -352,10 +352,10 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
                            , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::std::tr1::_Nil)> q)\
    {\
       (void)p; (void)q;\
-      (dispatch_uses_allocator)\
+      dispatch_uses_allocator\
          (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
       BOOST_TRY{\
-         (dispatch_uses_allocator)\
+         dispatch_uses_allocator\
             (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
       }\
       BOOST_CATCH(...) {\
@@ -387,10 +387,10 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
          , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),M),::std::_Nil) > q)\
    {\
       (void)p; (void)q;\
-      (dispatch_uses_allocator)\
+      dispatch_uses_allocator\
          (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
       BOOST_TRY{\
-         (dispatch_uses_allocator)\
+         dispatch_uses_allocator\
             (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
       }\
       BOOST_CATCH(...) {\
@@ -415,9 +415,9 @@ typename dtl::enable_if< dtl::is_pair<Pair>, 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_FWD_REF(Args) ...args)
 {
-   (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));
+   dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));
    BOOST_TRY{
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<Args>(args)...);
+      dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<Args>(args)...);
    }
    BOOST_CATCH(...) {
       allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
@@ -436,9 +436,9 @@ typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
       (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)\
    {\
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));\
+      dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));\
       BOOST_TRY{\
-         (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
       BOOST_CATCH(...) {\
          allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));\

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

@@ -55,6 +55,11 @@
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+#endif
+
 //merge_unique
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME merge_unique
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace dtl {
@@ -103,6 +108,11 @@
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
 #include <boost/intrusive/detail/has_member_function_callable_with.hpp>
 
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic pop
+#endif
+
+
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 namespace boost {
@@ -123,18 +133,19 @@ BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(stored_allocator_type)
 //
 ///////////////////////////////////////
 template<class SequenceContainer, class Compare>
-void flat_tree_container_inplace_merge //is_contiguous_container == true
+BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_merge //is_contiguous_container == true
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::true_)
 {
    typedef typename SequenceContainer::value_type  value_type;
    value_type *const braw = boost::movelib::iterator_to_raw_pointer(dest.begin());
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
    value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
-   boost::movelib::adaptive_merge(braw, iraw, eraw, comp, eraw, dest.capacity()- dest.size());
+   boost::movelib::adaptive_merge
+      (braw, iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_container_inplace_merge //is_contiguous_container == false
+BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_merge //is_contiguous_container == false
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp, dtl::false_)
 {
    boost::movelib::adaptive_merge(dest.begin(), it, dest.end(), comp);
@@ -146,17 +157,18 @@ void flat_tree_container_inplace_merge //is_contiguous_container == false
 //
 ///////////////////////////////////////
 template<class SequenceContainer, class Compare>
-void flat_tree_container_inplace_sort_ending //is_contiguous_container == true
+BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_sort_ending //is_contiguous_container == true
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp, dtl::true_)
 {
    typedef typename SequenceContainer::value_type  value_type;
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
    value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
-   boost::movelib::adaptive_sort(iraw, eraw, comp, eraw, dest.capacity()- dest.size());
+   boost::movelib::adaptive_sort
+      (iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_container_inplace_sort_ending //is_contiguous_container == false
+BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_sort_ending //is_contiguous_container == false
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::false_)
 {
    boost::movelib::adaptive_sort(it, dest.end(), comp);
@@ -312,7 +324,7 @@ void flat_tree_sort_contiguous_to_adopt // is_contiguous_container == true
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_adopt_sequence_equal // is_contiguous_container == true
+BOOST_CONTAINER_FORCEINLINE void flat_tree_adopt_sequence_equal // is_contiguous_container == true
    (SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::true_)
 {
    flat_tree_sort_contiguous_to_adopt(tseq, boost::move(seq), comp);
@@ -320,7 +332,7 @@ void flat_tree_adopt_sequence_equal // is_contiguous_container == true
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_adopt_sequence_equal // is_contiguous_container == false
+BOOST_CONTAINER_FORCEINLINE void flat_tree_adopt_sequence_equal // is_contiguous_container == false
    (SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::false_)
 {
    boost::movelib::adaptive_sort(seq.begin(), seq.end(), comp);
@@ -406,24 +418,24 @@ class flat_tree_value_compare
    typedef Value              second_argument_type;
    typedef bool               return_type;
    public:
-   flat_tree_value_compare()
+   BOOST_CONTAINER_FORCEINLINE flat_tree_value_compare()
       : Compare()
    {}
 
-   flat_tree_value_compare(const Compare &pred)
+   BOOST_CONTAINER_FORCEINLINE flat_tree_value_compare(const Compare &pred)
       : Compare(pred)
    {}
 
-   bool operator()(const Value& lhs, const Value& rhs) const
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const Value& lhs, const Value& rhs) const
    {
       KeyOfValue key_extract;
       return Compare::operator()(key_extract(lhs), key_extract(rhs));
    }
 
-   const Compare &get_comp() const
+   BOOST_CONTAINER_FORCEINLINE const Compare &get_comp() const
       {  return *this;  }
 
-   Compare &get_comp()
+   BOOST_CONTAINER_FORCEINLINE Compare &get_comp()
       {  return *this;  }
 };
 
@@ -477,35 +489,35 @@ class flat_tree
       BOOST_COPYABLE_AND_MOVABLE(Data)
 
       public:
-      Data()
+      BOOST_CONTAINER_FORCEINLINE Data()
          : value_compare(), m_seq()
       {}
 
-      explicit Data(const allocator_t &alloc)
+      BOOST_CONTAINER_FORCEINLINE explicit Data(const allocator_t &alloc)
          : value_compare(), m_seq(alloc)
       {}
 
-      explicit Data(const Compare &comp)
+      BOOST_CONTAINER_FORCEINLINE explicit Data(const Compare &comp)
          : value_compare(comp), m_seq()
       {}
 
-      Data(const Compare &comp, const allocator_t &alloc)
+      BOOST_CONTAINER_FORCEINLINE Data(const Compare &comp, const allocator_t &alloc)
          : value_compare(comp), m_seq(alloc)
       {}
 
-      explicit Data(const Data &d)
+      BOOST_CONTAINER_FORCEINLINE explicit Data(const Data &d)
          : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq)
       {}
 
-      Data(BOOST_RV_REF(Data) d)
+      BOOST_CONTAINER_FORCEINLINE Data(BOOST_RV_REF(Data) d)
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq))
       {}
 
-      Data(const Data &d, const allocator_t &a)
+      BOOST_CONTAINER_FORCEINLINE Data(const Data &d, const allocator_t &a)
          : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq, a)
       {}
 
-      Data(BOOST_RV_REF(Data) d, const allocator_t &a)
+      BOOST_CONTAINER_FORCEINLINE Data(BOOST_RV_REF(Data) d, const allocator_t &a)
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq), a)
       {}
 
@@ -724,68 +736,88 @@ class flat_tree
 
    public:
    // accessors:
-   BOOST_CONTAINER_FORCEINLINE Compare key_comp() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      Compare key_comp() const
    { return this->m_data.get_comp(); }
 
-   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      value_compare value_comp() const
    { return this->m_data; }
 
-   BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      allocator_type get_allocator() const
    { return this->m_data.m_seq.get_allocator(); }
 
-   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_const_return_t get_stored_allocator() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      get_stored_allocator_const_return_t get_stored_allocator() const
    {
       return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_noconst_return_t get_stored_allocator()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      get_stored_allocator_noconst_return_t get_stored_allocator()
    {
       return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE iterator begin()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      iterator begin()
    { return this->m_data.m_seq.begin(); }
 
-   BOOST_CONTAINER_FORCEINLINE const_iterator begin() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_iterator begin() const
    { return this->cbegin(); }
 
-   BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_iterator cbegin() const
    { return this->m_data.m_seq.begin(); }
 
-   BOOST_CONTAINER_FORCEINLINE iterator end()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      iterator end()
    { return this->m_data.m_seq.end(); }
 
-   BOOST_CONTAINER_FORCEINLINE const_iterator end() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_iterator end() const
    { return this->cend(); }
 
-   BOOST_CONTAINER_FORCEINLINE const_iterator cend() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_iterator cend() const
    { return this->m_data.m_seq.end(); }
 
-   BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      reverse_iterator rbegin()
    { return reverse_iterator(this->end()); }
 
-   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rbegin() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_reverse_iterator rbegin() const
    {  return this->crbegin();  }
 
-   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crbegin() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_reverse_iterator crbegin() const
    {  return const_reverse_iterator(this->cend());  }
 
-   BOOST_CONTAINER_FORCEINLINE reverse_iterator rend()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      reverse_iterator rend()
    { return reverse_iterator(this->begin()); }
 
-   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rend() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_reverse_iterator rend() const
    { return this->crend(); }
 
-   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crend() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_reverse_iterator crend() const
    { return const_reverse_iterator(this->cbegin()); }
 
-   BOOST_CONTAINER_FORCEINLINE bool empty() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      bool empty() const
    { return this->m_data.m_seq.empty(); }
 
-   BOOST_CONTAINER_FORCEINLINE size_type size() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      size_type size() const
    { return this->m_data.m_seq.size(); }
 
-   BOOST_CONTAINER_FORCEINLINE size_type max_size() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      size_type max_size() const
    { return this->m_data.m_seq.max_size(); }
 
    BOOST_CONTAINER_FORCEINLINE void swap(flat_tree& other)
@@ -984,10 +1016,7 @@ class flat_tree
          ret.first  = this->nth(data.position - this->cbegin());
       }
       else{
-         typedef typename emplace_functor_type<try_emplace_t, KeyType, Args...>::type func_t;
-         typedef emplace_iterator<value_type, func_t, difference_type> it_t;
-         func_t func(try_emplace_t(), ::boost::forward<KeyType>(key), ::boost::forward<Args>(args)...);
-         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
+         ret.first = this->m_data.m_seq.emplace(data.position, try_emplace_t(), ::boost::forward<KeyType>(key), ::boost::forward<Args>(args)...);
       }
       return ret;
    }
@@ -1053,10 +1082,7 @@ class flat_tree
          ret.first  = this->nth(data.position - this->cbegin());\
       }\
       else{\
-         typedef typename emplace_functor_type<try_emplace_t, KeyType BOOST_MOVE_I##N BOOST_MOVE_TARG##N>::type func_t;\
-         typedef emplace_iterator<value_type, func_t, difference_type> it_t;\
-         func_t func(try_emplace_t(), ::boost::forward<KeyType>(key) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());\
+         ret.first = this->m_data.m_seq.emplace(data.position, try_emplace_t(), ::boost::forward<KeyType>(key) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
       return ret;\
    }\
@@ -1080,10 +1106,7 @@ class flat_tree
          ret.first->second = boost::forward<M>(obj);
       }
       else{
-         typedef typename emplace_functor_type<KeyType, M>::type func_t;
-         typedef emplace_iterator<value_type, func_t, difference_type> it_t;
-         func_t func(boost::forward<KeyType>(key), boost::forward<M>(obj));
-         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
+         ret.first = this->m_data.m_seq.emplace(data.position, boost::forward<KeyType>(key), boost::forward<M>(obj));
       }
       return ret;
    }
@@ -1123,21 +1146,24 @@ class flat_tree
       return flat_tree_nth<iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_nth<container_type, size_type>::value;
       return flat_tree_nth<const_iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_index_of<container_type, iterator>::value;
       return flat_tree_index_of(this->m_data.m_seq, p, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_index_of<container_type, const_iterator>::value;
@@ -1145,7 +1171,8 @@ class flat_tree
    }
 
    // set operations:
-   iterator find(const key_type& k)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD
+      iterator find(const key_type& k)
    {
       iterator i = this->lower_bound(k);
       iterator end_it = this->end();
@@ -1155,6 +1182,7 @@ class flat_tree
       return i;
    }
 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD
    const_iterator find(const key_type& k) const
    {
       const_iterator i = this->lower_bound(k);
@@ -1167,7 +1195,8 @@ class flat_tree
    }
 
    template<class K>
-   typename dtl::enable_if_transparent<key_compare, K, iterator>::type
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD
+      typename dtl::enable_if_transparent<key_compare, K, iterator>::type
       find(const K& k)
    {
       iterator i = this->lower_bound(k);
@@ -1179,7 +1208,8 @@ class flat_tree
    }
 
    template<class K>
-   typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD
+      typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
       find(const K& k) const
    {
       const_iterator i = this->lower_bound(k);
@@ -1191,7 +1221,8 @@ class flat_tree
       return i;
    }
 
-   size_type count(const key_type& k) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD
+      size_type count(const key_type& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
       size_type n = p.second - p.first;
@@ -1199,7 +1230,8 @@ class flat_tree
    }
 
    template<class K>
-   typename dtl::enable_if_transparent<key_compare, K, size_type>::type
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD
+      typename dtl::enable_if_transparent<key_compare, K, size_type>::type
       count(const K& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
@@ -1207,11 +1239,11 @@ class flat_tree
       return n;
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool contains(const key_type& x) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE bool contains(const key_type& x) const
    {  return this->find(x) != this->cend();  }
 
    template<typename K>
-   BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       typename dtl::enable_if_transparent<key_compare, K, bool>::type
          contains(const K& x) const
    {  return this->find(x) != this->cend();  }
@@ -1254,99 +1286,111 @@ class flat_tree
          , dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& k)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      iterator lower_bound(const key_type& k)
    {  return this->priv_lower_bound(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& k) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const_iterator lower_bound(const key_type& k) const
    {  return this->priv_lower_bound(this->cbegin(), this->cend(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE 
       typename dtl::enable_if_transparent<key_compare, K, iterator>::type
          lower_bound(const K& k)
    {  return this->priv_lower_bound(this->begin(), this->end(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE 
       typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
          lower_bound(const K& k) const
    {  return this->priv_lower_bound(this->cbegin(), this->cend(), k);  }
 
-   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& k)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      iterator upper_bound(const key_type& k)
    {  return this->priv_upper_bound(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& k) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE 
+      const_iterator upper_bound(const key_type& k) const
    {  return this->priv_upper_bound(this->cbegin(), this->cend(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       typename dtl::enable_if_transparent<key_compare, K,iterator>::type
    upper_bound(const K& k)
    {  return this->priv_upper_bound(this->begin(), this->end(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       typename dtl::enable_if_transparent<key_compare, K,const_iterator>::type
          upper_bound(const K& k) const
    {  return this->priv_upper_bound(this->cbegin(), this->cend(), k);  }
 
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& k)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      std::pair<iterator,iterator> equal_range(const key_type& k)
    {  return this->priv_equal_range(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
    {  return this->priv_equal_range(this->cbegin(), this->cend(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE
-      typename dtl::enable_if_transparent<key_compare, K,std::pair<iterator,iterator> >::type
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      typename dtl::enable_if_transparent<key_compare, K, std::pair<iterator,iterator> >::type
          equal_range(const K& k)
    {  return this->priv_equal_range(this->begin(), this->end(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       typename dtl::enable_if_transparent<key_compare, K,std::pair<const_iterator,const_iterator> >::type
          equal_range(const K& k) const
    {  return this->priv_equal_range(this->cbegin(), this->cend(), k);  }
 
 
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, iterator> lower_bound_range(const key_type& k)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      std::pair<iterator, iterator> lower_bound_range(const key_type& k)
    {  return this->priv_lower_bound_range(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> lower_bound_range(const key_type& k) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      std::pair<const_iterator, const_iterator> lower_bound_range(const key_type& k) const
    {  return this->priv_lower_bound_range(this->cbegin(), this->cend(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       typename dtl::enable_if_transparent<key_compare, K,std::pair<iterator,iterator> >::type
          lower_bound_range(const K& k)
    {  return this->priv_lower_bound_range(this->begin(), this->end(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       typename dtl::enable_if_transparent<key_compare, K,std::pair<const_iterator,const_iterator> >::type
          lower_bound_range(const K& k) const
    {  return this->priv_lower_bound_range(this->cbegin(), this->cend(), k);  }
 
-   BOOST_CONTAINER_FORCEINLINE size_type capacity() const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      size_type capacity() const
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_capacity<container_type>::value;
       return (flat_tree_capacity)(this->m_data.m_seq, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
+   BOOST_CONTAINER_FORCEINLINE
+      void reserve(size_type cnt)
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_reserve<container_type, size_type>::value;
       (flat_tree_reserve)(this->m_data.m_seq, cnt, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE container_type extract_sequence()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      container_type extract_sequence()
    {
       return boost::move(m_data.m_seq);
    }
 
-   BOOST_CONTAINER_FORCEINLINE container_type &get_sequence_ref()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      container_type &get_sequence_ref()
    {
       return m_data.m_seq;
    }
@@ -1375,29 +1419,36 @@ class flat_tree
       m_data.m_seq = boost::move(seq);
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      friend bool operator==(const flat_tree& x, const flat_tree& y)
    {
       return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      friend bool operator<(const flat_tree& x, const flat_tree& y)
    {
       return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      friend bool operator!=(const flat_tree& x, const flat_tree& y)
       {  return !(x == y); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      friend bool operator>(const flat_tree& x, const flat_tree& y)
       {  return y < x;  }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      friend bool operator<=(const flat_tree& x, const flat_tree& y)
       {  return !(y < x);  }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      friend bool operator>=(const flat_tree& x, const flat_tree& y)
       {  return !(x < y);  }
 
    BOOST_CONTAINER_FORCEINLINE friend void swap(flat_tree& x, flat_tree& y)
+          BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y)))
       {  x.swap(y);  }
 
    private: