passenger 6.0.19 → 6.0.21

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

@@ -135,19 +135,21 @@ BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(stored_allocator_type)
 //
 ///////////////////////////////////////
 template<class SequenceContainer, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_merge //is_contiguous_container == true
+inline void flat_tree_container_inplace_merge //is_contiguous_container == true
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::true_)
 {
    typedef typename SequenceContainer::value_type  value_type;
-   value_type *const braw = boost::movelib::iterator_to_raw_pointer(dest.begin());
+   value_type *const braw = boost::movelib::to_raw_pointer(dest.data());
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
-   value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
+   //Don't use iterator_to_raw_pointer for end as debug iterators can assert when
+   //"operator ->" is used with the end iterator
+   value_type *const eraw = braw + dest.size();
    boost::movelib::adaptive_merge
       (braw, iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
 }
 
 template<class SequenceContainer, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_merge //is_contiguous_container == false
+inline void flat_tree_container_inplace_merge //is_contiguous_container == false
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp, dtl::false_)
 {
    boost::movelib::adaptive_merge(dest.begin(), it, dest.end(), comp);
@@ -159,18 +161,22 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_merge //is_contiguo
 //
 ///////////////////////////////////////
 template<class SequenceContainer, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_sort_ending //is_contiguous_container == true
+inline void flat_tree_container_inplace_sort_ending //is_contiguous_container == true
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp, dtl::true_)
 {
    typedef typename SequenceContainer::value_type  value_type;
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
-   value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
+   //Don't use iterator_to_raw_pointer for end as debug iterators can assert when
+   //"operator ->" is used with the end iterator
+   value_type* const eraw = boost::movelib::to_raw_pointer(dest.data()) + dest.size();
+
+
    boost::movelib::adaptive_sort
       (iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
 }
 
 template<class SequenceContainer, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_sort_ending //is_contiguous_container == false
+inline void flat_tree_container_inplace_sort_ending //is_contiguous_container == false
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::false_)
 {
    boost::movelib::adaptive_sort(it, dest.end(), comp);
@@ -182,20 +188,22 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_sort_ending //is_co
 //
 ///////////////////////////////////////
 template<class SequenceContainer, class Iterator, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal
+inline void flat_tree_merge_equal
    (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::true_)
 {
    dest.merge(first, last, comp);
 }
 
 template<class SequenceContainer, class Iterator, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal   //has_merge_unique == false
+inline void flat_tree_merge_equal   //has_merge_unique == false
    (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
-   typedef typename SequenceContainer::iterator    iterator;
-   iterator const it = dest.insert( dest.end(), first, last );
-   dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
-   (flat_tree_container_inplace_merge)(dest, it, comp, contiguous_tag);
+   if(first != last) {
+      typedef typename SequenceContainer::iterator    iterator;
+      iterator const it = dest.insert( dest.end(), first, last );
+      dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
+      (flat_tree_container_inplace_merge)(dest, it, comp, contiguous_tag);
+   }
 }
 
 ///////////////////////////////////////
@@ -204,26 +212,28 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal   //has_merge_unique == f
 //
 ///////////////////////////////////////
 template<class SequenceContainer, class Iterator, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique  //has_merge_unique == true
+inline void flat_tree_merge_unique  //has_merge_unique == true
    (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::true_)
 {
    dest.merge_unique(first, last, comp);
 }
 
 template<class SequenceContainer, class Iterator, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique  //has_merge_unique == false
+inline void flat_tree_merge_unique  //has_merge_unique == false
    (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
-   typedef typename SequenceContainer::iterator          iterator;
-   typedef typename SequenceContainer::size_type         size_type;
-   typedef typename SequenceContainer::difference_type   difference_type;
-
-   size_type const old_sz = dest.size();
-   iterator const first_new = dest.insert(dest.cend(), first, last );
-   iterator e = boost::movelib::inplace_set_unique_difference(first_new, dest.end(), dest.begin(), first_new, comp);
-   dest.erase(e, dest.end());
-   dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
-   (flat_tree_container_inplace_merge)(dest, dest.begin() + difference_type(old_sz), comp, contiguous_tag);
+   if (first != last) {
+      typedef typename SequenceContainer::iterator          iterator;
+      typedef typename SequenceContainer::size_type         size_type;
+      typedef typename SequenceContainer::difference_type   difference_type;
+
+      size_type const old_sz = dest.size();
+      iterator const first_new = dest.insert(dest.cend(), first, last );
+      iterator e = boost::movelib::inplace_set_unique_difference(first_new, dest.end(), dest.begin(), first_new, comp);
+      dest.erase(e, dest.end());
+      dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
+      (flat_tree_container_inplace_merge)(dest, dest.begin() + difference_type(old_sz), comp, contiguous_tag);
+   }
 }
 
 ///////////////////////////////////////
@@ -232,7 +242,7 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique  //has_merge_unique == f
 //
 ///////////////////////////////////////
 template<class SequenceContainer, class Iterator>
-BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+inline typename SequenceContainer::size_type
    flat_tree_index_of   // has_index_of == true
       (SequenceContainer& cont, Iterator p, dtl::true_)
 {
@@ -240,7 +250,7 @@ BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
 }
 
 template<class SequenceContainer, class Iterator>
-BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+inline typename SequenceContainer::size_type
    flat_tree_index_of   // has_index_of == false
       (SequenceContainer& cont, Iterator p, dtl::false_)
 {
@@ -254,7 +264,7 @@ BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
 //
 ///////////////////////////////////////
 template<class Iterator, class SequenceContainer>
-BOOST_CONTAINER_FORCEINLINE Iterator
+inline Iterator
    flat_tree_nth  // has_nth == true
       (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::true_)
 {
@@ -262,7 +272,7 @@ BOOST_CONTAINER_FORCEINLINE Iterator
 }
 
 template<class Iterator, class SequenceContainer>
-BOOST_CONTAINER_FORCEINLINE Iterator
+inline Iterator
    flat_tree_nth  // has_nth == false
       (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::false_)
 {
@@ -275,7 +285,7 @@ BOOST_CONTAINER_FORCEINLINE Iterator
 //
 ///////////////////////////////////////
 template<class SequenceContainer>
-BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::stored_allocator_type &
+inline typename SequenceContainer::stored_allocator_type &
    flat_tree_get_stored_allocator   // has_get_stored_allocator == true
       (SequenceContainer& cont, dtl::true_)
 {
@@ -283,7 +293,7 @@ BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::stored_allocator_type &
 }
 
 template<class SequenceContainer>
-BOOST_CONTAINER_FORCEINLINE const typename SequenceContainer::stored_allocator_type &
+inline const typename SequenceContainer::stored_allocator_type &
    flat_tree_get_stored_allocator   // has_get_stored_allocator == true
       (const SequenceContainer& cont, dtl::true_)
 {
@@ -291,7 +301,7 @@ BOOST_CONTAINER_FORCEINLINE const typename SequenceContainer::stored_allocator_t
 }
 
 template<class SequenceContainer>
-BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::allocator_type
+inline typename SequenceContainer::allocator_type
    flat_tree_get_stored_allocator   // has_get_stored_allocator == false
       (SequenceContainer& cont, dtl::false_)
 {
@@ -327,7 +337,7 @@ void flat_tree_sort_contiguous_to_adopt // is_contiguous_container == true
 }
 
 template<class SequenceContainer, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_adopt_sequence_equal // is_contiguous_container == true
+inline void flat_tree_adopt_sequence_equal // is_contiguous_container == true
    (SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::true_)
 {
    flat_tree_sort_contiguous_to_adopt(tseq, boost::move(seq), comp);
@@ -335,7 +345,7 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_adopt_sequence_equal // is_contiguous
 }
 
 template<class SequenceContainer, class Compare>
-BOOST_CONTAINER_FORCEINLINE void flat_tree_adopt_sequence_equal // is_contiguous_container == false
+inline void flat_tree_adopt_sequence_equal // is_contiguous_container == false
    (SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::false_)
 {
    boost::movelib::adaptive_sort(seq.begin(), seq.end(), comp);
@@ -376,14 +386,14 @@ void flat_tree_adopt_sequence_unique// is_contiguous_container == false
 //
 ///////////////////////////////////////
 template<class SequenceContainer>
-BOOST_CONTAINER_FORCEINLINE void // has_reserve == true
+inline void // has_reserve == true
    flat_tree_reserve(SequenceContainer &tseq, typename SequenceContainer::size_type cap, dtl::true_)
 {
    tseq.reserve(cap);
 }
 
 template<class SequenceContainer>
-BOOST_CONTAINER_FORCEINLINE void // has_reserve == false
+inline void // has_reserve == false
    flat_tree_reserve(SequenceContainer &, typename SequenceContainer::size_type, dtl::false_)
 {
 }
@@ -394,14 +404,14 @@ BOOST_CONTAINER_FORCEINLINE void // has_reserve == false
 //
 ///////////////////////////////////////
 template<class SequenceContainer>   // has_capacity == true
-BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+inline typename SequenceContainer::size_type
    flat_tree_capacity(const SequenceContainer &tseq, dtl::true_)
 {
    return tseq.capacity();
 }
 
 template<class SequenceContainer>   // has_capacity == false
-BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+inline typename SequenceContainer::size_type
    flat_tree_capacity(const SequenceContainer &tseq, dtl::false_)
 {
    return tseq.size();
@@ -421,24 +431,24 @@ class flat_tree_value_compare
    typedef Value              second_argument_type;
    typedef bool               return_type;
    public:
-   BOOST_CONTAINER_FORCEINLINE flat_tree_value_compare()
+   inline flat_tree_value_compare()
       : Compare()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree_value_compare(const Compare &pred)
+   inline flat_tree_value_compare(const Compare &pred)
       : Compare(pred)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const Value& lhs, const Value& rhs) const
+   inline bool operator()(const Value& lhs, const Value& rhs) const
    {
       KeyOfValue key_extract;
       return Compare::operator()(key_extract(lhs), key_extract(rhs));
    }
 
-   BOOST_CONTAINER_FORCEINLINE const Compare &get_comp() const
+   inline const Compare &get_comp() const
       {  return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE Compare &get_comp()
+   inline Compare &get_comp()
       {  return *this;  }
 };
 
@@ -492,35 +502,35 @@ class flat_tree
       BOOST_COPYABLE_AND_MOVABLE(Data)
 
       public:
-      BOOST_CONTAINER_FORCEINLINE Data()
+      inline Data()
          : value_compare(), m_seq()
       {}
 
-      BOOST_CONTAINER_FORCEINLINE explicit Data(const allocator_t &alloc)
+      inline explicit Data(const allocator_t &alloc)
          : value_compare(), m_seq(alloc)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE explicit Data(const Compare &comp)
+      inline explicit Data(const Compare &comp)
          : value_compare(comp), m_seq()
       {}
 
-      BOOST_CONTAINER_FORCEINLINE Data(const Compare &comp, const allocator_t &alloc)
+      inline Data(const Compare &comp, const allocator_t &alloc)
          : value_compare(comp), m_seq(alloc)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE explicit Data(const Data &d)
+      inline explicit Data(const Data &d)
          : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE Data(BOOST_RV_REF(Data) d)
+      inline Data(BOOST_RV_REF(Data) d)
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq))
       {}
 
-      BOOST_CONTAINER_FORCEINLINE Data(const Data &d, const allocator_t &a)
+      inline Data(const Data &d, const allocator_t &a)
          : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq, a)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE Data(BOOST_RV_REF(Data) d, const allocator_t &a)
+      inline Data(BOOST_RV_REF(Data) d, const allocator_t &a)
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq), a)
       {}
 
@@ -586,41 +596,41 @@ class flat_tree
    typedef typename dtl::if_c
       <has_stored_allocator_type, stored_allocator_type &, allocator_type>::type get_stored_allocator_noconst_return_t;
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree()
+   inline flat_tree()
       : m_data()
    { }
 
-   BOOST_CONTAINER_FORCEINLINE explicit flat_tree(const Compare& comp)
+   inline explicit flat_tree(const Compare& comp)
       : m_data(comp)
    { }
 
-   BOOST_CONTAINER_FORCEINLINE explicit flat_tree(const allocator_type& a)
+   inline explicit flat_tree(const allocator_type& a)
       : m_data(a)
    { }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree(const Compare& comp, const allocator_type& a)
+   inline flat_tree(const Compare& comp, const allocator_type& a)
       : m_data(comp, a)
    { }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree(const flat_tree& x)
+   inline flat_tree(const flat_tree& x)
       :  m_data(x.m_data)
    { }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree(BOOST_RV_REF(flat_tree) x)
+   inline flat_tree(BOOST_RV_REF(flat_tree) x)
       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       :  m_data(boost::move(x.m_data))
    { }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree(const flat_tree& x, const allocator_type &a)
+   inline flat_tree(const flat_tree& x, const allocator_type &a)
       :  m_data(x.m_data, a)
    { }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree(BOOST_RV_REF(flat_tree) x, const allocator_type &a)
+   inline flat_tree(BOOST_RV_REF(flat_tree) x, const allocator_type &a)
       :  m_data(boost::move(x.m_data), a)
    { }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( ordered_range_t, InputIterator first, InputIterator last)
       : m_data()
    {
@@ -629,7 +639,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
       : m_data(comp)
    {
@@ -638,7 +648,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : m_data(comp, a)
    {
@@ -647,7 +657,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last)
       : m_data()
    {
@@ -656,7 +666,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
       : m_data(comp)
    {
@@ -665,7 +675,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : m_data(comp, a)
    {
@@ -674,7 +684,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( bool unique_insertion, InputIterator first, InputIterator last)
       : m_data()
    {
@@ -682,7 +692,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( bool unique_insertion, InputIterator first, InputIterator last
             , const Compare& comp)
       : m_data(comp)
@@ -691,7 +701,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( bool unique_insertion, InputIterator first, InputIterator last
             , const allocator_type& a)
       : m_data(a)
@@ -700,7 +710,7 @@ class flat_tree
    }
 
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    flat_tree( bool unique_insertion, InputIterator first, InputIterator last
             , const Compare& comp, const allocator_type& a)
       : m_data(comp, a)
@@ -708,28 +718,28 @@ class flat_tree
       this->priv_range_insertion_construct(unique_insertion, first, last);
    }
 
-   BOOST_CONTAINER_FORCEINLINE ~flat_tree()
+   inline ~flat_tree()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree&  operator=(BOOST_COPY_ASSIGN_REF(flat_tree) x)
+   inline flat_tree&  operator=(BOOST_COPY_ASSIGN_REF(flat_tree) x)
    {  m_data = x.m_data;   return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree&  operator=(BOOST_RV_REF(flat_tree) x)
+   inline 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::dtl::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
+   inline const value_compare &priv_value_comp() const
    { return static_cast<const value_compare &>(this->m_data); }
 
-   BOOST_CONTAINER_FORCEINLINE value_compare &priv_value_comp()
+   inline value_compare &priv_value_comp()
    { return static_cast<value_compare &>(this->m_data); }
 
-   BOOST_CONTAINER_FORCEINLINE const key_compare &priv_key_comp() const
+   inline const key_compare &priv_key_comp() const
    { return this->priv_value_comp().get_comp(); }
 
-   BOOST_CONTAINER_FORCEINLINE key_compare &priv_key_comp()
+   inline key_compare &priv_key_comp()
    { return this->priv_value_comp().get_comp(); }
 
    struct insert_commit_data
@@ -739,91 +749,91 @@ class flat_tree
 
    public:
    // accessors:
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       Compare key_comp() const
    { return this->m_data.get_comp(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       value_compare value_comp() const
    { return this->m_data; }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       allocator_type get_allocator() const
    { return this->m_data.m_seq.get_allocator(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       get_stored_allocator_const_return_t get_stored_allocator() const
    {
       return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       get_stored_allocator_noconst_return_t get_stored_allocator()
    {
       return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator begin()
    { return this->m_data.m_seq.begin(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator begin() const
    { return this->cbegin(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cbegin() const
    { return this->m_data.m_seq.begin(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator end()
    { return this->m_data.m_seq.end(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator end() const
    { return this->cend(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cend() const
    { return this->m_data.m_seq.end(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rbegin()
    { return reverse_iterator(this->end()); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rbegin() const
    {  return this->crbegin();  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crbegin() const
    {  return const_reverse_iterator(this->cend());  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rend()
    { return reverse_iterator(this->begin()); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rend() const
    { return this->crend(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crend() const
    { return const_reverse_iterator(this->cbegin()); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       bool empty() const
    { return this->m_data.m_seq.empty(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type size() const
    { return this->m_data.m_seq.size(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type max_size() const
    { return this->m_data.m_seq.max_size(); }
 
-   BOOST_CONTAINER_FORCEINLINE void swap(flat_tree& other)
+   inline void swap(flat_tree& other)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::dtl::is_nothrow_swappable<Compare>::value )
    {  this->m_data.swap(other.m_data);  }
@@ -931,11 +941,13 @@ class flat_tree
    template <class InIt>
    void insert_equal(InIt first, InIt last)
    {
-      dtl::bool_<is_contiguous_container<container_type>::value> contiguous_tag;
-      container_type &seq = this->m_data.m_seq;
-      typename container_type::iterator const it = seq.insert(seq.cend(), first, last);
-      (flat_tree_container_inplace_sort_ending)(seq, it, this->priv_value_comp(), contiguous_tag);
-      (flat_tree_container_inplace_merge)      (seq, it, this->priv_value_comp(), contiguous_tag);
+      if (first != last) {
+         dtl::bool_<is_contiguous_container<container_type>::value> contiguous_tag;
+         container_type &seq = this->m_data.m_seq;
+         typename container_type::iterator const it = seq.insert(seq.cend(), first, last);
+         (flat_tree_container_inplace_sort_ending)(seq, it, this->priv_value_comp(), contiguous_tag);
+         (flat_tree_container_inplace_merge)      (seq, it, this->priv_value_comp(), contiguous_tag);
+      }
    }
 
    //Ordered
@@ -1005,7 +1017,7 @@ class flat_tree
    }
 
    template <class KeyType, class... Args>
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> try_emplace
+   inline std::pair<iterator, bool> try_emplace
       (const_iterator hint, BOOST_FWD_REF(KeyType) key, BOOST_FWD_REF(Args)... args)
    {
       std::pair<iterator,bool> ret;
@@ -1071,7 +1083,7 @@ class flat_tree
       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>\
+   inline 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;\
@@ -1114,7 +1126,7 @@ class flat_tree
       return ret;
    }
 
-   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator position)
+   inline iterator erase(const_iterator position)
    {  return this->m_data.m_seq.erase(position);  }
 
    size_type erase(const key_type& k)
@@ -1129,17 +1141,17 @@ class flat_tree
 
    size_type erase_unique(const key_type& k)
    {
-      iterator i = this->find(k);
-      size_type ret = static_cast<size_type>(i != this->end());
+      const_iterator i = static_cast<const flat_tree &>(*this).find(k);
+      size_type ret = static_cast<size_type>(i != this->cend());
       if (ret)
          this->erase(i);
       return ret;
    }
 
-   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
+   inline iterator erase(const_iterator first, const_iterator last)
    {  return this->m_data.m_seq.erase(first, last);  }
 
-   BOOST_CONTAINER_FORCEINLINE void clear()
+   inline void clear()
    {  this->m_data.m_seq.clear();  }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -1148,17 +1160,17 @@ class flat_tree
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
-   BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
+   inline void shrink_to_fit()
    {  this->m_data.m_seq.shrink_to_fit();  }
 
-   BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_nth<container_type, size_type>::value;
       return flat_tree_nth<iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = boost::container::dtl::
@@ -1166,7 +1178,7 @@ class flat_tree
       return flat_tree_nth<const_iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = boost::container::dtl::
@@ -1174,7 +1186,7 @@ class flat_tree
       return flat_tree_index_of(this->m_data.m_seq, p, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = boost::container::dtl::
@@ -1251,30 +1263,30 @@ class flat_tree
       return n;
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE bool contains(const key_type& x) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline bool contains(const key_type& x) const
    {  return this->find(x) != this->cend();  }
 
    template<typename K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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)
+   inline void merge_unique(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
    {
       this->insert_unique( boost::make_move_iterator(source.begin())
                          , boost::make_move_iterator(source.end()));
    }
 
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge_equal(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
+   inline void merge_equal(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
    {
       this->insert_equal( boost::make_move_iterator(source.begin())
                         , boost::make_move_iterator(source.end()));
    }
 
-   BOOST_CONTAINER_FORCEINLINE void merge_unique(flat_tree& source)
+   inline void merge_unique(flat_tree& source)
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
@@ -1286,7 +1298,7 @@ class flat_tree
          , dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE void merge_equal(flat_tree& source)
+   inline void merge_equal(flat_tree& source)
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_merge<container_type, iterator, iterator, value_compare>::value;
@@ -1298,88 +1310,88 @@ class flat_tree
          , dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator lower_bound(const key_type& k)
    {  return this->priv_lower_bound(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator lower_bound(const key_type& k) const
    {  return this->priv_lower_bound(this->cbegin(), this->cend(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline 
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline 
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator upper_bound(const key_type& k)
    {  return this->priv_upper_bound(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline 
       const_iterator upper_bound(const key_type& k) const
    {  return this->priv_upper_bound(this->cbegin(), this->cend(), k);  }
 
    template<class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       std::pair<iterator,iterator> equal_range(const key_type& k)
    {  return this->priv_equal_range(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       std::pair<iterator, iterator> lower_bound_range(const key_type& k)
    {  return this->priv_lower_bound_range(this->begin(), this->end(), k);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       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_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type capacity() const
    {
       const bool value = boost::container::dtl::
@@ -1387,7 +1399,7 @@ class flat_tree
       return (flat_tree_capacity)(this->m_data.m_seq, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       void reserve(size_type cnt)
    {
       const bool value = boost::container::dtl::
@@ -1395,25 +1407,25 @@ class flat_tree
       (flat_tree_reserve)(this->m_data.m_seq, cnt, dtl::bool_<value>());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       container_type extract_sequence()
    {  return boost::move(m_data.m_seq);   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       container_type &get_sequence_ref()
    {  return m_data.m_seq; }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const container_type &get_sequence_cref() const
    {  return m_data.m_seq; }
 
-   BOOST_CONTAINER_FORCEINLINE void adopt_sequence_equal(BOOST_RV_REF(container_type) seq)
+   inline void adopt_sequence_equal(BOOST_RV_REF(container_type) seq)
    {
       (flat_tree_adopt_sequence_equal)( m_data.m_seq, boost::move(seq), this->priv_value_comp()
          , dtl::bool_<is_contiguous_container<container_type>::value>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE void adopt_sequence_unique(BOOST_RV_REF(container_type) seq)
+   inline void adopt_sequence_unique(BOOST_RV_REF(container_type) seq)
    {
       (flat_tree_adopt_sequence_unique)(m_data.m_seq, boost::move(seq), this->priv_value_comp()
          , dtl::bool_<is_contiguous_container<container_type>::value>());
@@ -1431,35 +1443,35 @@ class flat_tree
       m_data.m_seq = boost::move(seq);
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator==(const flat_tree& x, const flat_tree& y)
    {
       return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<(const flat_tree& x, const flat_tree& y)
    {
       return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator!=(const flat_tree& x, const flat_tree& y)
       {  return !(x == y); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>(const flat_tree& x, const flat_tree& y)
       {  return y < x;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<=(const flat_tree& x, const flat_tree& y)
       {  return !(y < x);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>=(const flat_tree& x, const flat_tree& y)
       {  return !(x < y);  }
 
-   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_tree& x, flat_tree& y)
+   inline friend void swap(flat_tree& x, flat_tree& y)
           BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y)))
       {  x.swap(y);  }
 
@@ -1480,7 +1492,7 @@ class flat_tree
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_in_range_or_end(const_iterator pos) const
+   inline bool priv_in_range_or_end(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos <= this->end());
    }
@@ -1523,7 +1535,7 @@ class flat_tree
       return commit_data.position == e || key_cmp(k, KeyOfValue()(*commit_data.position));
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_insert_unique_prepare
+   inline 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);   }
 
@@ -1571,7 +1583,7 @@ class flat_tree
    }
 
    template<class Convertible>
-   BOOST_CONTAINER_FORCEINLINE iterator priv_insert_commit
+   inline iterator priv_insert_commit
       (insert_commit_data &commit_data, BOOST_FWD_REF(Convertible) convertible)
    {
       return this->m_data.m_seq.insert