passenger 6.0.2 → 6.0.3

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

@@ -125,8 +125,16 @@ struct insert_value_initialized_n_proxy
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {  boost::container::uninitialized_value_init_alloc_n(a, n, p);  }
 
-   void copy_n_and_update(Allocator &, Iterator, size_type) const
-   {  BOOST_ASSERT(false); }
+   void copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   {
+      for (; 0 < n; --n, ++p){
+         typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+         value_type *vp = reinterpret_cast<value_type *>(v.data);
+         alloc_traits::construct(a, vp);
+         value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
+         *p = ::boost::move(*vp);
+      }
+   }
 };
 
 template<class Allocator, class Iterator>
@@ -139,8 +147,18 @@ struct insert_default_initialized_n_proxy
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {  boost::container::uninitialized_default_init_alloc_n(a, n, p);  }
 
-   void copy_n_and_update(Allocator &, Iterator, size_type) const
-   {  BOOST_ASSERT(false); }
+   void copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   {
+      if(!is_pod<value_type>::value){
+         for (; 0 < n; --n, ++p){
+            typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+            value_type *vp = reinterpret_cast<value_type *>(v.data);
+            alloc_traits::construct(a, vp, default_init);
+            value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
+            *p = ::boost::move(*vp);
+         }
+      }
+   }
 };
 
 template<class Allocator, class Iterator>
@@ -271,7 +289,7 @@ struct insert_emplace_proxy
    {
       BOOST_ASSERT(n ==1); (void)n;
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
-      value_type *vp = static_cast<value_type *>(static_cast<void *>(v.data));
+      value_type *vp = reinterpret_cast<value_type *>(v.data);
       alloc_traits::construct(a, vp,
          ::boost::forward<Args>(get<IdxPack>(this->args_))...);
       BOOST_TRY{
@@ -382,7 +400,7 @@ struct insert_emplace_proxy_arg##N\
       BOOST_ASSERT(n == 1); (void)n;\
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
       BOOST_ASSERT((((size_type)(&v)) % alignment_of<value_type>::value) == 0);\
-      value_type *vp = static_cast<value_type *>(static_cast<void *>(v.data));\
+      value_type *vp = reinterpret_cast<value_type *>(v.data);\
       alloc_traits::construct(a, vp BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
       BOOST_TRY{\
          *p = ::boost::move(*vp);\

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

@@ -93,7 +93,8 @@ struct allocator_version_traits<Allocator, 1>
    {
       size_type n = holder.size();
       typename multiallocation_chain::iterator it = holder.begin();
-      while(n--){
+      while(n){
+         --n;
          pointer p = boost::intrusive::pointer_traits<pointer>::pointer_to(*it);
          ++it;
          a.deallocate(p, 1);

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

@@ -19,6 +19,8 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/ebo_functor_holder.hpp>
+
 namespace boost {
 namespace container {
 
@@ -37,7 +39,7 @@ class equal_to_value
    {  return t_ == t;   }
 };
 
-template<class Node, class Pred>
+template<class Node, class Pred, class Ret = bool>
 struct value_to_node_compare
    :  Pred
 {
@@ -52,22 +54,76 @@ struct value_to_node_compare
       :  Pred(pred)
    {}
 
-   bool operator()(const Node &a, const Node &b) const
+   Ret operator()(const Node &a, const Node &b) const
    {  return static_cast<const Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   bool operator()(const Node &a) const
+   Ret operator()(const Node &a) const
    {  return static_cast<const Pred&>(*this)(a.get_data());  }
 
-   bool operator()(const Node &a, const Node &b)
+   Ret operator()(const Node &a, const Node &b)
    {  return static_cast<Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   bool operator()(const Node &a)
+   Ret operator()(const Node &a)
    {  return static_cast<Pred&>(*this)(a.get_data());  }
 
    predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
    const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
 };
 
+template<class KeyPred, class KeyOfValue, class Node, class Ret = bool>
+struct key_node_pred
+   :  public boost::intrusive::detail::ebo_functor_holder<KeyPred>
+{
+   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred(const KeyPred &comp)
+      :  base_t(comp)
+   {}
+
+   typedef boost::intrusive::detail::ebo_functor_holder<KeyPred> base_t;
+   typedef KeyPred                     key_predicate;
+   typedef KeyOfValue                  key_of_value;
+   typedef typename KeyOfValue::type   key_type;
+
+
+   BOOST_CONTAINER_FORCEINLINE static const key_type &key_from(const Node &n)
+   {
+      return key_of_value()(n.get_data());
+   }
+
+   template <class T>
+   BOOST_CONTAINER_FORCEINLINE static const T &
+      key_from(const T &t)
+   {  return t;  }
+
+   BOOST_CONTAINER_FORCEINLINE const key_predicate &key_pred() const
+   {  return static_cast<const key_predicate &>(*this);  }
+
+   BOOST_CONTAINER_FORCEINLINE key_predicate &key_pred()
+   {  return static_cast<key_predicate &>(*this);  }
+
+   BOOST_CONTAINER_FORCEINLINE Ret operator()(const key_type &key) const
+   {  return this->key_pred()(key);  }
+
+   template<class U>
+   BOOST_CONTAINER_FORCEINLINE Ret operator()(const U &nonkey) const
+   {  return this->key_pred()(this->key_from(nonkey));  }
+
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
+   {  return this->key_pred()(key1, key2);  }
+
+   template<class U>
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const U &nonkey2) const
+   {  return this->key_pred()(key1, this->key_from(nonkey2));  }
+
+   template<class U>
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const key_type &key2) const
+   {  return this->key_pred()(this->key_from(nonkey1), key2);  }
+
+   template<class U, class V>
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const V &nonkey2) const
+   {  return this->key_pred()(this->key_from(nonkey1), this->key_from(nonkey2));  }
+};
+
+
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -34,7 +34,21 @@
 // other
 #include <boost/core/no_exceptions_support.hpp>
 // std
-#include <cstring> //for emmove/memcpy
+#include <cstring> //for memmove/memcpy
+
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic push
+//pair memcpy optimizations rightfully detected by GCC
+#  if defined(BOOST_GCC) && (BOOST_GCC >= 80000)
+#     pragma GCC diagnostic ignored "-Wclass-memaccess"
+#  endif
+//GCC 8 seems a bit confused about array access error with static_vector
+//when out of bound exceptions are being thrown.
+#  if defined(BOOST_GCC) && (BOOST_GCC >= 80000) && (BOOST_GCC < 80200)
+#     pragma GCC diagnostic ignored "-Wstringop-overflow"
+#  endif
+#  pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
 
 namespace boost {
 namespace container {
@@ -160,9 +174,13 @@ template
 inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
-   typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
-   if(n){
-      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
+   value_type *const dest_raw = boost::movelib::iterator_to_raw_pointer(r);
+   const value_type *const beg_raw = boost::movelib::iterator_to_raw_pointer(f);
+   const value_type *const end_raw = boost::movelib::iterator_to_raw_pointer(l);
+   if(BOOST_LIKELY(beg_raw != end_raw)){
+      BOOST_ASSERT(beg_raw != 0);
+      const typename boost::container::iterator_traits<I>::difference_type n = end_raw - beg_raw;
+      std::memmove(dest_raw, beg_raw, sizeof(value_type)*n);
       boost::container::iterator_advance(r, n);
    }
    return r;
@@ -175,10 +193,11 @@ template
 F memmove_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
-   if(n){
+   if(BOOST_LIKELY(n)){
       std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(r, n);
    }
+
    return r;
 }
 
@@ -188,7 +207,7 @@ template
     typename F> // F models ForwardIterator
 I memmove_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
-   if(n){
+   if(BOOST_LIKELY(n)){
       typedef typename boost::container::iterator_traits<I>::value_type value_type;
       std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(f, n);
@@ -203,7 +222,7 @@ template
 I memmove_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
-   if(n){
+   if(BOOST_LIKELY(n)){
       std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(f, n);
       boost::container::iterator_advance(r, n);
@@ -720,7 +739,8 @@ typename F>   // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
    copy_n(I f, U n, F r)
 {
-   while (n--) {
+   while (n) {
+      --n;
       *r = *f;
       ++f; ++r;
    }
@@ -1141,4 +1161,9 @@ void move_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_tr
 }  //namespace container {
 }  //namespace boost {
 
+//#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic pop
+#endif
+
 #endif   //#ifndef BOOST_CONTAINER_DETAIL_COPY_MOVE_ALGO_HPP

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

@@ -921,11 +921,11 @@ class flat_tree
    std::pair<iterator, bool> emplace_unique(BOOST_FWD_REF(Args)... args)
    {
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
+      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, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type, value_type> d(a, val);
-      return this->insert_unique(::boost::move(val));
+      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);
+      return this->insert_unique(::boost::move(*pval));
    }
 
    template <class... Args>
@@ -933,22 +933,22 @@ class flat_tree
    {
       //hint checked in insert_unique
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
+      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, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type, value_type> d(a, val);
-      return this->insert_unique(hint, ::boost::move(val));
+      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);
+      return this->insert_unique(hint, ::boost::move(*pval));
    }
 
    template <class... Args>
    iterator emplace_equal(BOOST_FWD_REF(Args)... args)
    {
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
+      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, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type, value_type> d(a, val);
-      return this->insert_equal(::boost::move(val));
+      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);
+      return this->insert_equal(::boost::move(*pval));
    }
 
    template <class... Args>
@@ -956,11 +956,11 @@ class flat_tree
    {
       //hint checked in insert_equal
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
+      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, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type, value_type> d(a, val);
-      return this->insert_equal(hint, ::boost::move(val));
+      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);
+      return this->insert_equal(hint, ::boost::move(*pval));
    }
 
    template <class KeyType, class... Args>
@@ -993,44 +993,44 @@ class flat_tree
    std::pair<iterator, bool> emplace_unique(BOOST_MOVE_UREF##N)\
    {\
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));\
+      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, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type, value_type> d(a, val);\
-      return this->insert_unique(::boost::move(val));\
+      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);\
+      return this->insert_unique(::boost::move(*pval));\
    }\
    \
    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;\
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));\
+      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, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type, value_type> d(a, val);\
-      return this->insert_unique(hint, ::boost::move(val));\
+      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);\
+      return this->insert_unique(hint, ::boost::move(*pval));\
    }\
    \
    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;\
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));\
+      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, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type, value_type> d(a, val);\
-      return this->insert_equal(::boost::move(val));\
+      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);\
+      return this->insert_equal(::boost::move(*pval));\
    }\
    \
    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;\
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));\
+      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, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type, value_type> d(a, val);\
-      return this->insert_equal(hint, ::boost::move(val));\
+      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type, value_type> d(a, *pval);\
+      return this->insert_equal(hint, ::boost::move(*pval));\
    }\
    template <class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
    BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool>\
@@ -1160,7 +1160,31 @@ class flat_tree
       return i;
    }
 
-   // set operations:
+   template<class K>
+   typename dtl::enable_if_transparent<key_compare, K, iterator>::type
+      find(const K& k)
+   {
+      iterator i = this->lower_bound(k);
+      iterator end_it = this->end();
+      if (i != end_it && this->m_data.get_comp()(k, KeyOfValue()(*i))){
+         i = end_it;
+      }
+      return i;
+   }
+
+   template<class K>
+   typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
+      find(const K& k) const
+   {
+      const_iterator i = this->lower_bound(k);
+
+      const_iterator end_it = this->cend();
+      if (i != end_it && this->m_data.get_comp()(k, KeyOfValue()(*i))){
+         i = end_it;
+      }
+      return i;
+   }
+
    size_type count(const key_type& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
@@ -1168,6 +1192,24 @@ class flat_tree
       return n;
    }
 
+   template<class K>
+   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);
+      size_type n = p.second - p.first;
+      return n;
+   }
+
+   BOOST_CONTAINER_FORCEINLINE bool contains(const key_type& x) const
+   {  return this->find(x) != this->cend();  }
+
+   template<typename K>
+   BOOST_CONTAINER_FORCEINLINE
+      typename dtl::enable_if_transparent<key_compare, K, bool>::type
+         contains(const K& x) const
+   {  return this->find(x) != this->cend();  }
+
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge_unique(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
    {
@@ -1212,24 +1254,73 @@ class flat_tree
    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 
+      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 
+      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)
    {  return this->priv_upper_bound(this->begin(), this->end(), k);  }
 
    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
+      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
+      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)
    {  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
    {  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
+         equal_range(const K& k)
+   {  return this->priv_equal_range(this->begin(), this->end(), k);  }
+
+   template<class K>
+   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)
    {  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
    {  return this->priv_lower_bound_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
+         lower_bound_range(const K& k)
+   {  return this->priv_lower_bound_range(this->begin(), this->end(), k);  }
+
+   template<class K>
+   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
    {
       const bool value = boost::container::dtl::
@@ -1419,9 +1510,9 @@ class flat_tree
          , boost::forward<Convertible>(convertible));
    }
 
-   template <class RanIt>
+   template <class RanIt, class K>
    RanIt priv_lower_bound(RanIt first, const RanIt last,
-                          const key_type & key) const
+                          const K & key) const
    {
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;
@@ -1444,9 +1535,9 @@ class flat_tree
       return first;
    }
 
-   template <class RanIt>
+   template <class RanIt, class K>
    RanIt priv_upper_bound
-      (RanIt first, const RanIt last,const key_type & key) const
+      (RanIt first, const RanIt last,const K & key) const
    {
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;
@@ -1469,9 +1560,9 @@ class flat_tree
       return first;
    }
 
-   template <class RanIt>
+   template <class RanIt, class K>
    std::pair<RanIt, RanIt>
-      priv_equal_range(RanIt first, RanIt last, const key_type& key) const
+      priv_equal_range(RanIt first, RanIt last, const K& key) const
    {
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;
@@ -1502,8 +1593,8 @@ class flat_tree
       return std::pair<RanIt, RanIt>(first, first);
    }
 
-   template<class RanIt>
-   std::pair<RanIt, RanIt> priv_lower_bound_range(RanIt first, RanIt last, const key_type& k) const
+   template<class RanIt, class K>
+   std::pair<RanIt, RanIt> priv_lower_bound_range(RanIt first, RanIt last, const K& k) const
    {
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;