passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/basic_op.hpp

@@ -35,19 +35,19 @@ struct four_way_t{};
 struct move_op
 {
    template <class SourceIt, class DestinationIt>
-   void operator()(SourceIt source, DestinationIt dest)
+   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
    {  *dest = ::boost::move(*source);  }
 
    template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return ::boost::move(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
    {  return ::boost::move_backward(first, last, dest_last);  }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
    {
       *dest2it = boost::move(*dest1it);
       *dest1it = boost::move(*srcit);
@@ -64,7 +64,7 @@ struct move_op
    }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
-   void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
    {
       *dest3it = boost::move(*dest2it);
       *dest2it = boost::move(*dest1it);
@@ -75,19 +75,19 @@ struct move_op
 struct swap_op
 {
    template <class SourceIt, class DestinationIt>
-   void operator()(SourceIt source, DestinationIt dest)
+   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
    {  boost::adl_move_swap(*dest, *source);  }
 
    template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return boost::adl_move_swap_ranges(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return boost::adl_move_swap_ranges_backward(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
    {
       typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest2it));
       *dest2it = boost::move(*dest1it);
@@ -105,7 +105,7 @@ struct swap_op
    }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
-   void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
    {
       typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest3it));
       *dest3it = boost::move(*dest2it);

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/heap_sort.hpp

@@ -0,0 +1,111 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2018.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_DETAIL_HEAP_SORT_HPP
+#define BOOST_MOVE_DETAIL_HEAP_SORT_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/algo/detail/is_sorted.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost {  namespace movelib{
+
+template <class RandomAccessIterator, class Compare>
+class heap_sort_helper
+{
+   typedef typename boost::movelib::iterator_traits<RandomAccessIterator>::size_type  size_type;
+   typedef typename boost::movelib::iterator_traits<RandomAccessIterator>::value_type value_type;
+
+   static void adjust_heap(RandomAccessIterator first, size_type hole_index, size_type const len, value_type &value, Compare comp)
+   {
+      size_type const top_index = hole_index;
+      size_type second_child = 2 * (hole_index + 1);
+
+      while (second_child < len) {
+         if (comp(*(first + second_child), *(first + (second_child - 1))))
+            second_child--;
+         *(first + hole_index) = boost::move(*(first + second_child));
+         hole_index = second_child;
+         second_child = 2 * (second_child + 1);
+      }
+      if (second_child == len) {
+         *(first + hole_index) = boost::move(*(first + (second_child - 1)));
+         hole_index = second_child - 1;
+      }
+
+      {  //push_heap-like ending
+         size_type parent = (hole_index - 1) / 2;
+         while (hole_index > top_index && comp(*(first + parent), value)) {
+            *(first + hole_index) = boost::move(*(first + parent));
+            hole_index = parent;
+            parent = (hole_index - 1) / 2;
+         }    
+         *(first + hole_index) = boost::move(value);
+      }
+   }
+
+   static void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+   {
+      size_type const len = size_type(last - first);
+      if (len > 1) {
+         size_type parent = len/2u - 1u;
+
+         do {
+            value_type v(boost::move(*(first + parent)));
+            adjust_heap(first, parent, len, v, comp);
+         }while (parent--);
+      }
+   }
+
+   static void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+   {
+      size_type len = size_type(last - first);
+      while (len > 1) {
+         //move biggest to the safe zone
+         --last;
+         value_type v(boost::move(*last));
+         *last = boost::move(*first);
+         adjust_heap(first, size_type(0), --len, v, comp);
+      }
+   }
+
+   public:
+   static void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+   {
+      make_heap(first, last, comp);
+      sort_heap(first, last, comp);
+      BOOST_ASSERT(boost::movelib::is_sorted(first, last, comp));
+   }
+};
+
+template <class RandomAccessIterator, class Compare>
+BOOST_MOVE_FORCEINLINE void heap_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+{
+   heap_sort_helper<RandomAccessIterator, Compare>::sort(first, last, comp);
+}
+
+}} //namespace boost {  namespace movelib{
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_DETAIL_HEAP_SORT_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/insertion_sort.hpp

@@ -31,6 +31,7 @@
 #include <boost/move/detail/destruct_n.hpp>
 #include <boost/move/algo/detail/basic_op.hpp>
 #include <boost/move/detail/placement_new.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 
 namespace boost {  namespace movelib{
 
@@ -91,30 +92,30 @@ void insertion_sort(BirdirectionalIterator first, BirdirectionalIterator last, C
    }
 }
 
-template <class Compare, class BirdirectionalIterator>
+template <class Compare, class BirdirectionalIterator, class BirdirectionalRawIterator>
 void insertion_sort_uninitialized_copy
    (BirdirectionalIterator first1, BirdirectionalIterator const last1
-   , typename iterator_traits<BirdirectionalIterator>::value_type* const first2
+   , BirdirectionalRawIterator const first2
    , Compare comp)
 {
    typedef typename iterator_traits<BirdirectionalIterator>::value_type value_type;
    if (first1 != last1){
-      value_type* last2 = first2;
-      ::new(last2, boost_move_new_t()) value_type(move(*first1));
-      destruct_n<value_type> d(first2);
+      BirdirectionalRawIterator last2 = first2;
+      ::new((iterator_to_raw_pointer)(last2), boost_move_new_t()) value_type(::boost::move(*first1));
+      destruct_n<value_type, BirdirectionalRawIterator> d(first2);
       d.incr();
       for (++last2; ++first1 != last1; ++last2){
-         value_type* j2 = last2;
-         value_type* k2 = j2;
+         BirdirectionalRawIterator j2 = last2;
+         BirdirectionalRawIterator k2 = j2;
          if (comp(*first1, *--k2)){
-            ::new(j2, boost_move_new_t()) value_type(move(*k2));
+            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(::boost::move(*k2));
             d.incr();
             for (--j2; k2 != first2 && comp(*first1, *--k2); --j2)
-               *j2 = move(*k2);
-            *j2 = move(*first1);
+               *j2 = ::boost::move(*k2);
+            *j2 = ::boost::move(*first1);
          }
          else{
-            ::new(j2, boost_move_new_t()) value_type(move(*first1));
+            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(::boost::move(*first1));
             d.incr();
          }
       }

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/is_sorted.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_MOVE_DETAIL_IS_SORTED_HPP
+#define BOOST_MOVE_DETAIL_IS_SORTED_HPP
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2018. 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_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+namespace boost {
+namespace movelib {
+
+template<class ForwardIt, class Pred>
+bool is_sorted(ForwardIt const first, ForwardIt last, Pred pred)
+{
+   if (first != last) {
+      ForwardIt next = first, cur(first);
+      while (++next != last) {
+         if (pred(*next, *cur))
+            return false;
+         cur = next;
+      }
+   }
+   return true;
+}
+
+template<class ForwardIt, class Pred>
+bool is_sorted_and_unique(ForwardIt first, ForwardIt last, Pred pred)
+{
+   if (first != last) {
+      ForwardIt next = first;
+      while (++next != last) {
+         if (!pred(*first, *next))
+            return false;
+         first = next;
+      }
+   }
+   return true;
+}
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#endif   //BOOST_MOVE_DETAIL_IS_SORTED_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/merge.hpp

@@ -16,6 +16,8 @@
 #include <boost/move/algo/detail/basic_op.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/destruct_n.hpp>
+#include <boost/move/algo/predicate.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/assert.hpp>
 
 namespace boost {
@@ -181,9 +183,6 @@ void op_merge_left( RandIt buf_first
                            //and all elements from the second half are less)
       op(forward_t(), first1, last1, buf_first);
    }
-   else{
-      buf_first = buf_first;
-   }
 }
 
 // [buf_first, first1) -> buffer
@@ -257,84 +256,93 @@ void swap_merge_right
    op_merge_right(first1, last1, last2, buf_last, comp, swap_op());
 }
 
-template <class BidirIt, class Distance, class Compare>
+//Complexity: min(len1,len2)^2 + max(len1,len2)
+template<class RandIt, class Compare>
+void merge_bufferless_ON2(RandIt first, RandIt middle, RandIt last, Compare comp)
+{
+   if((middle - first) < (last - middle)){
+      while(first != middle){
+         RandIt const old_last1 = middle;
+         middle = boost::movelib::lower_bound(middle, last, *first, comp);
+         first = rotate_gcd(first, old_last1, middle);
+         if(middle == last){
+            break;
+         }
+         do{
+            ++first;
+         } while(first != middle && !comp(*middle, *first));
+      }
+   }
+   else{
+      while(middle != last){
+         RandIt p = boost::movelib::upper_bound(first, middle, last[-1], comp);
+         last = rotate_gcd(p, middle, last);
+         middle = p;
+         if(middle == first){
+            break;
+         }
+         --p;
+         do{
+            --last;
+         } while(middle != last && !comp(last[-1], *p));
+      }
+   }
+}
+
+static const std::size_t MergeBufferlessONLogNRotationThreshold = 32;
+
+template <class RandIt, class Distance, class Compare>
 void merge_bufferless_ONlogN_recursive
-   (BidirIt first, BidirIt middle, BidirIt last, Distance len1, Distance len2, Compare comp)
+   (RandIt first, RandIt middle, RandIt last, Distance len1, Distance len2, Compare comp)
 {
-   typedef typename iterator_traits<BidirIt>::size_type size_type;
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+
    while(1) {
-      //#define MERGE_BUFFERLESS_RECURSIVE_OPT
-      #ifndef MERGE_BUFFERLESS_RECURSIVE_OPT
-      if (len2  == 0) {
+      //trivial cases
+      if (!len2) {
          return;
       }
-
-      if (!len1) {
+      else if (!len1) {
          return;
       }
-
-      if ((len1 | len2) == 1) {
+      else if (size_type(len1 | len2) == 1u) {
          if (comp(*middle, *first))
             adl_move_swap(*first, *middle);  
          return;
       }
-      #else
-      if (len2  == 0) {
+      else if(size_type(len1+len2) < MergeBufferlessONLogNRotationThreshold){
+         merge_bufferless_ON2(first, middle, last, comp);
          return;
       }
 
-      if (!len1) {
-         return;
-      }
-      BidirIt middle_prev = middle; --middle_prev;
-      if(!comp(*middle, *middle_prev))
-         return;
-
-      while(true) {
-         if (comp(*middle, *first))
-            break;
-         ++first;
-         if(--len1 == 1)
-            break;
-      }
-
-      if (len1 == 1 && len2 == 1) {
-         //comp(*middle, *first) == true already tested in the loop
-         adl_move_swap(*first, *middle);  
-         return;
-      }
-      #endif
-
-      BidirIt first_cut = first;
-      BidirIt second_cut = middle;
+      RandIt first_cut = first;
+      RandIt second_cut = middle;
       Distance len11 = 0;
       Distance len22 = 0;
       if (len1 > len2) {
          len11 = len1 / 2;
          first_cut +=  len11;
-         second_cut = lower_bound(middle, last, *first_cut, comp);
+         second_cut = boost::movelib::lower_bound(middle, last, *first_cut, comp);
          len22 = size_type(second_cut - middle);
       }
       else {
          len22 = len2 / 2;
          second_cut += len22;
-         first_cut = upper_bound(first, middle, *second_cut, comp);
+         first_cut = boost::movelib::upper_bound(first, middle, *second_cut, comp);
          len11 = size_type(first_cut - first);
       }
-      BidirIt new_middle = rotate_gcd(first_cut, middle, second_cut);
+      RandIt new_middle = rotate_gcd(first_cut, middle, second_cut);
 
       //Avoid one recursive call doing a manual tail call elimination on the biggest range
       const Distance len_internal = len11+len22;
       if( len_internal < (len1 + len2 - len_internal) ) {
          merge_bufferless_ONlogN_recursive(first,      first_cut,  new_middle, len11,        len22,        comp);
-         //merge_bufferless_recursive(new_middle, second_cut, last,       len1 - len11, len2 - len22, comp);
          first = new_middle;
          middle = second_cut;
          len1 -= len11;
          len2 -= len22;
       }
       else {
-         //merge_bufferless_recursive(first,      first_cut,  new_middle, len11,        len22,        comp);
          merge_bufferless_ONlogN_recursive(new_middle, second_cut, last,       len1 - len11, len2 - len22, comp);
          middle = first_cut;
          last = new_middle;
@@ -345,50 +353,17 @@ void merge_bufferless_ONlogN_recursive
 }
 
 //Complexity: NlogN
-template<class BidirIt, class Compare>
-void merge_bufferless_ONlogN(BidirIt first, BidirIt middle, BidirIt last, Compare comp)
+template<class RandIt, class Compare>
+void merge_bufferless_ONlogN(RandIt first, RandIt middle, RandIt last, Compare comp)
 {
    merge_bufferless_ONlogN_recursive
       (first, middle, last, middle - first, last - middle, comp); 
 }
 
-//Complexity: min(len1,len2)^2 + max(len1,len2)
-template<class RandIt, class Compare>
-void merge_bufferless_ON2(RandIt first, RandIt middle, RandIt last, Compare comp)
-{
-   if((middle - first) < (last - middle)){
-      while(first != middle){
-         RandIt const old_last1 = middle;
-         middle = lower_bound(middle, last, *first, comp);
-         first = rotate_gcd(first, old_last1, middle);
-         if(middle == last){
-            break;
-         }
-         do{
-            ++first;
-         } while(first != middle && !comp(*middle, *first));
-      }
-   }
-   else{
-      while(middle != last){
-         RandIt p = upper_bound(first, middle, last[-1], comp);
-         last = rotate_gcd(p, middle, last);
-         middle = p;
-         if(middle == first){
-            break;
-         }
-         --p;
-         do{
-            --last;
-         } while(middle != last && !comp(last[-1], *p));
-      }
-   }
-}
-
 template<class RandIt, class Compare>
 void merge_bufferless(RandIt first, RandIt middle, RandIt last, Compare comp)
 {
-   //#define BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
+   #define BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
    #ifdef BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
    merge_bufferless_ONlogN(first, middle, last, comp);
    #else
@@ -396,65 +371,6 @@ void merge_bufferless(RandIt first, RandIt middle, RandIt last, Compare comp)
    #endif   //BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
 }
 
-template<class Comp>
-struct antistable
-{
-   explicit antistable(Comp &comp)
-      : m_comp(comp)
-   {}
-
-   template<class U, class V>
-   bool operator()(const U &u, const V & v)
-   {  return !m_comp(v, u);  }
-
-   private:
-   antistable & operator=(const antistable &);
-   Comp &m_comp;
-};
-
-template <class Comp>
-class negate
-{
-   public:
-   negate()
-   {}
-
-   explicit negate(Comp comp)
-      : m_comp(comp)
-   {}
-
-   template <class T1, class T2>
-   bool operator()(const T1& l, const T2& r)
-   {
-      return !m_comp(l, r);
-   }
-
-   private:
-   Comp m_comp;
-};
-
-
-template <class Comp>
-class inverse
-{
-   public:
-   inverse()
-   {}
-
-   explicit inverse(Comp comp)
-      : m_comp(comp)
-   {}
-
-   template <class T1, class T2>
-   bool operator()(const T1& l, const T2& r)
-   {
-      return m_comp(r, l);
-   }
-
-   private:
-   Comp m_comp;
-};
-
 // [r_first, r_last) are already in the right part of the destination range.
 template <class Compare, class InputIterator, class InputOutIterator, class Op>
 void op_merge_with_right_placed
@@ -557,12 +473,12 @@ void uninitialized_merge_with_right_placed
    typedef typename iterator_traits<InputOutIterator>::value_type value_type;
    InputOutIterator const original_r_first = r_first;
 
-   destruct_n<value_type> d(&*dest_first);
+   destruct_n<value_type, InputOutIterator> d(dest_first);
 
    while ( first != last && dest_first != original_r_first ) {
       if (r_first == r_last) {
          for(; dest_first != original_r_first; ++dest_first, ++first){
-            ::new(&*dest_first) value_type(::boost::move(*first));
+            ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
             d.incr();
          }
          d.release();
@@ -572,12 +488,12 @@ void uninitialized_merge_with_right_placed
          return;
       }
       else if (comp(*r_first, *first)) {
-         ::new(&*dest_first) value_type(::boost::move(*r_first));
+         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*r_first));
          d.incr();
          ++r_first;
       }
       else {
-         ::new(&*dest_first) value_type(::boost::move(*first));
+         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
          d.incr();
          ++first;
       }