passenger 5.1.4 → 5.1.5

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

@@ -32,11 +32,13 @@
 #include <boost/container/detail/destroyers.hpp>
 #include <boost/container/detail/algorithm.hpp> //algo_equal(), algo_lexicographical_compare
 #include <boost/container/detail/iterator.hpp>
+#include <boost/container/detail/is_sorted.hpp>
 #include <boost/container/allocator_traits.hpp>
 #ifdef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
 #include <boost/intrusive/pointer_traits.hpp>
 #endif
 #include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/iterators.hpp>
 #include <boost/move/make_unique.hpp>
 #include <boost/move/adl_move_swap.hpp>
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -44,6 +46,7 @@
 #endif
 
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
+#include <boost/move/iterator.hpp>
 
 namespace boost {
 namespace container {
@@ -98,7 +101,7 @@ struct get_flat_tree_iterators
    typedef boost::container::reverse_iterator<const_iterator>  const_reverse_iterator;
 };
 
-template <class Key, class Value, class KeyOfValue,
+template <class Value, class KeyOfValue,
           class Compare, class Allocator>
 class flat_tree
 {
@@ -183,7 +186,7 @@ class flat_tree
    typedef typename vector_t::const_pointer           const_pointer;
    typedef typename vector_t::reference               reference;
    typedef typename vector_t::const_reference         const_reference;
-   typedef Key                                        key_type;
+   typedef typename KeyOfValue::type                  key_type;
    typedef Compare                                    key_compare;
    typedef typename vector_t::allocator_type          allocator_type;
    typedef typename vector_t::size_type               size_type;
@@ -200,35 +203,36 @@ class flat_tree
    typedef allocator_traits<stored_allocator_type> stored_allocator_traits;
 
    public:
-   flat_tree()
+   BOOST_CONTAINER_FORCEINLINE flat_tree()
       : m_data()
    { }
 
-   explicit flat_tree(const Compare& comp)
+   BOOST_CONTAINER_FORCEINLINE explicit flat_tree(const Compare& comp)
       : m_data(comp)
    { }
 
-   flat_tree(const Compare& comp, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE flat_tree(const Compare& comp, const allocator_type& a)
       : m_data(comp, a)
    { }
 
-   explicit flat_tree(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit flat_tree(const allocator_type& a)
       : m_data(a)
    { }
 
-   flat_tree(const flat_tree& x)
+   BOOST_CONTAINER_FORCEINLINE flat_tree(const flat_tree& x)
       :  m_data(x.m_data)
    { }
 
-   flat_tree(BOOST_RV_REF(flat_tree) x)
+   BOOST_CONTAINER_FORCEINLINE flat_tree(BOOST_RV_REF(flat_tree) x)
+      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       :  m_data(boost::move(x.m_data))
    { }
 
-   flat_tree(const flat_tree& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_tree(const flat_tree& x, const allocator_type &a)
       :  m_data(x.m_data, a)
    { }
 
-   flat_tree(BOOST_RV_REF(flat_tree) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_tree(BOOST_RV_REF(flat_tree) x, const allocator_type &a)
       :  m_data(boost::move(x.m_data), a)
    { }
 
@@ -237,7 +241,20 @@ class flat_tree
             , const Compare& comp     = Compare()
             , const allocator_type& a = allocator_type())
       : m_data(comp, a)
-   { this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last); }
+   {
+      this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last);
+      BOOST_ASSERT((is_sorted)(this->m_data.m_vect.cbegin(), this->m_data.m_vect.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last
+            , const Compare& comp     = Compare()
+            , const allocator_type& a = allocator_type())
+      : m_data(comp, a)
+   {
+      this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last);
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_vect.cbegin(), this->m_data.m_vect.cend(), this->priv_value_comp()));
+   }
 
    template <class InputIterator>
    flat_tree( bool unique_insertion
@@ -262,80 +279,93 @@ class flat_tree
       }
    }
 
-   ~flat_tree()
+   BOOST_CONTAINER_FORCEINLINE ~flat_tree()
    {}
 
-   flat_tree&  operator=(BOOST_COPY_ASSIGN_REF(flat_tree) x)
+   BOOST_CONTAINER_FORCEINLINE flat_tree&  operator=(BOOST_COPY_ASSIGN_REF(flat_tree) x)
    {  m_data = x.m_data;   return *this;  }
 
-   flat_tree&  operator=(BOOST_RV_REF(flat_tree) x)
-      BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_move_assignable<Compare>::value )
+   BOOST_CONTAINER_FORCEINLINE flat_tree&  operator=(BOOST_RV_REF(flat_tree) x)
+      BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
+                          allocator_traits_type::is_always_equal::value) &&
+                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
    {  m_data = boost::move(x.m_data); return *this;  }
 
+   BOOST_CONTAINER_FORCEINLINE const value_compare &priv_value_comp() const
+   { return static_cast<const value_compare &>(this->m_data); }
+
+   BOOST_CONTAINER_FORCEINLINE value_compare &priv_value_comp()
+   { return static_cast<value_compare &>(this->m_data); }
+
+   BOOST_CONTAINER_FORCEINLINE const key_compare &priv_key_comp() const
+   { return this->priv_value_comp().get_comp(); }
+
+   BOOST_CONTAINER_FORCEINLINE key_compare &priv_key_comp()
+   { return this->priv_value_comp().get_comp(); }
+
    public:
    // accessors:
-   Compare key_comp() const
+   BOOST_CONTAINER_FORCEINLINE Compare key_comp() const
    { return this->m_data.get_comp(); }
 
-   value_compare value_comp() const
+   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
    { return this->m_data; }
 
-   allocator_type get_allocator() const
+   BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const
    { return this->m_data.m_vect.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const
+   BOOST_CONTAINER_FORCEINLINE const stored_allocator_type &get_stored_allocator() const
    {  return this->m_data.m_vect.get_stored_allocator(); }
 
-   stored_allocator_type &get_stored_allocator()
+   BOOST_CONTAINER_FORCEINLINE stored_allocator_type &get_stored_allocator()
    {  return this->m_data.m_vect.get_stored_allocator(); }
 
-   iterator begin()
+   BOOST_CONTAINER_FORCEINLINE iterator begin()
    { return this->m_data.m_vect.begin(); }
 
-   const_iterator begin() const
+   BOOST_CONTAINER_FORCEINLINE const_iterator begin() const
    { return this->cbegin(); }
 
-   const_iterator cbegin() const
+   BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const
    { return this->m_data.m_vect.begin(); }
 
-   iterator end()
+   BOOST_CONTAINER_FORCEINLINE iterator end()
    { return this->m_data.m_vect.end(); }
 
-   const_iterator end() const
+   BOOST_CONTAINER_FORCEINLINE const_iterator end() const
    { return this->cend(); }
 
-   const_iterator cend() const
+   BOOST_CONTAINER_FORCEINLINE const_iterator cend() const
    { return this->m_data.m_vect.end(); }
 
-   reverse_iterator rbegin()
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin()
    { return reverse_iterator(this->end()); }
 
-   const_reverse_iterator rbegin() const
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rbegin() const
    {  return this->crbegin();  }
 
-   const_reverse_iterator crbegin() const
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crbegin() const
    {  return const_reverse_iterator(this->cend());  }
 
-   reverse_iterator rend()
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rend()
    { return reverse_iterator(this->begin()); }
 
-   const_reverse_iterator rend() const
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rend() const
    { return this->crend(); }
 
-   const_reverse_iterator crend() const
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crend() const
    { return const_reverse_iterator(this->cbegin()); }
 
-   bool empty() const
+   BOOST_CONTAINER_FORCEINLINE bool empty() const
    { return this->m_data.m_vect.empty(); }
 
-   size_type size() const
+   BOOST_CONTAINER_FORCEINLINE size_type size() const
    { return this->m_data.m_vect.size(); }
 
-   size_type max_size() const
+   BOOST_CONTAINER_FORCEINLINE size_type max_size() const
    { return this->m_data.m_vect.max_size(); }
 
-   void swap(flat_tree& other)
+   BOOST_CONTAINER_FORCEINLINE void swap(flat_tree& other)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
    {  this->m_data.swap(other.m_data);  }
@@ -346,7 +376,7 @@ class flat_tree
    {
       std::pair<iterator,bool> ret;
       insert_commit_data data;
-      ret.second = this->priv_insert_unique_prepare(val, data);
+      ret.second = this->priv_insert_unique_prepare(KeyOfValue()(val), data);
       ret.first = ret.second ? this->priv_insert_commit(data, val)
                              : iterator(vector_iterator_get_ptr(data.position));
       return ret;
@@ -356,7 +386,7 @@ class flat_tree
    {
       std::pair<iterator,bool> ret;
       insert_commit_data data;
-      ret.second = this->priv_insert_unique_prepare(val, data);
+      ret.second = this->priv_insert_unique_prepare(KeyOfValue()(val), data);
       ret.first = ret.second ? this->priv_insert_commit(data, boost::move(val))
                              : iterator(vector_iterator_get_ptr(data.position));
       return ret;
@@ -379,9 +409,8 @@ class flat_tree
    iterator insert_unique(const_iterator hint, const value_type& val)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(hint));
-      std::pair<iterator,bool> ret;
       insert_commit_data data;
-      return this->priv_insert_unique_prepare(hint, val, data)
+      return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
             ? this->priv_insert_commit(data, val)
             : iterator(vector_iterator_get_ptr(data.position));
    }
@@ -389,9 +418,8 @@ class flat_tree
    iterator insert_unique(const_iterator hint, BOOST_RV_REF(value_type) val)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(hint));
-      std::pair<iterator,bool> ret;
       insert_commit_data data;
-      return this->priv_insert_unique_prepare(hint, val, data)
+      return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
          ? this->priv_insert_commit(data, boost::move(val))
          : iterator(vector_iterator_get_ptr(data.position));
    }
@@ -481,7 +509,7 @@ class flat_tree
          >::type * = 0
       #endif
       )
-   {   this->m_data.m_vect.merge(first, last);   }
+   {   this->m_data.m_vect.merge(first, last, static_cast<const value_compare &>(this->m_data));   }
 
    template <class InIt>
    void insert_unique(ordered_unique_range_t, InIt first, InIt last
@@ -510,7 +538,7 @@ class flat_tree
          >::type * = 0
       #endif
       )
-   {   this->m_data.m_vect.merge_unique(first, last, value_compare());   }
+   {   this->m_data.m_vect.merge_unique(first, last, static_cast<const value_compare &>(this->m_data));   }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -560,6 +588,29 @@ class flat_tree
       return this->insert_equal(hint, ::boost::move(val));
    }
 
+   template <class KeyType, class... Args>
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> try_emplace
+      (const_iterator hint, BOOST_FWD_REF(KeyType) key, BOOST_FWD_REF(Args)... args)
+   {
+      std::pair<iterator,bool> ret;
+      insert_commit_data data;
+      const key_type & k = key;
+      ret.second = hint == const_iterator()
+         ? this->priv_insert_unique_prepare(k, data)
+         : this->priv_insert_unique_prepare(hint, k, data);
+
+      if(!ret.second){
+         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_vect.insert(data.position, it_t(func), it_t());
+      }
+      return ret;
+   }
+
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_FLAT_TREE_EMPLACE_CODE(N) \
@@ -606,13 +657,57 @@ class flat_tree
       value_destructor<stored_allocator_type> d(a, val);\
       return this->insert_equal(hint, ::boost::move(val));\
    }\
+   template <class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool>\
+      try_emplace(const_iterator hint, BOOST_FWD_REF(KeyType) key BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   {\
+      std::pair<iterator,bool> ret;\
+      insert_commit_data data;\
+      const key_type & k = key;\
+      ret.second = hint == const_iterator()\
+         ? this->priv_insert_unique_prepare(k, data)\
+         : this->priv_insert_unique_prepare(hint, k, data);\
+      \
+      if(!ret.second){\
+         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_vect.insert(data.position, it_t(func), it_t());\
+      }\
+      return ret;\
+   }\
    //
-   BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_FLAT_TREE_EMPLACE_CODE)
+   BOOST_MOVE_ITERATE_0TO7(BOOST_CONTAINER_FLAT_TREE_EMPLACE_CODE)
    #undef BOOST_CONTAINER_FLAT_TREE_EMPLACE_CODE
 
    #endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-   iterator erase(const_iterator position)
+   template<class KeyType, class M>
+   std::pair<iterator, bool> insert_or_assign(const_iterator hint, BOOST_FWD_REF(KeyType) key, BOOST_FWD_REF(M) obj)
+   {
+      const key_type& k = key;
+      std::pair<iterator,bool> ret;
+      insert_commit_data data;
+      ret.second = hint == const_iterator()
+         ? this->priv_insert_unique_prepare(k, data)
+         : this->priv_insert_unique_prepare(hint, k, data);
+      if(!ret.second){
+         ret.first  = this->nth(data.position - this->cbegin());
+         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_vect.insert(data.position, it_t(func), it_t());
+      }
+      return ret;
+   }
+
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator position)
    {  return this->m_data.m_vect.erase(position);  }
 
    size_type erase(const key_type& k)
@@ -625,10 +720,10 @@ class flat_tree
       return ret;
    }
 
-   iterator erase(const_iterator first, const_iterator last)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {  return this->m_data.m_vect.erase(first, last);  }
 
-   void clear()
+   BOOST_CONTAINER_FORCEINLINE void clear()
    {  this->m_data.m_vect.clear();  }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -637,19 +732,19 @@ class flat_tree
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
-   void shrink_to_fit()
+   BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
    {  this->m_data.m_vect.shrink_to_fit();  }
 
-   iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_data.m_vect.nth(n);   }
 
-   const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_data.m_vect.nth(n);   }
 
-   size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_data.m_vect.index_of(p);   }
 
-   size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_data.m_vect.index_of(p);   }
 
    // set operations:
@@ -682,64 +777,94 @@ class flat_tree
       return n;
    }
 
-   iterator lower_bound(const key_type& k)
+   template<class C2>
+   void merge_unique(flat_tree<Value, KeyOfValue, C2, Allocator>& source)
+   {
+      this->insert( boost::make_move_iterator(source.begin())
+                  , boost::make_move_iterator(source.end()));
+   }
+
+   template<class C2>
+   void merge_equal(flat_tree<Value, KeyOfValue, C2, Allocator>& source)
+   {
+      this->insert( boost::make_move_iterator(source.begin())
+                  , boost::make_move_iterator(source.end()));
+   }
+
+   void merge_unique(flat_tree& source)
+   {
+      this->m_data.m_vect.merge_unique
+         ( boost::make_move_iterator(source.begin())
+         , boost::make_move_iterator(source.end())
+         , static_cast<const value_compare &>(this->m_data));
+   }
+
+   void merge_equal(flat_tree& source)
+   {
+      this->m_data.m_vect.merge
+         ( boost::make_move_iterator(source.begin())
+         , boost::make_move_iterator(source.end())
+         , static_cast<const value_compare &>(this->m_data));
+   }
+
+   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& k)
    {  return this->priv_lower_bound(this->begin(), this->end(), k);  }
 
-   const_iterator lower_bound(const key_type& k) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& k) const
    {  return this->priv_lower_bound(this->cbegin(), this->cend(), k);  }
 
-   iterator upper_bound(const key_type& k)
+   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& k)
    {  return this->priv_upper_bound(this->begin(), this->end(), k);  }
 
-   const_iterator upper_bound(const key_type& k) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& k) const
    {  return this->priv_upper_bound(this->cbegin(), this->cend(), k);  }
 
-   std::pair<iterator,iterator> equal_range(const key_type& k)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& k)
    {  return this->priv_equal_range(this->begin(), this->end(), k);  }
 
-   std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
+   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);  }
 
-   std::pair<iterator, iterator> lower_bound_range(const key_type& k)
+   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);  }
 
-   std::pair<const_iterator, const_iterator> lower_bound_range(const key_type& k) const
+   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);  }
 
-   size_type capacity() const
+   BOOST_CONTAINER_FORCEINLINE size_type capacity() const
    { return this->m_data.m_vect.capacity(); }
 
-   void reserve(size_type cnt)
+   BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
    { this->m_data.m_vect.reserve(cnt);   }
 
-   friend bool operator==(const flat_tree& x, const flat_tree& y)
+   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());
    }
 
-   friend bool operator<(const flat_tree& x, const flat_tree& y)
+   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());
    }
 
-   friend bool operator!=(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_tree& x, const flat_tree& y)
       {  return !(x == y); }
 
-   friend bool operator>(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_tree& x, const flat_tree& y)
       {  return y < x;  }
 
-   friend bool operator<=(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_tree& x, const flat_tree& y)
       {  return !(y < x);  }
 
-   friend bool operator>=(const flat_tree& x, const flat_tree& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_tree& x, const flat_tree& y)
       {  return !(x < y);  }
 
-   friend void swap(flat_tree& x, flat_tree& y)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_tree& x, flat_tree& y)
       {  x.swap(y);  }
 
    private:
 
-   bool priv_in_range_or_end(const_iterator pos) const
+   BOOST_CONTAINER_FORCEINLINE bool priv_in_range_or_end(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos <= this->end());
    }
@@ -780,34 +905,34 @@ class flat_tree
    }
 
    bool priv_insert_unique_prepare
-      (const_iterator b, const_iterator e, const value_type& val, insert_commit_data &commit_data)
+      (const_iterator b, const_iterator e, const key_type& k, insert_commit_data &commit_data)
    {
-      const value_compare &val_cmp  = this->m_data;
-      commit_data.position = this->priv_lower_bound(b, e, KeyOfValue()(val));
-      return commit_data.position == e || val_cmp(val, *commit_data.position);
+      const key_compare &key_cmp  = this->priv_key_comp();
+      commit_data.position = this->priv_lower_bound(b, e, k);
+      return commit_data.position == e || key_cmp(k, KeyOfValue()(*commit_data.position));
    }
 
-   bool priv_insert_unique_prepare
-      (const value_type& val, insert_commit_data &commit_data)
-   {  return this->priv_insert_unique_prepare(this->cbegin(), this->cend(), val, commit_data);   }
+   BOOST_CONTAINER_FORCEINLINE bool priv_insert_unique_prepare
+      (const key_type& k, insert_commit_data &commit_data)
+   {  return this->priv_insert_unique_prepare(this->cbegin(), this->cend(), k, commit_data);   }
 
    bool priv_insert_unique_prepare
-      (const_iterator pos, const value_type& val, insert_commit_data &commit_data)
+      (const_iterator pos, const key_type& k, insert_commit_data &commit_data)
    {
       //N1780. Props to Howard Hinnant!
-      //To insert val at pos:
-      //if pos == end || val <= *pos
-      //   if pos == begin || val >= *(pos-1)
-      //      insert val before pos
+      //To insert k at pos:
+      //if pos == end || k <= *pos
+      //   if pos == begin || k >= *(pos-1)
+      //      insert k before pos
       //   else
-      //      insert val before upper_bound(val)
-      //else if pos+1 == end || val <= *(pos+1)
-      //   insert val after pos
+      //      insert k before upper_bound(k)
+      //else if pos+1 == end || k <= *(pos+1)
+      //   insert k after pos
       //else
-      //   insert val before lower_bound(val)
-      const value_compare &val_cmp = this->m_data;
+      //   insert k before lower_bound(k)
+      const key_compare &key_cmp = this->priv_key_comp();
       const const_iterator cend_it = this->cend();
-      if(pos == cend_it || val_cmp(val, *pos)){ //Check if val should go before end
+      if(pos == cend_it || key_cmp(k, KeyOfValue()(*pos))){ //Check if k should go before end
          const const_iterator cbeg = this->cbegin();
          commit_data.position = pos;
          if(pos == cbeg){  //If container is empty then insert it in the beginning
@@ -815,27 +940,27 @@ class flat_tree
          }
          const_iterator prev(pos);
          --prev;
-         if(val_cmp(*prev, val)){   //If previous element was less, then it should go between prev and pos
+         if(key_cmp(KeyOfValue()(*prev), k)){   //If previous element was less, then it should go between prev and pos
             return true;
          }
-         else if(!val_cmp(val, *prev)){   //If previous was equal then insertion should fail
+         else if(!key_cmp(k, KeyOfValue()(*prev))){   //If previous was equal then insertion should fail
             commit_data.position = prev;
             return false;
          }
          else{ //Previous was bigger so insertion hint was pointless, dispatch to hintless insertion
-               //but reduce the search between beg and prev as prev is bigger than val
-            return this->priv_insert_unique_prepare(cbeg, prev, val, commit_data);
+               //but reduce the search between beg and prev as prev is bigger than k
+            return this->priv_insert_unique_prepare(cbeg, prev, k, commit_data);
          }
       }
       else{
          //The hint is before the insertion position, so insert it
          //in the remaining range [pos, end)
-         return this->priv_insert_unique_prepare(pos, cend_it, val, commit_data);
+         return this->priv_insert_unique_prepare(pos, cend_it, k, commit_data);
       }
    }
 
    template<class Convertible>
-   iterator priv_insert_commit
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert_commit
       (insert_commit_data &commit_data, BOOST_FWD_REF(Convertible) convertible)
    {
       return this->m_data.m_vect.insert
@@ -966,9 +1091,9 @@ class flat_tree
 
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class Key, class T, class KeyOfValue,
+template <class T, class KeyOfValue,
 class Compare, class Allocator>
-struct has_trivial_destructor_after_move<boost::container::container_detail::flat_tree<Key, T, KeyOfValue, Compare, Allocator> >
+struct has_trivial_destructor_after_move<boost::container::container_detail::flat_tree<T, KeyOfValue, Compare, Allocator> >
 {
    typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
    static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&