passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/iterator/interoperable.hpp

@@ -5,43 +5,33 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_INTEROPERABLE_23022003THW_HPP
-# define BOOST_INTEROPERABLE_23022003THW_HPP
+#define BOOST_INTEROPERABLE_23022003THW_HPP
 
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/or.hpp>
-
-# include <boost/type_traits/is_convertible.hpp>
-
-# include <boost/iterator/detail/config_def.hpp> // must appear last
+#include <type_traits>
+#include <boost/iterator/detail/type_traits/disjunction.hpp>
 
 namespace boost {
 namespace iterators {
 
-  //
-  // Meta function that determines whether two
-  // iterator types are considered interoperable.
-  //
-  // Two iterator types A,B are considered interoperable if either
-  // A is convertible to B or vice versa.
-  // This interoperability definition is in sync with the
-  // standards requirements on constant/mutable container
-  // iterators (23.1 [lib.container.requirements]).
-  //
-  // For compilers that don't support is_convertible
-  // is_interoperable gives false positives. See comments
-  // on operator implementation for consequences.
-  //
-  template <typename A, typename B>
-  struct is_interoperable
-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-    : mpl::true_
-# else
-    : mpl::or_<
-          is_convertible< A, B >
-        , is_convertible< B, A > >
-# endif
-  {
-  };
+//
+// Meta function that determines whether two
+// iterator types are considered interoperable.
+//
+// Two iterator types A,B are considered interoperable if either
+// A is convertible to B or vice versa.
+// This interoperability definition is in sync with the
+// standards requirements on constant/mutable container
+// iterators (23.1 [lib.container.requirements]).
+//
+// For compilers that don't support is_convertible
+// is_interoperable gives false positives. See comments
+// on operator implementation for consequences.
+//
+template< typename A, typename B >
+struct is_interoperable :
+    public detail::disjunction< std::is_convertible< A, B >, std::is_convertible< B, A > >
+{
+};
 
 } // namespace iterators
 
@@ -49,6 +39,4 @@ using iterators::is_interoperable;
 
 } // namespace boost
 
-# include <boost/iterator/detail/config_undef.hpp>
-
 #endif // BOOST_INTEROPERABLE_23022003THW_HPP

data/src/cxx_supportlib/vendor-modified/boost/iterator/is_iterator.hpp

@@ -16,15 +16,15 @@
 
 #include <cstddef>
 #include <boost/config.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/negation.hpp>
-#include <boost/type_traits/conjunction.hpp>
 #include <boost/type_traits/is_complete.hpp>
-#include <boost/type_traits/is_function.hpp>
+#include <boost/iterator/detail/type_traits/conjunction.hpp>
+#include <boost/iterator/detail/type_traits/negation.hpp>
 #if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
 #include <iterator>
 #endif
 
+#include <type_traits>
+
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
 #endif
@@ -59,56 +59,56 @@ no_type check(...);
 
 template< typename T >
 struct is_iterator_impl :
-    public boost::integral_constant<
+    public std::integral_constant<
         bool,
-        sizeof(has_iterator_category_detail::check< T >(0)) == sizeof(has_iterator_category_detail::yes_type)
+        sizeof(has_iterator_category_detail::check<T>(0)) == sizeof(has_iterator_category_detail::yes_type)
     >
 {
 };
 
 template< typename T >
 struct is_iterator_impl< T* > :
-    public boost::conjunction<
-        boost::is_complete< T >,
-        boost::negation< boost::is_function< T > >
+    public conjunction<
+        boost::is_complete<T>,
+        negation< std::is_function< T > >
     >::type
 {
 };
 
 template< typename T, typename U >
 struct is_iterator_impl< T U::* > :
-    public boost::false_type
+    public std::false_type
 {
 };
 
 template< typename T >
-struct is_iterator_impl< T& > :
-    public boost::false_type
+struct is_iterator_impl<T&> :
+    public std::false_type
 {
 };
 
 template< typename T, std::size_t N >
 struct is_iterator_impl< T[N] > :
-    public boost::false_type
+    public std::false_type
 {
 };
 
 #if !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)
 template< typename T >
 struct is_iterator_impl< T[] > :
-    public boost::false_type
+    public std::false_type
 {
 };
 
 template< >
 struct is_iterator_impl< void > :
-    public boost::false_type
+    public std::false_type
 {
 };
 
 template< >
 struct is_iterator_impl< void* > :
-    public boost::false_type
+    public std::false_type
 {
 };
 #endif // !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)

data/src/cxx_supportlib/vendor-modified/boost/iterator/iterator_adaptor.hpp

@@ -7,349 +7,202 @@
 #ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
-#include <boost/static_assert.hpp>
+#include <type_traits>
 
 #include <boost/core/use_default.hpp>
 
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/iterator/enable_if_convertible.hpp> // for backward compatibility; remove once downstream users are updated
+#include <boost/iterator/detail/eval_if_default.hpp>
+
+#include <boost/iterator/detail/config_def.hpp>
 
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/or.hpp>
+namespace boost {
+namespace iterators {
 
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_convertible.hpp>
+// Used as a default template argument internally, merely to
+// indicate "use the default", this can also be passed by users
+// explicitly in order to specify that the default should be used.
+using boost::use_default;
+
+namespace detail {
+
+// A metafunction which computes an iterator_adaptor's base class,
+// a specialization of iterator_facade.
+template<
+    typename Derived,
+    typename Base,
+    typename Value,
+    typename Traversal,
+    typename Reference,
+    typename Difference
+>
+using iterator_adaptor_base_t = iterator_facade<
+    Derived,
 
 #ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-# include <boost/type_traits/remove_reference.hpp>
+    detail::eval_if_default_t<
+        Value,
+        detail::eval_if_default<
+            Reference,
+            iterator_value< Base >,
+            std::remove_reference< Reference >
+        >
+    >,
+#else
+    detail::eval_if_default_t<
+        Value,
+        iterator_value< Base >
+    >,
 #endif
 
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/iterator/detail/config_def.hpp>
+    detail::eval_if_default_t<
+        Traversal,
+        iterator_traversal< Base >
+    >,
+
+    detail::eval_if_default_t<
+        Reference,
+        detail::eval_if_default<
+            Value,
+            iterator_reference< Base >,
+            std::add_lvalue_reference< Value >
+        >
+    >,
 
-#include <boost/iterator/iterator_traits.hpp>
+    detail::eval_if_default_t<
+        Difference,
+        iterator_difference< Base >
+    >
+>;
+
+} // namespace detail
+
+//
+// Iterator Adaptor
+//
+// The parameter ordering changed slightly with respect to former
+// versions of iterator_adaptor The idea is that when the user needs
+// to fiddle with the reference type it is highly likely that the
+// iterator category has to be adjusted as well.  Any of the
+// following four template arguments may be omitted or explicitly
+// replaced by use_default.
+//
+//   Value - if supplied, the value_type of the resulting iterator, unless
+//      const. If const, a conforming compiler strips constness for the
+//      value_type. If not supplied, iterator_traits<Base>::value_type is used
+//
+//   Category - the traversal category of the resulting iterator. If not
+//      supplied, iterator_traversal<Base>::type is used.
+//
+//   Reference - the reference type of the resulting iterator, and in
+//      particular, the result type of operator*(). If not supplied but
+//      Value is supplied, Value& is used. Otherwise
+//      iterator_traits<Base>::reference is used.
+//
+//   Difference - the difference_type of the resulting iterator. If not
+//      supplied, iterator_traits<Base>::difference_type is used.
+//
+template<
+    typename Derived,
+    typename Base,
+    typename Value        = use_default,
+    typename Traversal    = use_default,
+    typename Reference    = use_default,
+    typename Difference   = use_default
+>
+class iterator_adaptor :
+    public detail::iterator_adaptor_base_t<
+        Derived, Base, Value, Traversal, Reference, Difference
+    >
+{
+    friend class iterator_core_access;
 
-namespace boost {
-namespace iterators {
+protected:
+    using super_t = detail::iterator_adaptor_base_t<
+        Derived, Base, Value, Traversal, Reference, Difference
+    >;
 
-  // Used as a default template argument internally, merely to
-  // indicate "use the default", this can also be passed by users
-  // explicitly in order to specify that the default should be used.
-  using boost::use_default;
+public:
+    using base_type = Base;
 
-} // namespace iterators
+    iterator_adaptor() = default;
 
-// the incompleteness of use_default causes massive problems for
-// is_convertible (naturally).  This workaround is fortunately not
-// needed for vc6/vc7.
-template<class To>
-struct is_convertible<use_default,To>
-  : mpl::false_ {};
+    explicit iterator_adaptor(Base const& iter) :
+        m_iterator(iter)
+    {
+    }
 
-namespace iterators {
+    base_type const& base() const { return m_iterator; }
 
-  namespace detail
-  {
+protected:
+    // for convenience in derived classes
+    using iterator_adaptor_ = iterator_adaptor< Derived, Base, Value, Traversal, Reference, Difference >;
 
     //
-    // Result type used in enable_if_convertible meta function.
-    // This can be an incomplete type, as only pointers to
-    // enable_if_convertible< ... >::type are used.
-    // We could have used void for this, but conversion to
-    // void* is just to easy.
+    // lvalue access to the Base object for Derived
     //
-    struct enable_type;
-  }
-
-
-  //
-  // enable_if for use in adapted iterators constructors.
-  //
-  // In order to provide interoperability between adapted constant and
-  // mutable iterators, adapted iterators will usually provide templated
-  // conversion constructors of the following form
-  //
-  // template <class BaseIterator>
-  // class adapted_iterator :
-  //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
-  // {
-  // public:
-  //
-  //   ...
-  //
-  //   template <class OtherIterator>
-  //   adapted_iterator(
-  //       OtherIterator const& it
-  //     , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0);
-  //
-  //   ...
-  // };
-  //
-  // enable_if_convertible is used to remove those overloads from the overload
-  // set that cannot be instantiated. For all practical purposes only overloads
-  // for constant/mutable interaction will remain. This has the advantage that
-  // meta functions like boost::is_convertible do not return false positives,
-  // as they can only look at the signature of the conversion constructor
-  // and not at the actual instantiation.
-  //
-  // enable_if_interoperable can be safely used in user code. It falls back to
-  // always enabled for compilers that don't support enable_if or is_convertible.
-  // There is no need for compiler specific workarounds in user code.
-  //
-  // The operators implementation relies on boost::is_convertible not returning
-  // false positives for user/library defined iterator types. See comments
-  // on operator implementation for consequences.
-  //
-#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-
-  template <class From, class To>
-  struct enable_if_convertible
-  {
-      typedef boost::iterators::detail::enable_type type;
-  };
-
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
-
-  // For some reason vc7.1 needs us to "cut off" instantiation
-  // of is_convertible in a few cases.
-  template<typename From, typename To>
-  struct enable_if_convertible
-    : iterators::enable_if<
-        mpl::or_<
-            is_same<From,To>
-          , is_convertible<From, To>
-        >
-      , boost::iterators::detail::enable_type
-    >
-  {};
-
-#  else
-
-  template<typename From, typename To>
-  struct enable_if_convertible
-    : iterators::enable_if<
-          is_convertible<From, To>
-        , boost::iterators::detail::enable_type
-      >
-  {};
-
-# endif
-
-  //
-  // Default template argument handling for iterator_adaptor
-  //
-  namespace detail
-  {
-    // If T is use_default, return the result of invoking
-    // DefaultNullaryFn, otherwise return T.
-    template <class T, class DefaultNullaryFn>
-    struct ia_dflt_help
-      : mpl::eval_if<
-            is_same<T, use_default>
-          , DefaultNullaryFn
-          , mpl::identity<T>
-        >
+    Base& base_reference() { return m_iterator; }
+    Base const& base_reference() const { return m_iterator; }
+
+private:
+    //
+    // Core iterator interface for iterator_facade.  This is private
+    // to prevent temptation for Derived classes to use it, which
+    // will often result in an error.  Derived classes should use
+    // base_reference(), above, to get direct access to m_iterator.
+    //
+    typename super_t::reference dereference() const { return *m_iterator; }
+
+    template< typename OtherDerived, typename OtherIterator, typename V, typename C, typename R, typename D >
+    bool equal(iterator_adaptor< OtherDerived, OtherIterator, V, C, R, D > const& x) const
     {
-    };
-
-    // A metafunction which computes an iterator_adaptor's base class,
-    // a specialization of iterator_facade.
-    template <
-        class Derived
-      , class Base
-      , class Value
-      , class Traversal
-      , class Reference
-      , class Difference
-    >
-    struct iterator_adaptor_base
+        // Maybe readd with same_distance
+        //           BOOST_STATIC_ASSERT(
+        //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
+        //               );
+        return m_iterator == x.base();
+    }
+
+    using my_traversal = typename iterator_category_to_traversal< typename super_t::iterator_category >::type;
+
+    void advance(typename super_t::difference_type n)
     {
-        typedef iterator_facade<
-            Derived
-
-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          , typename boost::iterators::detail::ia_dflt_help<
-                Value
-              , mpl::eval_if<
-                    is_same<Reference,use_default>
-                  , iterator_value<Base>
-                  , remove_reference<Reference>
-                >
-            >::type
-# else
-          , typename boost::iterators::detail::ia_dflt_help<
-                Value, iterator_value<Base>
-            >::type
-# endif
-
-          , typename boost::iterators::detail::ia_dflt_help<
-                Traversal
-              , iterator_traversal<Base>
-            >::type
-
-          , typename boost::iterators::detail::ia_dflt_help<
-                Reference
-              , mpl::eval_if<
-                    is_same<Value,use_default>
-                  , iterator_reference<Base>
-                  , add_reference<Value>
-                >
-            >::type
-
-          , typename boost::iterators::detail::ia_dflt_help<
-                Difference, iterator_difference<Base>
-            >::type
-        >
-        type;
-    };
+        static_assert(detail::is_traversal_at_least< my_traversal, random_access_traversal_tag >::value,
+            "Iterator must support random access traversal.");
+        m_iterator += n;
+    }
+
+    void increment() { ++m_iterator; }
 
-    // workaround for aC++ CR JAGaf33512
-    template <class Tr1, class Tr2>
-    inline void iterator_adaptor_assert_traversal ()
+    void decrement()
     {
-      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
+        static_assert(detail::is_traversal_at_least< my_traversal, bidirectional_traversal_tag >::value,
+            "Iterator must support bidirectional traversal.");
+        --m_iterator;
     }
-  }
-
-  //
-  // Iterator Adaptor
-  //
-  // The parameter ordering changed slightly with respect to former
-  // versions of iterator_adaptor The idea is that when the user needs
-  // to fiddle with the reference type it is highly likely that the
-  // iterator category has to be adjusted as well.  Any of the
-  // following four template arguments may be ommitted or explicitly
-  // replaced by use_default.
-  //
-  //   Value - if supplied, the value_type of the resulting iterator, unless
-  //      const. If const, a conforming compiler strips constness for the
-  //      value_type. If not supplied, iterator_traits<Base>::value_type is used
-  //
-  //   Category - the traversal category of the resulting iterator. If not
-  //      supplied, iterator_traversal<Base>::type is used.
-  //
-  //   Reference - the reference type of the resulting iterator, and in
-  //      particular, the result type of operator*(). If not supplied but
-  //      Value is supplied, Value& is used. Otherwise
-  //      iterator_traits<Base>::reference is used.
-  //
-  //   Difference - the difference_type of the resulting iterator. If not
-  //      supplied, iterator_traits<Base>::difference_type is used.
-  //
-  template <
-      class Derived
-    , class Base
-    , class Value        = use_default
-    , class Traversal    = use_default
-    , class Reference    = use_default
-    , class Difference   = use_default
-  >
-  class iterator_adaptor
-    : public boost::iterators::detail::iterator_adaptor_base<
-        Derived, Base, Value, Traversal, Reference, Difference
-      >::type
-  {
-      friend class iterator_core_access;
-
-   protected:
-      typedef typename boost::iterators::detail::iterator_adaptor_base<
-          Derived, Base, Value, Traversal, Reference, Difference
-      >::type super_t;
-   public:
-      iterator_adaptor() {}
-
-      explicit iterator_adaptor(Base const &iter)
-          : m_iterator(iter)
-      {
-      }
-
-      typedef Base base_type;
-
-      Base const& base() const
-        { return m_iterator; }
-
-   protected:
-      // for convenience in derived classes
-      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
-
-      //
-      // lvalue access to the Base object for Derived
-      //
-      Base const& base_reference() const
-        { return m_iterator; }
-
-      Base& base_reference()
-        { return m_iterator; }
-
-   private:
-      //
-      // Core iterator interface for iterator_facade.  This is private
-      // to prevent temptation for Derived classes to use it, which
-      // will often result in an error.  Derived classes should use
-      // base_reference(), above, to get direct access to m_iterator.
-      //
-      typename super_t::reference dereference() const
-        { return *m_iterator; }
-
-      template <
-      class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >
-      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
-      {
+
+    template< typename OtherDerived, typename OtherIterator, typename V, typename C, typename R, typename D >
+    typename super_t::difference_type distance_to(iterator_adaptor< OtherDerived, OtherIterator, V, C, R, D > const& y) const
+    {
+        static_assert(detail::is_traversal_at_least< my_traversal, random_access_traversal_tag >::value,
+            "Super iterator must support random access traversal.");
         // Maybe readd with same_distance
         //           BOOST_STATIC_ASSERT(
         //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
         //               );
-          return m_iterator == x.base();
-      }
-
-      typedef typename iterator_category_to_traversal<
-          typename super_t::iterator_category
-      >::type my_traversal;
-
-# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
-      boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
-
-      void advance(typename super_t::difference_type n)
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
-          m_iterator += n;
-      }
-
-      void increment() { ++m_iterator; }
-
-      void decrement()
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
-           --m_iterator;
-      }
-
-      template <
-          class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >
-      typename super_t::difference_type distance_to(
-          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
-          // Maybe readd with same_distance
-          //           BOOST_STATIC_ASSERT(
-          //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
-          //               );
-          return y.base() - m_iterator;
-      }
-
-# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
-
-   private: // data members
-      Base m_iterator;
-  };
+        return y.base() - m_iterator;
+    }
+
+private: // data members
+    Base m_iterator;
+};
 
 } // namespace iterators
 
 using iterators::iterator_adaptor;
-using iterators::enable_if_convertible;
 
 } // namespace boost