Trim trailing spaces.

This should silence gcc warnings about deprecated implicit copy assignment
operator because of the explicitly defined copy constructor. Also, changed
constructor definitions to be defaulted when possible and added missing
includes.

Closes https://github.com/boostorg/iterator/pull/69.

.github/workflows/ci.yml

@@ -253,7 +253,7 @@ jobs:
                 if [ -f "/etc/debian_version" ]
                 then
                     apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
-                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y sudo software-properties-common tzdata wget curl apt-transport-https ca-certificates make build-essential g++ python python3 git cmake
+                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y sudo software-properties-common tzdata wget curl apt-transport-https ca-certificates make build-essential g++ python python3 perl git cmake
                 fi
             fi
             git config --global pack.threads 0
@@ -263,28 +263,32 @@ jobs:
       - name: Install packages
         if: matrix.install
         run: |
-            SOURCE_KEYS=(${{join(matrix.source_keys, ' ')}})
-            SOURCES=(${{join(matrix.sources, ' ')}})
+            declare -a SOURCE_KEYS SOURCES
+            if [ -n "${{join(matrix.source_keys, ' ')}}" ]
+            then
+                SOURCE_KEYS=("${{join(matrix.source_keys, '" "')}}")
+            fi
+            if [ -n "${{join(matrix.sources, ' ')}}" ]
+            then
+                SOURCES=("${{join(matrix.sources, '" "')}}")
+            fi
             for key in "${SOURCE_KEYS[@]}"
             do
                 for i in {1..$NET_RETRY_COUNT}
                 do
+                    echo "Adding key: $key"
                     wget -O - "$key" | sudo apt-key add - && break || sleep 2
                 done
             done
             if [ ${#SOURCES[@]} -gt 0 ]
             then
                 APT_ADD_REPO_COMMON_ARGS=("-y")
-                APT_ADD_REPO_HAS_SOURCE_ARGS=0
-                SOFTWARE_PROPERTIES_VERSION="$(dpkg-query --showformat='${Version}' --show software-properties-common)"
-                if dpkg --compare-versions "$SOFTWARE_PROPERTIES_VERSION" ge "0.96.24.20"
+                APT_ADD_REPO_SUPPORTED_ARGS="$(apt-add-repository --help | perl -ne 'if (/^\s*-n/) { print "n"; } elsif (/^\s*-P/) { print "P"; } elsif (/^\s*-S/) { print "S"; } elsif (/^\s*-U/) { print "U"; }')"
+                if [ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*n*}" ]
                 then
                     APT_ADD_REPO_COMMON_ARGS+=("-n")
                 fi
-                if dpkg --compare-versions "$SOFTWARE_PROPERTIES_VERSION" ge "0.98.10"
-                then
-                    APT_ADD_REPO_HAS_SOURCE_ARGS=1
-                fi
+                APT_ADD_REPO_HAS_SOURCE_ARGS="$([ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*P*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*S*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*U*}" ] && echo 1 || echo 0)"
                 for source in "${SOURCES[@]}"
                 do
                     for i in {1..$NET_RETRY_COUNT}
@@ -305,6 +309,7 @@ jobs:
                             esac
                         fi
                         APT_ADD_REPO_ARGS+=("$source")
+                        echo "apt-add-repository ${APT_ADD_REPO_ARGS[@]}"
                         sudo -E apt-add-repository "${APT_ADD_REPO_ARGS[@]}" && break || sleep 2
                     done
                 done
@@ -335,7 +340,7 @@ jobs:
             REF=${GITHUB_BASE_REF:-$GITHUB_REF}
             REF=${REF#refs/heads/}
             echo REF: $REF
-            BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+            BOOST_BRANCH=develop && [ "$REF" = "master" ] && BOOST_BRANCH=master || true
             echo BOOST_BRANCH: $BOOST_BRANCH
             BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
             echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV

doc/Jamfile.v2

@@ -4,20 +4,20 @@
 
 using quickbook ;
 
-xml iterator 
-  : 
-    quickbook/iterator.qbk 
+xml iterator
+  :
+    quickbook/iterator.qbk
   ;
 
 boostbook standalone 
   : 
     iterator 
   :
-    <xsl:param>boost.root=../../../..
+    <xsl:param>"boost.root=../../../.."
     <xsl:param>toc.max.depth=3
     <xsl:param>toc.section.depth=3
     <xsl:param>chunk.section.depth=2
-    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc
+    <format>pdf:<xsl:param>"boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc/html"
   ;
 
 ###############################################################################

example/node.hpp

@@ -24,7 +24,7 @@ struct node_base
 
     virtual void print(std::ostream& s) const = 0;
     virtual void double_me() = 0;
-        
+
     void append(node_base* p)
     {
         if (m_next)
@@ -32,7 +32,7 @@ struct node_base
         else
             m_next = p;
     }
-    
+
  private:
     node_base* m_next;
 };
@@ -52,9 +52,9 @@ struct node : node_base
 
     void print(std::ostream& s) const { s << this->m_value; }
     void double_me() { m_value += m_value; }
-    
+
  private:
     T m_value;
 };
-    
+
 #endif // NODE_DWA2004110_HPP

example/node_iterator1.hpp

@@ -28,10 +28,10 @@ class node_iterator
 
     void increment()
     { m_node = m_node->next(); }
-    
+
     bool equal(node_iterator const& other) const
     { return this->m_node == other.m_node; }
-    
+
     node_base& dereference() const
     { return *m_node; }
 

example/node_iterator2.hpp

@@ -38,15 +38,15 @@ class node_iter
             boost::is_convertible<OtherValue*,Value*>
           , enabler
         >::type = enabler()
-# endif 
+# endif
     )
       : m_node(other.m_node) {}
 
 
 # if !BOOST_WORKAROUND(__GNUC__, == 2)
- private: // GCC2 can't grant friendship to template member functions    
+ private: // GCC2 can't grant friendship to template member functions
     friend class boost::iterator_core_access;
-# endif 
+# endif
 
     template <class OtherValue>
     bool equal(node_iter<OtherValue> const& other) const
@@ -63,7 +63,7 @@ class node_iter
 # else
  private:
     template <class> friend class node_iter;
-# endif 
+# endif
     Value* m_node;
 };
 

example/node_iterator3.hpp

@@ -27,7 +27,7 @@ class node_iter
     typedef boost::iterator_adaptor<
         node_iter<Value>, Value*, boost::use_default, boost::forward_traversal_tag
     > super_t;
-    
+
  public:
     node_iter()
       : super_t(0) {}
@@ -43,14 +43,14 @@ class node_iter
             boost::is_convertible<OtherValue*,Value*>
           , enabler
         >::type = enabler()
-# endif 
+# endif
     )
       : super_t(other.base()) {}
 
 # if !BOOST_WORKAROUND(__GNUC__, == 2)
- private: // GCC2 can't grant friendship to template member functions    
+ private: // GCC2 can't grant friendship to template member functions
     friend class boost::iterator_core_access;
-# endif     
+# endif
     void increment() { this->base_reference() = this->base()->next(); }
 };
 

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 {
@@ -45,7 +54,7 @@ namespace detail
            && 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

include/boost/iterator/detail/config_def.hpp

@@ -18,9 +18,9 @@
 
 #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
@@ -50,7 +50,7 @@
     || (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
 
@@ -112,7 +112,7 @@
 
 #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(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
 
@@ -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

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

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
     {
     };

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>
@@ -38,7 +38,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,12 +46,12 @@ 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_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 &
             >
         {
         public:
@@ -83,12 +83,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<
+                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 &
             >
         {
         public:
@@ -122,15 +122,15 @@ 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>
         >::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>
         >::type base_type;
@@ -153,7 +153,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; };

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);

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))

test/counting_iterator_test.cpp

@@ -30,7 +30,7 @@
 #include <boost/iterator/new_iterator_tests.hpp>
 
 #include <boost/next_prior.hpp>
-#include <boost/mpl/if.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/limits.hpp>
 
@@ -68,7 +68,7 @@ struct unsigned_assert_nonnegative
 
 template <class T>
 struct assert_nonnegative
-  : boost::mpl::if_c<
+  : boost::conditional<
         std::numeric_limits<T>::is_signed
       , signed_assert_nonnegative<T>
       , unsigned_assert_nonnegative<T>
@@ -271,8 +271,12 @@ int main()
     test_integer<long>();
     test_integer<unsigned long>();
 #if defined(BOOST_HAS_LONG_LONG)
-    test_integer< ::boost::long_long_type>();
-    test_integer< ::boost::ulong_long_type>();
+    test_integer<boost::long_long_type>();
+    test_integer<boost::ulong_long_type>();
+#endif
+#if defined(BOOST_HAS_INT128)
+    test_integer<boost::int128_type>();
+    test_integer<boost::uint128_type>();
 #endif
 
     // Test user-defined type.