passenger 5.0.24 → 5.0.25

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

@@ -0,0 +1,103 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_ALLOC_LIB_HPP
+#define BOOST_CONTAINER_DETAIL_ALLOC_LIB_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/detail/auto_link.hpp>
+
+#include <boost/container/detail/alloc_lib.h>
+
+namespace boost{
+namespace container{
+
+typedef boost_cont_command_ret_t dlmalloc_command_ret_t;
+typedef boost_cont_memchain dlmalloc_memchain;
+typedef boost_cont_memchain_it dlmalloc_memchain_it;
+typedef boost_cont_malloc_stats_t dlmalloc_malloc_stats_t;
+
+BOOST_CONTAINER_DECL size_t dlmalloc_size(const void *p);
+
+BOOST_CONTAINER_DECL void* dlmalloc_malloc(size_t bytes);
+
+BOOST_CONTAINER_DECL void  dlmalloc_free(void* mem);
+
+BOOST_CONTAINER_DECL void* dlmalloc_memalign(size_t bytes, size_t alignment);
+
+BOOST_CONTAINER_DECL int dlmalloc_multialloc_nodes
+   (size_t n_elements, size_t elem_size, size_t contiguous_elements, boost_cont_memchain *pchain);
+
+BOOST_CONTAINER_DECL int dlmalloc_multialloc_arrays
+   (size_t n_elements, const size_t *sizes, size_t sizeof_element, size_t contiguous_elements, boost_cont_memchain *pchain);
+
+BOOST_CONTAINER_DECL void dlmalloc_multidealloc(boost_cont_memchain *pchain);
+
+BOOST_CONTAINER_DECL size_t dlmalloc_footprint();
+
+BOOST_CONTAINER_DECL size_t dlmalloc_allocated_memory();
+
+BOOST_CONTAINER_DECL size_t dlmalloc_chunksize(const void *p);
+
+BOOST_CONTAINER_DECL int dlmalloc_all_deallocated();
+
+BOOST_CONTAINER_DECL boost_cont_malloc_stats_t dlmalloc_malloc_stats();
+
+BOOST_CONTAINER_DECL size_t dlmalloc_in_use_memory();
+
+BOOST_CONTAINER_DECL int dlmalloc_trim(size_t pad);
+
+BOOST_CONTAINER_DECL int dlmalloc_mallopt(int parameter_number, int parameter_value);
+
+BOOST_CONTAINER_DECL int dlmalloc_grow(void* oldmem, size_t minbytes, size_t maxbytes, size_t *received);
+
+BOOST_CONTAINER_DECL int dlmalloc_shrink(void* oldmem, size_t minbytes, size_t maxbytes, size_t *received, int do_commit);
+
+BOOST_CONTAINER_DECL void* dlmalloc_alloc(size_t minbytes, size_t preferred_bytes, size_t *received_bytes);
+
+BOOST_CONTAINER_DECL int dlmalloc_malloc_check();
+
+BOOST_CONTAINER_DECL boost_cont_command_ret_t dlmalloc_allocation_command
+   ( allocation_type command
+   , size_t sizeof_object
+   , size_t limit_objects
+   , size_t preferred_objects
+   , size_t *received_objects
+   , void *reuse_ptr
+   );
+
+BOOST_CONTAINER_DECL int dlmalloc_mallopt(int param_number, int value);
+
+BOOST_CONTAINER_DECL void *dlmalloc_sync_create();
+
+BOOST_CONTAINER_DECL void dlmalloc_sync_destroy(void *sync);
+
+BOOST_CONTAINER_DECL bool dlmalloc_sync_lock(void *sync);
+
+BOOST_CONTAINER_DECL void dlmalloc_sync_unlock(void *sync);
+
+BOOST_CONTAINER_DECL bool dlmalloc_global_sync_lock();
+
+BOOST_CONTAINER_DECL void dlmalloc_global_sync_unlock();
+
+}  //namespace container{
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_DETAIL_ALLOC_LIB_HPP

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

@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2015. Distributed under the Boost
 // Software License, Version 1.0. (See accompanying file
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
@@ -11,37 +11,42 @@
 #ifndef BOOST_CONTAINER_FLAT_TREE_HPP
 #define BOOST_CONTAINER_FLAT_TREE_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif
 
-#include "config_begin.hpp"
+#include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 
 #include <boost/container/container_fwd.hpp>
 
-#include <algorithm>
-#include <functional>
-#include <utility>
-
-#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/move/utility.hpp>
+#include <boost/move/utility_core.hpp>
 
-#include <boost/container/detail/utilities.hpp>
 #include <boost/container/detail/pair.hpp>
 #include <boost/container/vector.hpp>
 #include <boost/container/detail/value_init.hpp>
 #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/allocator_traits.hpp>
 #ifdef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
 #include <boost/intrusive/pointer_traits.hpp>
 #endif
-#include <boost/aligned_storage.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <boost/move/make_unique.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/move/detail/fwd_macros.hpp>
+#endif
 
-namespace boost {
+#include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 
+namespace boost {
 namespace container {
-
 namespace container_detail {
 
 template<class Compare, class Value, class KeyOfValue>
@@ -51,7 +56,7 @@ class flat_tree_value_compare
    typedef Value              first_argument_type;
    typedef Value              second_argument_type;
    typedef bool               return_type;
-   public:    
+   public:
    flat_tree_value_compare()
       : Compare()
    {}
@@ -68,7 +73,7 @@ class flat_tree_value_compare
 
    const Compare &get_comp() const
       {  return *this;  }
-  
+
    Compare &get_comp()
       {  return *this;  }
 };
@@ -77,28 +82,29 @@ template<class Pointer>
 struct get_flat_tree_iterators
 {
    #ifdef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-   typedef Pointer                                    iterator;
+   typedef Pointer                                             iterator;
    typedef typename boost::intrusive::
-      pointer_traits<Pointer>::element_type           iterator_element_type;
+      pointer_traits<Pointer>::element_type                    iterator_element_type;
    typedef typename boost::intrusive::
       pointer_traits<Pointer>:: template
-         rebind_pointer<const iterator_element_type>::type  const_iterator;
+         rebind_pointer<const iterator_element_type>::type     const_iterator;
    #else //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-   typedef typename container_detail::
-      vector_iterator<Pointer>                        iterator;
-   typedef typename container_detail::
-      vector_const_iterator<Pointer>                  const_iterator;
+   typedef typename boost::container::container_detail::
+      vec_iterator<Pointer, false>                             iterator;
+   typedef typename boost::container::container_detail::
+      vec_iterator<Pointer, true >                             const_iterator;
    #endif   //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-   typedef std::reverse_iterator<iterator>            reverse_iterator;
-   typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
+   typedef boost::container::reverse_iterator<iterator>        reverse_iterator;
+   typedef boost::container::reverse_iterator<const_iterator>  const_reverse_iterator;
 };
 
 template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
+          class Compare, class Allocator>
 class flat_tree
 {
-   typedef boost::container::vector<Value, A>  vector_t;
-   typedef A                                   allocator_t;
+   typedef boost::container::vector<Value, Allocator>    vector_t;
+   typedef Allocator                                     allocator_t;
+   typedef allocator_traits<Allocator>                   allocator_traits_type;
 
    public:
    typedef flat_tree_value_compare<Compare, Value, KeyOfValue> value_compare;
@@ -115,7 +121,7 @@ class flat_tree
          : value_compare(), m_vect()
       {}
 
-      Data(const Data &d)
+      explicit Data(const Data &d)
          : value_compare(static_cast<const value_compare&>(d)), m_vect(d.m_vect)
       {}
 
@@ -123,23 +129,26 @@ class flat_tree
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect))
       {}
 
-      Data(const Data &d, const A &a)
+      Data(const Data &d, const Allocator &a)
          : value_compare(static_cast<const value_compare&>(d)), m_vect(d.m_vect, a)
       {}
 
-      Data(BOOST_RV_REF(Data) d, const A &a)
+      Data(BOOST_RV_REF(Data) d, const Allocator &a)
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect), a)
       {}
 
-      Data(const Compare &comp)
+      explicit Data(const Compare &comp)
          : value_compare(comp), m_vect()
       {}
 
-      Data(const Compare &comp,
-           const allocator_t &alloc)
+      Data(const Compare &comp, const allocator_t &alloc)
          : value_compare(comp), m_vect(alloc)
       {}
 
+      explicit Data(const allocator_t &alloc)
+         : value_compare(), m_vect(alloc)
+      {}
+
       Data& operator=(BOOST_COPY_ASSIGN_REF(Data) d)
       {
          this->value_compare::operator=(d);
@@ -157,7 +166,7 @@ class flat_tree
       void swap(Data &d)
       {
          value_compare& mycomp    = *this, & othercomp = d;
-         boost::container::swap_dispatch(mycomp, othercomp);
+         boost::adl_move_swap(mycomp, othercomp);
          this->m_vect.swap(d.m_vect);
       }
 
@@ -203,6 +212,10 @@ class flat_tree
       : m_data(comp, a)
    { }
 
+   explicit flat_tree(const allocator_type& a)
+      : m_data(a)
+   { }
+
    flat_tree(const flat_tree& x)
       :  m_data(x.m_data)
    { }
@@ -233,28 +246,41 @@ class flat_tree
             , const allocator_type& a = allocator_type())
       : m_data(comp, a)
    {
+      //Use cend() as hint to achieve linear time for
+      //ordered ranges as required by the standard
+      //for the constructor
+      //Call end() every iteration as reallocation might have invalidated iterators
       if(unique_insertion){
-         this->insert_unique(first, last);
+         for ( ; first != last; ++first){
+            this->insert_unique(this->cend(), *first);
+         }
       }
       else{
-         this->insert_equal(first, last);
+         for ( ; first != last; ++first){
+            this->insert_equal(this->cend(), *first);
+         }
       }
    }
 
    ~flat_tree()
-   { }
+   {}
 
    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) mx)
-   {  m_data = boost::move(mx.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 )
+   {  m_data = boost::move(x.m_data); return *this;  }
 
-   public:   
+   public:
    // accessors:
    Compare key_comp() const
    { return this->m_data.get_comp(); }
 
+   value_compare value_comp() const
+   { return this->m_data; }
+
    allocator_type get_allocator() const
    { return this->m_data.m_vect.get_allocator(); }
 
@@ -310,27 +336,29 @@ class flat_tree
    { return this->m_data.m_vect.max_size(); }
 
    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);  }
 
    public:
    // insert/erase
    std::pair<iterator,bool> insert_unique(const value_type& val)
    {
+      std::pair<iterator,bool> ret;
       insert_commit_data data;
-      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(val, data);
-      if(ret.second){
-         ret.first = this->priv_insert_commit(data, val);
-      }
+      ret.second = this->priv_insert_unique_prepare(val, data);
+      ret.first = ret.second ? this->priv_insert_commit(data, val)
+                             : iterator(vector_iterator_get_ptr(data.position));
       return ret;
    }
 
    std::pair<iterator,bool> insert_unique(BOOST_RV_REF(value_type) val)
    {
+      std::pair<iterator,bool> ret;
       insert_commit_data data;
-      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(val, data);
-      if(ret.second){
-         ret.first = this->priv_insert_commit(data, boost::move(val));
-      }
+      ret.second = this->priv_insert_unique_prepare(val, data);
+      ret.first = ret.second ? this->priv_insert_commit(data, boost::move(val))
+                             : iterator(vector_iterator_get_ptr(data.position));
       return ret;
    }
 
@@ -348,43 +376,49 @@ class flat_tree
       return i;
    }
 
-   iterator insert_unique(const_iterator pos, const value_type& val)
+   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;
-      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(pos, val, data);
-      if(ret.second){
-         ret.first = this->priv_insert_commit(data, val);
-      }
-      return ret.first;
+      return this->priv_insert_unique_prepare(hint, val, data)
+            ? this->priv_insert_commit(data, val)
+            : iterator(vector_iterator_get_ptr(data.position));
    }
 
-   iterator insert_unique(const_iterator pos, BOOST_RV_REF(value_type) mval)
+   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;
-      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(pos, mval, data);
-      if(ret.second){
-         ret.first = this->priv_insert_commit(data, boost::move(mval));
-      }
-      return ret.first;
+      return this->priv_insert_unique_prepare(hint, val, data)
+         ? this->priv_insert_commit(data, boost::move(val))
+         : iterator(vector_iterator_get_ptr(data.position));
    }
 
-   iterator insert_equal(const_iterator pos, const value_type& val)
+   iterator insert_equal(const_iterator hint, const value_type& val)
    {
+      BOOST_ASSERT(this->priv_in_range_or_end(hint));
       insert_commit_data data;
-      this->priv_insert_equal_prepare(pos, val, data);
+      this->priv_insert_equal_prepare(hint, val, data);
       return this->priv_insert_commit(data, val);
    }
 
-   iterator insert_equal(const_iterator pos, BOOST_RV_REF(value_type) mval)
+   iterator insert_equal(const_iterator hint, BOOST_RV_REF(value_type) mval)
    {
+      BOOST_ASSERT(this->priv_in_range_or_end(hint));
       insert_commit_data data;
-      this->priv_insert_equal_prepare(pos, mval, data);
+      this->priv_insert_equal_prepare(hint, mval, data);
       return this->priv_insert_commit(data, boost::move(mval));
    }
 
    template <class InIt>
    void insert_unique(InIt first, InIt last)
-   {  this->priv_insert_unique_loop(first, last); }
+   {
+      for ( ; first != last; ++first){
+         this->insert_unique(*first);
+      }
+   }
 
    template <class InIt>
    void insert_equal(InIt first, InIt last
@@ -405,7 +439,7 @@ class flat_tree
       #endif
       )
    {
-      const size_type len = static_cast<size_type>(std::distance(first, last));
+      const size_type len = static_cast<size_type>(boost::container::iterator_distance(first, last));
       this->reserve(this->size()+len);
       this->priv_insert_equal_loop(first, last);
    }
@@ -427,12 +461,12 @@ class flat_tree
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename container_detail::enable_if_c
          < !container_detail::is_input_iterator<FwdIt>::value &&
-		   container_detail::is_forward_iterator<FwdIt>::value
+         container_detail::is_forward_iterator<FwdIt>::value
          >::type * = 0
       #endif
       )
    {
-      const size_type len = static_cast<size_type>(std::distance(first, last));
+      const size_type len = static_cast<size_type>(boost::container::iterator_distance(first, last));
       this->reserve(this->size()+len);
       this->priv_insert_equal_loop_ordered(first, last);
    }
@@ -440,49 +474,32 @@ class flat_tree
    template <class BidirIt>
    void insert_equal(ordered_range_t, BidirIt first, BidirIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_input_iterator<BidirIt>::value &&
-           !container_detail::is_forward_iterator<BidirIt>::value
+      , typename container_detail::disable_if_or
+         < void
+         , container_detail::is_input_iterator<BidirIt>
+         , container_detail::is_forward_iterator<BidirIt>
          >::type * = 0
       #endif
       )
-   {
-      size_type len = static_cast<size_type>(std::distance(first, last));
-      const size_type BurstSize = 16;
-      size_type positions[BurstSize];
-
-      //Prereserve all memory so that iterators are not invalidated
-      this->reserve(this->size()+len);
-      const const_iterator b(this->cbegin());
-      const_iterator pos(b);
-      //Loop in burst sizes
-      while(len){
-         const size_type burst = len < BurstSize ? len : BurstSize;
-         const const_iterator ce(this->cend());
-         len -= burst;
-         for(size_type i = 0; i != burst; ++i){
-            //Get the insertion position for each key
-            pos = const_cast<const flat_tree&>(*this).priv_upper_bound(pos, ce, KeyOfValue()(*first));
-            positions[i] = static_cast<size_type>(pos - b);
-            ++first;
-         }
-         //Insert all in a single step in the precalculated positions
-         this->m_data.m_vect.insert_ordered_at(burst, positions + burst, first);
-         //Next search position updated
-         pos += burst;
-      }
-   }
+   {   this->m_data.m_vect.merge(first, last);   }
 
    template <class InIt>
    void insert_unique(ordered_unique_range_t, InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < container_detail::is_input_iterator<InIt>::value ||
-           container_detail::is_forward_iterator<InIt>::value
+      , typename container_detail::enable_if_or
+         < void
+         , container_detail::is_input_iterator<InIt>
+         , container_detail::is_forward_iterator<InIt>
          >::type * = 0
       #endif
       )
-   {  this->priv_insert_unique_loop_hint(first, last);  }
+   {
+      const_iterator pos(this->cend());
+      for ( ; first != last; ++first){
+         pos = this->insert_unique(pos, *first);
+         ++pos;
+      }
+   }
 
    template <class BidirIt>
    void insert_unique(ordered_unique_range_t, BidirIt first, BidirIt last
@@ -493,185 +510,107 @@ class flat_tree
          >::type * = 0
       #endif
       )
-   {
-      size_type len = static_cast<size_type>(std::distance(first, last));
-      const size_type BurstSize = 16;
-      size_type positions[BurstSize];
-      size_type skips[BurstSize];
-
-      //Prereserve all memory so that iterators are not invalidated
-      this->reserve(this->size()+len);
-      const const_iterator b(this->cbegin());
-      const_iterator pos(b);
-      const value_compare &value_comp = this->m_data;
-      skips[0u] = 0u;
-      //Loop in burst sizes
-      while(len){
-         const size_type burst = len < BurstSize ? len : BurstSize;
-         size_type unique_burst = 0u;
-         const const_iterator ce(this->cend());
-         while(unique_burst < burst && len > 0){
-            //Get the insertion position for each key
-            const value_type & val = *first++;
-            --len;
-            pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, ce, KeyOfValue()(val));
-            //Check if already present
-            if(pos != ce && !value_comp(val, *pos)){
-               if(unique_burst > 0){
-                  ++skips[unique_burst-1];
-               }
-               continue;
-            }
-
-            //If not present, calculate position
-            positions[unique_burst] = static_cast<size_type>(pos - b);
-            skips[unique_burst++] = 0u;
-         }
-         if(unique_burst){
-            //Insert all in a single step in the precalculated positions
-            this->m_data.m_vect.insert_ordered_at(unique_burst, positions + unique_burst, skips + unique_burst, first);
-            //Next search position updated
-            pos += unique_burst;
-         }
-      }
-   }
+   {   this->m_data.m_vect.merge_unique(first, last, value_compare());   }
 
-   #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+   #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    template <class... Args>
-   std::pair<iterator, bool> emplace_unique(Args&&... args)
+   std::pair<iterator, bool> emplace_unique(BOOST_FWD_REF(Args)... args)
    {
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
+      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));
       stored_allocator_type &a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
       value_destructor<stored_allocator_type> d(a, val);
-      insert_commit_data data;
-      std::pair<iterator,bool> ret =
-         this->priv_insert_unique_prepare(val, data);
-      if(ret.second){
-         ret.first = this->priv_insert_commit(data, boost::move(val));
-      }
-      return ret;
+      return this->insert_unique(::boost::move(val));
    }
 
    template <class... Args>
-   iterator emplace_hint_unique(const_iterator hint, Args&&... args)
+   iterator emplace_hint_unique(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
+      //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));
       stored_allocator_type &a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
       value_destructor<stored_allocator_type> d(a, val);
-      insert_commit_data data;
-      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(hint, val, data);
-      if(ret.second){
-         ret.first = this->priv_insert_commit(data, boost::move(val));
-      }
-      return ret.first;
+      return this->insert_unique(hint, ::boost::move(val));
    }
 
    template <class... Args>
-   iterator emplace_equal(Args&&... args)
+   iterator emplace_equal(BOOST_FWD_REF(Args)... args)
    {
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
+      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));
       stored_allocator_type &a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
       value_destructor<stored_allocator_type> d(a, val);
-      iterator i = this->upper_bound(KeyOfValue()(val));
-      i = this->m_data.m_vect.insert(i, boost::move(val));
-      return i;
+      return this->insert_equal(::boost::move(val));
    }
 
    template <class... Args>
-   iterator emplace_hint_equal(const_iterator hint, Args&&... args)
+   iterator emplace_hint_equal(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
+      //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));
       stored_allocator_type &a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
       value_destructor<stored_allocator_type> d(a, val);
-      insert_commit_data data;
-      this->priv_insert_equal_prepare(hint, val, data);
-      iterator i = this->priv_insert_commit(data, boost::move(val));
-      return i;
-   }
-
-   #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
-   #define BOOST_PP_LOCAL_MACRO(n)                                                        \
-   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
-   std::pair<iterator, bool>                                                              \
-      emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                  \
-   {                                                                                      \
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;             \
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));              \
-      stored_allocator_type &a = this->get_stored_allocator();                            \
-      stored_allocator_traits::construct(a, &val                                          \
-         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                \
-      value_destructor<stored_allocator_type> d(a, val);                                  \
-      insert_commit_data data;                                                            \
-      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(val, data);         \
-      if(ret.second){                                                                     \
-         ret.first = this->priv_insert_commit(data, boost::move(val));                    \
-      }                                                                                   \
-      return ret;                                                                         \
-   }                                                                                      \
-                                                                                          \
-   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
-   iterator emplace_hint_unique(const_iterator hint                                       \
-                        BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))      \
-   {                                                                                      \
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;             \
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));              \
-      stored_allocator_type &a = this->get_stored_allocator();                            \
-      stored_allocator_traits::construct(a, &val                                          \
-         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                \
-      value_destructor<stored_allocator_type> d(a,  val);                                 \
-      insert_commit_data data;                                                            \
-      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(hint, val, data);   \
-      if(ret.second){                                                                     \
-         ret.first = this->priv_insert_commit(data, boost::move(val));                    \
-      }                                                                                   \
-      return ret.first;                                                                   \
-   }                                                                                      \
-                                                                                          \
-   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
-   iterator emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))             \
-   {                                                                                      \
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;             \
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));              \
-      stored_allocator_type &a = this->get_stored_allocator();                            \
-      stored_allocator_traits::construct(a, &val                                          \
-         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                \
-      value_destructor<stored_allocator_type> d(a,  val);                                 \
-      iterator i = this->upper_bound(KeyOfValue()(val));                                  \
-      i = this->m_data.m_vect.insert(i, boost::move(val));                                \
-      return i;                                                                           \
-   }                                                                                      \
-                                                                                          \
-   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
-   iterator emplace_hint_equal(const_iterator hint                                        \
-                      BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))        \
-   {                                                                                      \
-      aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;             \
-      value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));              \
-      stored_allocator_type &a = this->get_stored_allocator();                            \
-      stored_allocator_traits::construct(a, &val                                          \
-         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                \
-      value_destructor<stored_allocator_type> d(a,  val);                                 \
-      insert_commit_data data;                                                            \
-      this->priv_insert_equal_prepare(hint, val, data);                                   \
-      iterator i = this->priv_insert_commit(data, boost::move(val));                      \
-      return i;                                                                           \
-   }                                                                                      \
-
-   //!
-   #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
-   #include BOOST_PP_LOCAL_ITERATE()
-
-   #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+      return this->insert_equal(hint, ::boost::move(val));
+   }
+
+   #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   #define BOOST_CONTAINER_FLAT_TREE_EMPLACE_CODE(N) \
+   BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
+   std::pair<iterator, bool> emplace_unique(BOOST_MOVE_UREF##N)\
+   {\
+      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
+      value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));\
+      stored_allocator_type &a = this->get_stored_allocator();\
+      stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type> d(a, val);\
+      return this->insert_unique(::boost::move(val));\
+   }\
+   \
+   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));\
+      stored_allocator_type &a = this->get_stored_allocator();\
+      stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type> d(a, val);\
+      return this->insert_unique(hint, ::boost::move(val));\
+   }\
+   \
+   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));\
+      stored_allocator_type &a = this->get_stored_allocator();\
+      stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type> d(a, val);\
+      return this->insert_equal(::boost::move(val));\
+   }\
+   \
+   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));\
+      stored_allocator_type &a = this->get_stored_allocator();\
+      stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_destructor<stored_allocator_type> d(a, val);\
+      return this->insert_equal(hint, ::boost::move(val));\
+   }\
+   //
+   BOOST_MOVE_ITERATE_0TO9(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)
    {  return this->m_data.m_vect.erase(position);  }
@@ -701,29 +640,41 @@ class flat_tree
    void shrink_to_fit()
    {  this->m_data.m_vect.shrink_to_fit();  }
 
+   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
+   {  return this->m_data.m_vect.nth(n);   }
+
+   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
+   {  return this->m_data.m_vect.index_of(p);   }
+
    // set operations:
    iterator find(const key_type& k)
    {
-      const Compare &key_cmp = this->m_data.get_comp();
       iterator i = this->lower_bound(k);
-
-      if (i != this->end() && key_cmp(k, KeyOfValue()(*i))){ 
-         i = this->end(); 
+      iterator end_it = this->end();
+      if (i != end_it && this->m_data.get_comp()(k, KeyOfValue()(*i))){
+         i = end_it;
       }
       return i;
    }
 
    const_iterator find(const key_type& k) const
    {
-      const Compare &key_cmp = this->m_data.get_comp();
       const_iterator i = this->lower_bound(k);
 
-      if (i != this->end() && key_cmp(k, KeyOfValue()(*i))){ 
-         i = this->end(); 
+      const_iterator end_it = this->cend();
+      if (i != end_it && this->m_data.get_comp()(k, KeyOfValue()(*i))){
+         i = end_it;
       }
       return i;
    }
 
+   // set operations:
    size_type count(const key_type& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
@@ -735,27 +686,64 @@ class flat_tree
    {  return this->priv_lower_bound(this->begin(), this->end(), k);  }
 
    const_iterator lower_bound(const key_type& k) const
-   {  return this->priv_lower_bound(this->begin(), this->end(), k);  }
+   {  return this->priv_lower_bound(this->cbegin(), this->cend(), k);  }
 
    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
-   {  return this->priv_upper_bound(this->begin(), this->end(), k);  }
+   {  return this->priv_upper_bound(this->cbegin(), this->cend(), k);  }
 
    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
-   {  return this->priv_equal_range(this->begin(), this->end(), k);  }
+   {  return this->priv_equal_range(this->cbegin(), this->cend(), k);  }
+
+   std::pair<iterator, iterator> lower_bound_range(const key_type& k)
+   {  return this->priv_lower_bound_range(this->begin(), this->end(), k);  }
 
-   size_type capacity() const          
+   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
    { return this->m_data.m_vect.capacity(); }
 
-   void reserve(size_type cnt)      
+   void reserve(size_type cnt)
    { this->m_data.m_vect.reserve(cnt);   }
 
+   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)
+   {
+      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)
+      {  return !(x == y); }
+
+   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)
+      {  return !(y < x);  }
+
+   friend bool operator>=(const flat_tree& x, const flat_tree& y)
+      {  return !(x < y);  }
+
+   friend void swap(flat_tree& x, flat_tree& y)
+      {  x.swap(y);  }
+
    private:
+
+   bool priv_in_range_or_end(const_iterator pos) const
+   {
+      return (this->begin() <= pos) && (pos <= this->end());
+   }
+
    struct insert_commit_data
    {
       const_iterator position;
@@ -774,10 +762,10 @@ class flat_tree
       //         insert val before upper_bound(val)
       //   else
       //      insert val before lower_bound(val)
-      const value_compare &value_comp = this->m_data;
+      const value_compare &val_cmp = this->m_data;
 
-      if(pos == this->cend() || !value_comp(*pos, val)){
-         if (pos == this->cbegin() || !value_comp(val, pos[-1])){
+      if(pos == this->cend() || !val_cmp(*pos, val)){
+         if (pos == this->cbegin() || !val_cmp(val, pos[-1])){
             data.position = pos;
          }
          else{
@@ -791,21 +779,19 @@ class flat_tree
       }
    }
 
-   std::pair<iterator,bool> priv_insert_unique_prepare
+   bool priv_insert_unique_prepare
       (const_iterator b, const_iterator e, const value_type& val, insert_commit_data &commit_data)
    {
-      const value_compare &value_comp  = this->m_data;
+      const value_compare &val_cmp  = this->m_data;
       commit_data.position = this->priv_lower_bound(b, e, KeyOfValue()(val));
-      return std::pair<iterator,bool>
-         ( iterator(vector_iterator_get_ptr(commit_data.position))
-         , commit_data.position == e || value_comp(val, *commit_data.position));
+      return commit_data.position == e || val_cmp(val, *commit_data.position);
    }
 
-   std::pair<iterator,bool> priv_insert_unique_prepare
+   bool priv_insert_unique_prepare
       (const value_type& val, insert_commit_data &commit_data)
-   {  return this->priv_insert_unique_prepare(this->begin(), this->end(), val, commit_data);   }
+   {  return this->priv_insert_unique_prepare(this->cbegin(), this->cend(), val, commit_data);   }
 
-   std::pair<iterator,bool> priv_insert_unique_prepare
+   bool priv_insert_unique_prepare
       (const_iterator pos, const value_type& val, insert_commit_data &commit_data)
    {
       //N1780. Props to Howard Hinnant!
@@ -819,37 +805,32 @@ class flat_tree
       //   insert val after pos
       //else
       //   insert val before lower_bound(val)
-      const value_compare &value_comp = this->m_data;
-
-      if(pos == this->cend() || value_comp(val, *pos)){
-         if(pos != this->cbegin() && !value_comp(val, pos[-1])){
-            if(value_comp(pos[-1], val)){
-               commit_data.position = pos;
-               return std::pair<iterator,bool>(iterator(vector_iterator_get_ptr(pos)), true);
-            }
-            else{
-               return std::pair<iterator,bool>(iterator(vector_iterator_get_ptr(pos)), false);
-            }
+      const value_compare &val_cmp = this->m_data;
+      const const_iterator cend_it = this->cend();
+      if(pos == cend_it || val_cmp(val, *pos)){ //Check if val 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
+            return true;
+         }
+         const_iterator prev(pos);
+         --prev;
+         if(val_cmp(*prev, val)){   //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
+            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);
          }
-         return this->priv_insert_unique_prepare(this->cbegin(), pos, val, commit_data);
       }
-
-      // Works, but increases code complexity
-      //Next check
-      //else if (value_comp(*pos, val) && !value_comp(pos[1], val)){
-      //   if(value_comp(val, pos[1])){
-      //      commit_data.position = pos+1;
-      //      return std::pair<iterator,bool>(pos+1, true);
-      //   }
-      //   else{
-      //      return std::pair<iterator,bool>(pos+1, false);
-      //   }
-      //}
       else{
-         //[... pos ... val ... ]
          //The hint is before the insertion position, so insert it
-         //in the remaining range
-         return this->priv_insert_unique_prepare(pos, this->end(), val, commit_data);
+         //in the remaining range [pos, end)
+         return this->priv_insert_unique_prepare(pos, cend_it, val, commit_data);
       }
    }
 
@@ -863,50 +844,50 @@ class flat_tree
    }
 
    template <class RanIt>
-   RanIt priv_lower_bound(RanIt first, RanIt last,
+   RanIt priv_lower_bound(RanIt first, const RanIt last,
                           const key_type & key) const
    {
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;
-      difference_type len = last - first, half;
+      size_type len = static_cast<size_type>(last - first);
       RanIt middle;
 
-      while (len > 0) {
-         half = len >> 1;
+      while (len) {
+         size_type step = len >> 1;
          middle = first;
-         middle += half;
+         middle += step;
 
          if (key_cmp(key_extract(*middle), key)) {
-            ++middle;
-            first = middle;
-            len = len - half - 1;
+            first = ++middle;
+            len -= step + 1;
+         }
+         else{
+            len = step;
          }
-         else
-            len = half;
       }
       return first;
    }
 
    template <class RanIt>
-   RanIt priv_upper_bound(RanIt first, RanIt last,
-                          const key_type & key) const
+   RanIt priv_upper_bound
+      (RanIt first, const RanIt last,const key_type & key) const
    {
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;
-      difference_type len = last - first, half;
+      size_type len = static_cast<size_type>(last - first);
       RanIt middle;
 
-      while (len > 0) {
-         half = len >> 1;
+      while (len) {
+         size_type step = len >> 1;
          middle = first;
-         middle += half;
+         middle += step;
 
          if (key_cmp(key, key_extract(*middle))) {
-            len = half;
+            len = step;
          }
          else{
             first = ++middle;
-            len = len - half - 1; 
+            len -= step + 1;
          }
       }
       return first;
@@ -918,136 +899,82 @@ class flat_tree
    {
       const Compare &key_cmp = this->m_data.get_comp();
       KeyOfValue key_extract;
-      difference_type len = last - first, half;
-      RanIt middle, left, right;
+      size_type len = static_cast<size_type>(last - first);
+      RanIt middle;
 
-      while (len > 0) {
-         half = len >> 1;
+      while (len) {
+         size_type step = len >> 1;
          middle = first;
-         middle += half;
+         middle += step;
 
          if (key_cmp(key_extract(*middle), key)){
-            first = middle;
-            ++first;
-            len = len - half - 1;
+            first = ++middle;
+            len -= step + 1;
          }
          else if (key_cmp(key, key_extract(*middle))){
-            len = half;
+            len = step;
          }
          else {
-            left = this->priv_lower_bound(first, middle, key);
-            first += len;
-            right = this->priv_upper_bound(++middle, first, key);
-            return std::pair<RanIt, RanIt>(left, right);
+            //Middle is equal to key
+            last = first;
+            last += len;
+            RanIt const first_ret = this->priv_lower_bound(first, middle, key);
+            return std::pair<RanIt, RanIt>
+               ( first_ret, this->priv_upper_bound(++middle, last, key));
          }
       }
       return std::pair<RanIt, RanIt>(first, first);
    }
 
-   template<class InIt>
-   void priv_insert_equal_loop(InIt first, InIt last)
+   template<class RanIt>
+   std::pair<RanIt, RanIt> priv_lower_bound_range(RanIt first, RanIt last, const key_type& k) const
    {
-      for ( ; first != last; ++first){
-         this->insert_equal(*first);
-      }
-   }
-
-   template<class InIt>
-   void priv_insert_equal_loop_ordered(InIt first, InIt last)
-   {
-      const_iterator pos(this->cend());
-      for ( ; first != last; ++first){
-         pos = this->insert_equal(pos, *first);
+      const Compare &key_cmp = this->m_data.get_comp();
+      KeyOfValue key_extract;
+      RanIt lb(this->priv_lower_bound(first, last, k)), ub(lb);
+      if(lb != last && static_cast<difference_type>(!key_cmp(k, key_extract(*lb)))){
+         ++ub;
       }
+      return std::pair<RanIt, RanIt>(lb, ub);
    }
 
    template<class InIt>
-   void priv_insert_unique_loop(InIt first, InIt last)
+   void priv_insert_equal_loop(InIt first, InIt last)
    {
       for ( ; first != last; ++first){
-         this->insert_unique(*first);
+         this->insert_equal(*first);
       }
    }
 
    template<class InIt>
-   void priv_insert_unique_loop_ordered(InIt first, InIt last)
+   void priv_insert_equal_loop_ordered(InIt first, InIt last)
    {
       const_iterator pos(this->cend());
       for ( ; first != last; ++first){
-         pos = this->insert_unique(pos, *first);
+         //If ordered, then try hint version
+         //to achieve constant-time complexity per insertion
+         //in some cases
+         pos = this->insert_equal(pos, *first);
+         ++pos;
       }
    }
 };
 
-template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
-inline bool
-operator==(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
-           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
-{
-  return x.size() == y.size() &&
-         std::equal(x.begin(), x.end(), y.begin());
-}
-
-template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
-inline bool
-operator<(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
-          const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
-{
-  return std::lexicographical_compare(x.begin(), x.end(),
-                                      y.begin(), y.end());
-}
-
-template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
-inline bool
-operator!=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
-           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
-   {  return !(x == y); }
-
-template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
-inline bool
-operator>(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
-          const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
-   {  return y < x;  }
-
-template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
-inline bool
-operator<=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
-           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
-   {  return !(y < x);  }
-
-template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
-inline bool
-operator>=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
-           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
-   {  return !(x < y);  }
-
-
-template <class Key, class Value, class KeyOfValue,
-          class Compare, class A>
-inline void
-swap(flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
-     flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
-   {  x.swap(y);  }
-
 }  //namespace container_detail {
 
 }  //namespace container {
-/*
+
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class K, class V, class KOV,
-class C, class A>
-struct has_trivial_destructor_after_move<boost::container::container_detail::flat_tree<K, V, KOV, C, A> >
+template <class Key, 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> >
 {
-   static const bool value = has_trivial_destructor_after_move<A>::value && has_trivial_destructor_after_move<C>::value;
+   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+                             ::boost::has_trivial_destructor_after_move<pointer>::value;
 };
-*/
+
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>