update boost

2023-11-24 12:56:13 -06:00
parent cfc99971af
commit 19d727037a
9260 changed files with 849256 additions and 299957 deletions
--- a/linx64/include/boost/iterator/advance.hpp
+++ b/linx64/include/boost/iterator/advance.hpp
@@ -8,6 +8,7 @@
 #define BOOST_ITERATOR_ADVANCE_HPP

 #include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
 #include <boost/iterator/iterator_categories.hpp>

 namespace boost {
@@ -28,6 +29,12 @@ namespace iterators {
            }
        }

+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, >= 40600)
+// type-limits warning issued below when n is an unsigned integral
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
+
        template <typename BidirectionalIterator, typename Distance>
        inline BOOST_CXX14_CONSTEXPR void
        advance_impl(
@@ -50,6 +57,10 @@ namespace iterators {
            }
        }

+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, >= 40600)
+#pragma GCC diagnostic pop
+#endif
+
        template <typename RandomAccessIterator, typename Distance>
        inline BOOST_CXX14_CONSTEXPR void
        advance_impl(
--- a/linx64/include/boost/iterator/counting_iterator.hpp
+++ b/linx64/include/boost/iterator/counting_iterator.hpp
@@ -5,12 +5,21 @@
 #ifndef COUNTING_ITERATOR_DWA200348_HPP
 # define COUNTING_ITERATOR_DWA200348_HPP

-# include <boost/iterator/iterator_adaptor.hpp>
+# include <boost/config.hpp>
+# include <boost/static_assert.hpp>
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+# include <limits>
+# elif !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
+# include <boost/type_traits/is_convertible.hpp>
+# else
+# include <boost/type_traits/is_arithmetic.hpp>
+# endif
+# include <boost/type_traits/is_integral.hpp>
+# include <boost/type_traits/type_identity.hpp>
+# include <boost/type_traits/conditional.hpp>
+# include <boost/type_traits/integral_constant.hpp>
 # include <boost/detail/numeric_traits.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/identity.hpp>
-# include <boost/mpl/eval_if.hpp>
+# include <boost/iterator/iterator_adaptor.hpp>

 namespace boost {
 namespace iterators {
@@ -38,14 +47,14 @@ namespace detail

 # else

-#  if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#  if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
      BOOST_STATIC_CONSTANT(
          bool, value = (
              boost::is_convertible<int,T>::value
           && boost::is_convertible<T,int>::value
      ));
 #  else
-    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
+      BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
 #  endif

 # endif
@@ -53,23 +62,33 @@ namespace detail

  template <class T>
  struct is_numeric
-    : mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)>
+    : boost::integral_constant<bool, ::boost::iterators::detail::is_numeric_impl<T>::value>
  {};

 #  if defined(BOOST_HAS_LONG_LONG)
  template <>
-  struct is_numeric< ::boost::long_long_type>
-    : mpl::true_ {};
+  struct is_numeric<boost::long_long_type>
+    : boost::true_type {};

  template <>
-  struct is_numeric< ::boost::ulong_long_type>
-    : mpl::true_ {};
+  struct is_numeric<boost::ulong_long_type>
+    : boost::true_type {};
+#  endif
+
+#  if defined(BOOST_HAS_INT128)
+  template <>
+  struct is_numeric<boost::int128_type>
+    : boost::true_type {};
+
+  template <>
+  struct is_numeric<boost::uint128_type>
+    : boost::true_type {};
 #  endif

  // Some compilers fail to have a numeric_limits specialization
  template <>
  struct is_numeric<wchar_t>
-    : mpl::true_ {};
+    : true_type {};

  template <class T>
  struct numeric_difference
@@ -77,27 +96,40 @@ namespace detail
      typedef typename boost::detail::numeric_traits<T>::difference_type type;
  };

-  BOOST_STATIC_ASSERT(is_numeric<int>::value);
+#  if defined(BOOST_HAS_INT128)
+  // std::numeric_limits, which is used by numeric_traits, is not specialized for __int128 in some standard libraries
+  template <>
+  struct numeric_difference<boost::int128_type>
+  {
+      typedef boost::int128_type type;
+  };
+
+  template <>
+  struct numeric_difference<boost::uint128_type>
+  {
+      typedef boost::int128_type type;
+  };
+#  endif

  template <class Incrementable, class CategoryOrTraversal, class Difference>
  struct counting_iterator_base
  {
      typedef typename detail::ia_dflt_help<
          CategoryOrTraversal
-        , mpl::eval_if<
-              is_numeric<Incrementable>
-            , mpl::identity<random_access_traversal_tag>
+        , typename boost::conditional<
+              is_numeric<Incrementable>::value
+            , boost::type_identity<random_access_traversal_tag>
            , iterator_traversal<Incrementable>
-          >
+          >::type
      >::type traversal;

      typedef typename detail::ia_dflt_help<
          Difference
-        , mpl::eval_if<
-              is_numeric<Incrementable>
+        , typename boost::conditional<
+              is_numeric<Incrementable>::value
            , numeric_difference<Incrementable>
            , iterator_difference<Incrementable>
-          >
+          >::type
      >::type difference;

      typedef iterator_adaptor<
@@ -161,9 +193,9 @@ class counting_iterator
 public:
    typedef typename super_t::difference_type difference_type;

-    counting_iterator() { }
+    BOOST_DEFAULTED_FUNCTION(counting_iterator(), {})

-    counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}
+    BOOST_DEFAULTED_FUNCTION(counting_iterator(counting_iterator const& rhs), : super_t(rhs.base()) {})

    counting_iterator(Incrementable x)
      : super_t(x)
@@ -180,6 +212,8 @@ class counting_iterator
    {}
 # endif

+    BOOST_DEFAULTED_FUNCTION(counting_iterator& operator=(counting_iterator const& rhs), { *static_cast< super_t* >(this) = static_cast< super_t const& >(rhs); return *this; })
+
 private:

    typename super_t::reference dereference() const
@@ -191,13 +225,13 @@ class counting_iterator
    difference_type
    distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const
    {
-      typedef typename mpl::if_<
-          detail::is_numeric<Incrementable>
-        , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
-        , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
-      >::type d;
+        typedef typename boost::conditional<
+            detail::is_numeric<Incrementable>::value
+          , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
+          , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
+        >::type d;

-      return d::distance(this->base(), y.base());
+        return d::distance(this->base(), y.base());
    }
 };

@@ -206,8 +240,8 @@ template <class Incrementable>
 inline counting_iterator<Incrementable>
 make_counting_iterator(Incrementable x)
 {
-  typedef counting_iterator<Incrementable> result_t;
-  return result_t(x);
+    typedef counting_iterator<Incrementable> result_t;
+    return result_t(x);
 }

 } // namespace iterators
--- a/linx64/include/boost/iterator/detail/config_def.hpp
+++ b/linx64/include/boost/iterator/detail/config_def.hpp
@@ -18,16 +18,16 @@

 #ifdef BOOST_ITERATOR_CONFIG_DEF
 # error you have nested config_def #inclusion.
-#else 
+#else
 # define BOOST_ITERATOR_CONFIG_DEF
-#endif 
+#endif

 // We enable this always now.  Otherwise, the simple case in
 // libs/iterator/test/constant_iterator_arrow.cpp fails to compile
 // because the operator-> return is improperly deduced as a non-const
 // pointer.
 #if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
+    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x531))

 // Recall that in general, compilers without partial specialization
 // can't strip constness.  Consider counting_iterator, which normally
@@ -46,11 +46,11 @@

 #endif

-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x5A0))                      \
    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-    
+
 # define BOOST_NO_LVALUE_RETURN_DETECTION

 # if 0 // test code
@@ -79,7 +79,7 @@

  int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];
  int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];
-# endif 
+# endif

 #endif

@@ -88,7 +88,7 @@
 #endif

 #if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
 #  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:

 #  if 0 // test code
@@ -112,9 +112,9 @@

 #if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#endif 
+#endif

-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))

 // GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
 // operators in convertibility checks, causing premature errors.
@@ -123,6 +123,6 @@
 // instantiation stack backtrace.  They may be due in part to the fact
 // that it drops cv-qualification willy-nilly in templates.
 #  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
-# endif 
+# endif

 // no include guard; multiple inclusion intended
--- a/linx64/include/boost/iterator/detail/config_undef.hpp
+++ b/linx64/include/boost/iterator/detail/config_undef.hpp
@@ -21,4 +21,4 @@
 # undef BOOST_ITERATOR_CONFIG_DEF
 #else
 # error missing or nested #include config_def
-#endif 
+#endif
--- a/linx64/include/boost/iterator/detail/enable_if.hpp
+++ b/linx64/include/boost/iterator/detail/enable_if.hpp
@@ -7,10 +7,11 @@
 #ifndef BOOST_ENABLE_IF_23022003THW_HPP
 #define BOOST_ENABLE_IF_23022003THW_HPP

-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/identity.hpp>
-
+#include <boost/config.hpp>
 #include <boost/iterator/detail/config_def.hpp>
+#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE)
+#include <boost/type_traits/type_identity.hpp>
+#endif

 //
 // Boost iterators uses its own enable_if cause we need
@@ -48,7 +49,6 @@ namespace boost
      struct base
      {
 #ifdef BOOST_NO_SFINAE
-
        typedef T type;

        // This way to do it would give a nice error message containing
@@ -69,7 +69,7 @@ namespace boost
 # if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
      : enabled<(Cond::value)>::template base<Return>
 # else
-      : mpl::identity<Return>
+      : boost::type_identity<Return>
 # endif
    {
    };
--- a/linx64/include/boost/iterator/detail/facade_iterator_category.hpp
+++ b/linx64/include/boost/iterator/detail/facade_iterator_category.hpp
@@ -13,15 +13,14 @@
 # include <boost/mpl/if.hpp>
 # include <boost/mpl/eval_if.hpp>
 # include <boost/mpl/identity.hpp>
-# include <boost/mpl/assert.hpp>
+
+# include <boost/static_assert.hpp>

 # include <boost/type_traits/is_same.hpp>
 # include <boost/type_traits/is_const.hpp>
 # include <boost/type_traits/is_reference.hpp>
 # include <boost/type_traits/is_convertible.hpp>

-# include <boost/type_traits/is_same.hpp>
-
 # include <boost/iterator/detail/config_def.hpp> // try to keep this last

 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
@@ -139,17 +138,17 @@ struct iterator_category_with_traversal
    // Make sure this isn't used to build any categories where
    // convertibility to Traversal is redundant.  Should just use the
    // Category element in that case.
-    BOOST_MPL_ASSERT_NOT((
-        is_convertible<
+    BOOST_STATIC_ASSERT((
+        !is_convertible<
              typename iterator_category_to_traversal<Category>::type
            , Traversal
-          >));
+          >::value));

-    BOOST_MPL_ASSERT((is_iterator_category<Category>));
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
-    BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
+    BOOST_STATIC_ASSERT(is_iterator_category<Category>::value);
+    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
+    BOOST_STATIC_ASSERT(!is_iterator_traversal<Category>::value);
 #  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-    BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
+    BOOST_STATIC_ASSERT(is_iterator_traversal<Traversal>::value);
 #  endif
 };

@@ -158,7 +157,7 @@ struct iterator_category_with_traversal
 template <class Traversal, class ValueParam, class Reference>
 struct facade_iterator_category_impl
 {
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);

    typedef typename iterator_facade_default_category<
        Traversal,ValueParam,Reference
--- a/linx64/include/boost/iterator/filter_iterator.hpp
+++ b/linx64/include/boost/iterator/filter_iterator.hpp
@@ -12,6 +12,14 @@

 #include <boost/type_traits/is_class.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) static_cast< _type&& >(_value)
+#else
+#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) _value
+#endif

 namespace boost {
 namespace iterators {
@@ -54,13 +62,13 @@ namespace iterators {
      filter_iterator() { }

      filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator())
-          : super_t(x), m_predicate(f), m_end(end_)
+          : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f)), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
      {
          satisfy_predicate();
      }

      filter_iterator(Iterator x, Iterator end_ = Iterator())
-        : super_t(x), m_predicate(), m_end(end_)
+        : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
      {
        // Pro8 is a little too aggressive about instantiating the
        // body of this function.
@@ -111,7 +119,7 @@ namespace iterators {
  inline filter_iterator<Predicate,Iterator>
  make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
  {
-      return filter_iterator<Predicate,Iterator>(f,x,end);
+      return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f), BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
  }

  template <class Predicate, class Iterator>
@@ -123,7 +131,7 @@ namespace iterators {
      >::type x
    , Iterator end = Iterator())
  {
-      return filter_iterator<Predicate,Iterator>(x,end);
+      return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
  }

 } // namespace iterators
@@ -133,4 +141,6 @@ using iterators::make_filter_iterator;

 } // namespace boost

+#undef BOOST_ITERATOR_DETAIL_MOVE
+
 #endif // BOOST_FILTER_ITERATOR_23022003THW_HPP
--- a/linx64/include/boost/iterator/function_input_iterator.hpp
+++ b/linx64/include/boost/iterator/function_input_iterator.hpp
@@ -12,7 +12,7 @@
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/core/addressof.hpp>
-#include <boost/mpl/if.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/function_types/is_function_pointer.hpp>
 #include <boost/function_types/result_type.hpp>
 #include <boost/iterator/iterator_facade.hpp>
@@ -28,6 +28,9 @@ namespace boost {

 namespace iterators {

+    template <class Function, class Input>
+    class function_input_iterator;
+
    namespace impl {

        // Computes the return type of an lvalue-call with an empty argument,
@@ -38,7 +41,7 @@ namespace iterators {
        {
            typedef typename result_of<
 #ifdef BOOST_RESULT_OF_USE_TR1
-                typename mpl::if_<is_function<F>, F&, F>::type()
+                typename boost::conditional<is_function<F>::value, F&, F>::type()
 #else
                F&()
 #endif
@@ -46,21 +49,21 @@ namespace iterators {
        };

        template <class Function, class Input>
-        class function_input_iterator
-            : public iterator_facade<
-            function_input_iterator<Function, Input>,
-            typename result_of_nullary_lvalue_call<Function>::type,
-            single_pass_traversal_tag,
-            typename result_of_nullary_lvalue_call<Function>::type const &
+        class function_object_input_iterator :
+            public iterator_facade<
+                iterators::function_input_iterator<Function, Input>,
+                typename result_of_nullary_lvalue_call<Function>::type,
+                single_pass_traversal_tag,
+                typename result_of_nullary_lvalue_call<Function>::type const &
            >
        {
        public:
-            function_input_iterator() {}
-            function_input_iterator(Function & f_, Input state_ = Input())
+            function_object_input_iterator() {}
+            function_object_input_iterator(Function & f_, Input state_ = Input())
                : f(boost::addressof(f_)), state(state_) {}

            void increment() {
-                if(value)
+                if (value)
                    value = none;
                else
                    (*f)();
@@ -69,10 +72,12 @@ namespace iterators {

            typename result_of_nullary_lvalue_call<Function>::type const &
                dereference() const {
-                    return (value ? value : value = (*f)()).get();
+                if (!value)
+                    value = (*f)();
+                return value.get();
            }

-            bool equal(function_input_iterator const & other) const {
+            bool equal(function_object_input_iterator const & other) const {
                return f == other.f && state == other.state;
            }

@@ -83,12 +88,12 @@ namespace iterators {
        };

        template <class Function, class Input>
-        class function_pointer_input_iterator
-            : public iterator_facade<
-            function_pointer_input_iterator<Function, Input>,
-            typename function_types::result_type<Function>::type,
-            single_pass_traversal_tag,
-            typename function_types::result_type<Function>::type const &
+        class function_pointer_input_iterator :
+            public iterator_facade<
+                iterators::function_input_iterator<Function, Input>,
+                typename function_types::result_type<Function>::type,
+                single_pass_traversal_tag,
+                typename function_types::result_type<Function>::type const &
            >
        {
        public:
@@ -97,7 +102,7 @@ namespace iterators {
                : f(f_), state(state_) {}

            void increment() {
-                if(value)
+                if (value)
                    value = none;
                else
                    (*f)();
@@ -106,7 +111,9 @@ namespace iterators {

            typename function_types::result_type<Function>::type const &
                dereference() const {
-                    return (value ? value : value = (*f)()).get();
+                if (!value)
+                    value = (*f)();
+                return value.get();
            }

            bool equal(function_pointer_input_iterator const & other) const {
@@ -122,17 +129,17 @@ namespace iterators {
    } // namespace impl

    template <class Function, class Input>
-    class function_input_iterator
-        : public mpl::if_<
-            function_types::is_function_pointer<Function>,
+    class function_input_iterator :
+        public boost::conditional<
+            function_types::is_function_pointer<Function>::value,
            impl::function_pointer_input_iterator<Function,Input>,
-            impl::function_input_iterator<Function,Input>
+            impl::function_object_input_iterator<Function,Input>
        >::type
    {
-        typedef typename mpl::if_<
-            function_types::is_function_pointer<Function>,
+        typedef typename boost::conditional<
+            function_types::is_function_pointer<Function>::value,
            impl::function_pointer_input_iterator<Function,Input>,
-            impl::function_input_iterator<Function,Input>
+            impl::function_object_input_iterator<Function,Input>
        >::type base_type;
    public:
        function_input_iterator(Function & f, Input i)
@@ -153,7 +160,8 @@ namespace iterators {
            return result_t(f, state);
    }

-    struct infinite {
+    struct infinite
+    {
        infinite & operator++() { return *this; }
        infinite & operator++(int) { return *this; }
        bool operator==(infinite &) const { return false; };
--- a/linx64/include/boost/iterator/function_output_iterator.hpp
+++ b/linx64/include/boost/iterator/function_output_iterator.hpp
@@ -12,13 +12,53 @@
 #define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP

 #include <iterator>
+#include <boost/config.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <boost/type_traits/remove_reference.hpp>
+#endif

 namespace boost {
 namespace iterators {

  template <class UnaryFunction>
  class function_output_iterator {
+  private:
    typedef function_output_iterator self;
+
+    class output_proxy {
+    public:
+      explicit output_proxy(UnaryFunction& f) BOOST_NOEXCEPT : m_f(f) { }
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+      template <class T>
+      typename boost::disable_if_c<
+        boost::is_same< typename boost::remove_cv< T >::type, output_proxy >::value,
+        output_proxy&
+      >::type operator=(const T& value) {
+        m_f(value);
+        return *this;
+      }
+#else
+      template <class T>
+      typename boost::disable_if_c<
+        boost::is_same< typename boost::remove_cv< typename boost::remove_reference< T >::type >::type, output_proxy >::value,
+        output_proxy&
+      >::type operator=(T&& value) {
+        m_f(static_cast< T&& >(value));
+        return *this;
+      }
+#endif
+
+      BOOST_DEFAULTED_FUNCTION(output_proxy(output_proxy const& that), BOOST_NOEXCEPT : m_f(that.m_f) {})
+      BOOST_DELETED_FUNCTION(output_proxy& operator=(output_proxy const&))
+
+    private:
+      UnaryFunction& m_f;
+    };
+
  public:
    typedef std::output_iterator_tag iterator_category;
    typedef void                value_type;
@@ -31,17 +71,10 @@ namespace iterators {
    explicit function_output_iterator(const UnaryFunction& f)
      : m_f(f) {}

-    struct output_proxy {
-      output_proxy(UnaryFunction& f) : m_f(f) { }
-      template <class T> output_proxy& operator=(const T& value) {
-        m_f(value);
-        return *this;
-      }
-      UnaryFunction& m_f;
-    };
    output_proxy operator*() { return output_proxy(m_f); }
    self& operator++() { return *this; }
    self& operator++(int) { return *this; }
+
  private:
    UnaryFunction m_f;
  };
--- a/linx64/include/boost/iterator/indirect_iterator.hpp
+++ b/linx64/include/boost/iterator/indirect_iterator.hpp
@@ -111,7 +111,7 @@ namespace iterators {
  private:
      typename super_t::reference dereference() const
      {
-# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
+# if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x5A0 )
          return const_cast<super_t::reference>(**this->base());
 # else
          return **this->base();
--- a/linx64/include/boost/iterator/is_iterator.hpp
+++ b/linx64/include/boost/iterator/is_iterator.hpp
@@ -0,0 +1,148 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2023 Andrey Semashev
+ */
+/*!
+ * \file iterator/is_iterator.hpp
+ *
+ * This header contains definition of the \c is_iterator type trait.
+ */
+
+#ifndef BOOST_ITERATOR_IS_ITERATOR_HPP_INCLUDED_
+#define BOOST_ITERATOR_IS_ITERATOR_HPP_INCLUDED_
+
+#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>
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+#include <iterator>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+// The trait attempts to detect if the T type is an iterator class. Class-type iterators are assumed
+// to have the nested type iterator_category. Strictly speaking, this is not required to be the
+// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
+// Still, this is a good heuristic in practice, and we can't do anything better anyway.
+// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
+// required to be only present for iterators.
+namespace has_iterator_category_detail {
+
+typedef char yes_type;
+struct no_type { char padding[2]; };
+
+template< typename T >
+yes_type check(
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+    typename std::iterator_traits< T >::iterator_category*
+#else
+    typename T::iterator_category*
+#endif
+);
+template< typename >
+no_type check(...);
+
+} // namespace has_iterator_category_detail
+
+template< typename T >
+struct is_iterator_impl :
+    public boost::integral_constant<
+        bool,
+        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 > >
+    >::type
+{
+};
+
+template< typename T, typename U >
+struct is_iterator_impl< T U::* > :
+    public boost::false_type
+{
+};
+
+template< typename T >
+struct is_iterator_impl< T& > :
+    public boost::false_type
+{
+};
+
+template< typename T, std::size_t N >
+struct is_iterator_impl< T[N] > :
+    public boost::false_type
+{
+};
+
+#if !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)
+template< typename T >
+struct is_iterator_impl< T[] > :
+    public boost::false_type
+{
+};
+
+template< >
+struct is_iterator_impl< void > :
+    public boost::false_type
+{
+};
+
+template< >
+struct is_iterator_impl< void* > :
+    public boost::false_type
+{
+};
+#endif // !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)
+
+} // namespace detail
+
+/*!
+ * \brief The type trait detects whether the type \c T is an iterator type.
+ *
+ * The type trait yields \c true if its argument type \c T, after stripping top level
+ * cv qualifiers, is one of the following:
+ *
+ * - A pointer type, other than a pointer to function, a pointer to a class member,
+ *   or a pointer to an incomplete type, including `void`.
+ * - A class type for which an iterator category is obtainable. Prior to C++17,
+ *   the iterator category must be defined as a public `T::iterator_category` type.
+ *   Since C++17, the expression `std::iterator_traits< T >::iterator_category` must
+ *   be valid and produce the iterator category type.
+ *
+ * Otherwise, the type trait yields \c false.
+ */
+template< typename T >
+struct is_iterator : public detail::is_iterator_impl< T >::type {};
+template< typename T >
+struct is_iterator< const T > : public detail::is_iterator_impl< T >::type {};
+template< typename T >
+struct is_iterator< volatile T > : public detail::is_iterator_impl< T >::type {};
+template< typename T >
+struct is_iterator< const volatile T > : public detail::is_iterator_impl< T >::type {};
+
+} // namespace iterators
+
+using iterators::is_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_IS_ITERATOR_HPP_INCLUDED_
--- a/linx64/include/boost/iterator/iterator_concepts.hpp
+++ b/linx64/include/boost/iterator/iterator_concepts.hpp
@@ -144,8 +144,8 @@ namespace boost_concepts
  {
      typedef typename std::iterator_traits<Iterator>::difference_type difference_type;

-      BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
-      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+      BOOST_STATIC_ASSERT(boost::is_integral<difference_type>::value);
+      BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);

      BOOST_CONCEPT_ASSERT((
          boost::Convertible<
--- a/linx64/include/boost/iterator/iterator_facade.hpp
+++ b/linx64/include/boost/iterator/iterator_facade.hpp
@@ -154,79 +154,160 @@ namespace iterators {
    class postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;
+
     public:
        explicit postfix_increment_proxy(Iterator const& x)
-          : stored_value(*x)
+          : stored_iterator(x)
+          , stored_value(*x)
        {}

        // Returning a mutable reference allows nonsense like
        // (*r++).mutate(), but it imposes fewer assumptions about the
        // behavior of the value_type.  In particular, recall that
        // (*r).mutate() is legal if operator* returns by value.
-        value_type&
-        operator*() const
-        {
-            return this->stored_value;
-        }
-     private:
-        mutable value_type stored_value;
-    };
-
-    //
-    // In general, we can't determine that such an iterator isn't
-    // writable -- we also need to store a copy of the old iterator so
-    // that it can be written into.
-    template <class Iterator>
-    class writable_postfix_increment_proxy
-    {
-        typedef typename iterator_value<Iterator>::type value_type;
-     public:
-        explicit writable_postfix_increment_proxy(Iterator const& x)
-          : stored_value(*x)
-          , stored_iterator(x)
-        {}
-
-        // Dereferencing must return a proxy so that both *r++ = o and
-        // value_type(*r++) can work.  In this case, *r is the same as
-        // *r++, and the conversion operator below is used to ensure
-        // readability.
-        writable_postfix_increment_proxy const&
-        operator*() const
-        {
-            return *this;
-        }
-
        // Provides readability of *r++
-        operator value_type&() const
+        value_type& operator*() const
        {
            return stored_value;
        }

-        // Provides writability of *r++
-        template <class T>
-        T const& operator=(T const& x) const
-        {
-            *this->stored_iterator = x;
-            return x;
-        }
-
-        // This overload just in case only non-const objects are writable
-        template <class T>
-        T& operator=(T& x) const
-        {
-            *this->stored_iterator = x;
-            return x;
-        }
-
        // Provides X(r++)
        operator Iterator const&() const
        {
            return stored_iterator;
        }

+        // Provides (r++)->foo()
+        value_type* operator->() const
+        {
+            return boost::addressof(stored_value);
+        }
+
     private:
-        mutable value_type stored_value;
        Iterator stored_iterator;
+        mutable value_type stored_value;
+    };
+
+
+    template <class Iterator>
+    class writable_postfix_increment_dereference_proxy;
+
+    template <class T>
+    struct is_not_writable_postfix_increment_dereference_proxy :
+        public boost::true_type
+    {};
+
+    template <class Iterator>
+    struct is_not_writable_postfix_increment_dereference_proxy<
+        writable_postfix_increment_dereference_proxy<Iterator>
+    > :
+        public boost::false_type
+    {};
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy;
+
+    //
+    // In general, we can't determine that such an iterator isn't
+    // writable -- we also need to store a copy of the old iterator so
+    // that it can be written into.
+    template <class Iterator>
+    class writable_postfix_increment_dereference_proxy
+    {
+        friend class writable_postfix_increment_proxy<Iterator>;
+
+        typedef typename iterator_value<Iterator>::type value_type;
+
+     public:
+        explicit writable_postfix_increment_dereference_proxy(Iterator const& x)
+          : stored_iterator(x)
+          , stored_value(*x)
+        {}
+
+        // Provides readability of *r++
+        operator value_type&() const
+        {
+            return this->stored_value;
+        }
+
+        template <class OtherIterator>
+        writable_postfix_increment_dereference_proxy const&
+        operator=(writable_postfix_increment_dereference_proxy<OtherIterator> const& x) const
+        {
+            typedef typename iterator_value<OtherIterator>::type other_value_type;
+            *this->stored_iterator = static_cast<other_value_type&>(x);
+            return *this;
+        }
+
+        // Provides writability of *r++
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        template <class T>
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T&& x) const
+        {
+            *this->stored_iterator = static_cast< T&& >(x);
+            return *this;
+        }
+#else
+        template <class T>
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T const& x) const
+        {
+            *this->stored_iterator = x;
+            return *this;
+        }
+
+        // This overload just in case only non-const objects are writable
+        template <class T>
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T& x) const
+        {
+            *this->stored_iterator = x;
+            return *this;
+        }
+#endif
+
+     private:
+        Iterator stored_iterator;
+        mutable value_type stored_value;
+    };
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : dereference_proxy(x)
+        {}
+
+        writable_postfix_increment_dereference_proxy<Iterator> const&
+        operator*() const
+        {
+            return dereference_proxy;
+        }
+
+        // Provides X(r++)
+        operator Iterator const&() const
+        {
+            return dereference_proxy.stored_iterator;
+        }
+
+        // Provides (r++)->foo()
+        value_type* operator->() const
+        {
+            return boost::addressof(dereference_proxy.stored_value);
+        }
+
+     private:
+        writable_postfix_increment_dereference_proxy<Iterator> dereference_proxy;
    };

 # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
--- a/linx64/include/boost/iterator/new_iterator_tests.hpp
+++ b/linx64/include/boost/iterator/new_iterator_tests.hpp
@@ -87,11 +87,11 @@ void readable_iterator_test(const Iterator i1, T v)

 # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
  readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable<Iterator>());
-      
+
  // I think we don't really need this as it checks the same things as
  // the above code.
  BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value);
-# endif 
+# endif
 }

 template <class Iterator, class T>
@@ -106,7 +106,7 @@ void writable_iterator_test(Iterator i, T v, T v2)
          detail::is_incrementable<Iterator>
        , detail::is_postfix_incrementable<Iterator>
      >());
-# endif 
+# endif
 }

 template <class Iterator>
@@ -131,7 +131,7 @@ void constant_lvalue_iterator_test(Iterator i, T v1)
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
  BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
  BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator<Iterator>::value);
-# endif 
+# endif
 }

 template <class Iterator, class T>
@@ -143,17 +143,17 @@ void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
  BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
  T& v3 = *i2;
  BOOST_TEST(v1 == v3);
-  
+
  // A non-const lvalue iterator is not neccessarily writable, but we
  // are assuming the value_type is assignable here
  *i = v2;
-  
+
  T& v4 = *i2;
  BOOST_TEST(v2 == v4);
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
  BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
  BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value);
-# endif 
+# endif
 }

 template <class Iterator, class T>
@@ -248,7 +248,7 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals)
    BOOST_TEST(*i == vals[N - 1 - c]);
    typename std::iterator_traits<Iterator>::value_type x = j[N - 1 - c];
    BOOST_TEST(*i == x);
-    Iterator q = k - c; 
+    Iterator q = k - c;
    BOOST_TEST(*i == *q);
    BOOST_TEST(i > j);
    BOOST_TEST(i >= j);
--- a/linx64/include/boost/iterator/transform_iterator.hpp
+++ b/linx64/include/boost/iterator/transform_iterator.hpp
@@ -7,11 +7,11 @@
 #ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP

+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/iterator/detail/enable_if.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/iterator/iterator_categories.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/type_traits/function_traits.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_class.hpp>
@@ -24,7 +24,11 @@
 #include <iterator>

 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-# include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#endif
+
+#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+#include <boost/static_assert.hpp>
 #endif

 #include <boost/iterator/detail/config_def.hpp>
@@ -154,7 +158,7 @@ namespace iterators {
      return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
  }

-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
  template <class Return, class Argument, class Iterator>
  inline transform_iterator< Return (*)(Argument), Iterator, Return>
  make_transform_iterator(Iterator it, Return (*fun)(Argument))