Mostly remove pre-CXX11 workarounds.

С++03 support was deprecated in 1.85 and now can be removed. This PR clears
many of workarounds, which are no longer needed now.

* Remove unused workaround macros (many of).
* Remove BOOST_STATIC_ASSERT usages.
* Minimize Boost::type_traits dependency (in favour of STL's type_traits).

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

Squashed commit of the following:

commit 741a627b73
Author: Georgy Guminov <gogagum@gmail.com>
Date:   Sat Jan 25 12:13:05 2025 +0300

    Replace testers with standard metafunctions.

commit bf4cce6114
Author: Georgy Guminov <gogagum@gmail.com>
Date:   Sat Jan 25 11:51:32 2025 +0300

    Refactor is_lvalue_iterator.hpp.

commit 8d080c6c58
Author: Georgy Guminov <gogagum@gmail.com>
Date:   Sat Jan 25 10:27:32 2025 +0300

    Remove more workarounds.

commit 5a4ba24d36
Author: Georgy Guminov <gogagum@gmail.com>
Date:   Sun Jan 19 16:38:30 2025 +0300

    Fixes.

commit fdfafce2b9
Author: Georgy Guminov <gogagum@gmail.com>
Date:   Sat Oct 26 15:06:43 2024 +0300

    Remove BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
    Correct static_assert messages.
    Fix messages & replace is_standard_layout with is_copy_constructible.

commit c69ac1408a
Author: Georgy Guminov <gogagum@gmail.com>
Date:   Sat Oct 26 14:48:51 2024 +0300

    Correct static_assert messages.

commit b5df827151
Author: Georqy Guminov <gogagum@gmail.com>
Date:   Sun Jun 23 16:12:29 2024 +0300

    Fixes. Remove some Boost.MPL usages. Remove unused includes.

commit 01fd35e9f8
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Wed Jun 12 17:14:21 2024 +0300

    abstract conjunction.

commit c02def8acf
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Wed Jun 12 16:35:43 2024 +0300

    return addressof & conjunction.

commit 3b3d162575
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Wed Jun 12 16:30:44 2024 +0300

    Make macro more readable.

commit 4ab19e045f
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Wed Jun 12 15:56:49 2024 +0300

    Add static_assert messages.

commit 82b5c44cd3
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Wed Jun 12 14:12:10 2024 +0300

    Return is iterator CXX17 test.

commit 2d58d65462
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Tue Jun 11 14:04:17 2024 +0300

    Omitted.

commit a0d04d9491
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Tue Jun 11 14:00:35 2024 +0300

    Replace move with static_cast

commit 4a49b8a1a2
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Mon Jun 10 21:38:53 2024 +0300

    Return BOOST_NOEXCEPT

commit 054c013bba
Author: Georgiy Guminov <gogagum@gmail.com>
Date:   Sun Jun 9 15:20:41 2024 +0300

    CXX11

test/counting_iterator_test.cpp

@@ -30,13 +30,12 @@
 #include <boost/iterator/new_iterator_tests.hpp>
 
 #include <boost/next_prior.hpp>
-#include <boost/type_traits/conditional.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/limits.hpp>
 
 #include <algorithm>
-#include <climits>
 #include <iterator>
+#include <type_traits>
 #include <stdlib.h>
 #ifndef BOOST_BORLANDC
 # include <boost/tuple/tuple.hpp>
@@ -68,7 +67,7 @@ struct unsigned_assert_nonnegative
 
 template <class T>
 struct assert_nonnegative
-  : boost::conditional<
+  : std::conditional<
         std::numeric_limits<T>::is_signed
       , signed_assert_nonnegative<T>
       , unsigned_assert_nonnegative<T>

test/filter_iterator_test.cpp

@@ -7,15 +7,14 @@
 #include <boost/iterator/filter_iterator.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
 #include <boost/iterator/new_iterator_tests.hpp>
-#include <boost/type_traits/is_convertible.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/concept_archetype.hpp>
 #include <boost/iterator/iterator_concepts.hpp>
 #include <boost/iterator/iterator_archetypes.hpp>
 #include <boost/cstdlib.hpp>
 
+#include <type_traits>
 #include <deque>
-#include <iostream>
 
 using boost::dummyT;
 
@@ -229,12 +228,12 @@ int main()
         filter_iter(one_or_four(), array, array+N)
         , dummyT(1), dummyT(4));
 
-    BOOST_STATIC_ASSERT(
-        (!boost::is_convertible<
+    static_assert(
+        !std::is_convertible<
              boost::iterator_traversal<filter_iter>::type
            , boost::random_access_traversal_tag
-         >::value
-        ));
+         >::value,
+        "Filter interator must have a random_access_traversal_tag.");
 
     //# endif
 

test/function_input_iterator_test.cpp

@@ -11,14 +11,12 @@
 
 #include <boost/config.hpp>
 
-#if !defined(BOOST_NO_CXX11_DECLTYPE)
 // Force boost::result_of use decltype, even on compilers that don't support N3276.
 // This enables this test to also verify if the iterator works with lambdas
 // on such compilers with this config macro. Note that without the macro result_of
 // (and consequently the iterator) is guaranteed to _not_ work, so this case is not
 // worth testing anyway.
 #define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
 
 #include <boost/core/lightweight_test.hpp>
 #include <boost/iterator/function_input_iterator.hpp>
@@ -108,8 +106,6 @@ int main()
         BOOST_TEST_EQ(*it3, 54);
     }
 
-#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) \
-    && defined(BOOST_RESULT_OF_USE_DECLTYPE)
     // test the iterator with lambda expressions
     int num = 42;
     auto lambda_generator = [&num] { return num++; };
@@ -123,7 +119,6 @@ int main()
     BOOST_TEST_EQ(generated.size(), 10u);
     for(std::size_t i = 0; i != 10; ++i)
         BOOST_TEST_EQ(generated[i], static_cast<int>(42 + i));
-#endif // BOOST_NO_CXX11_LAMBDAS
 
     return boost::report_errors();
 }

test/function_output_iterator_test.cpp

@@ -44,7 +44,6 @@ int main()
         BOOST_TEST_EQ(n, 6);
     }
 
-#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
     {
         int n = 0;
         auto it = boost::iterators::make_function_output_iterator([&n](int x) { n -= x; });
@@ -57,7 +56,6 @@ int main()
 
         BOOST_TEST_EQ(n, -6);
     }
-#endif
 
 #if defined(__cpp_lib_concepts) && ( __cpp_lib_concepts >= 202002L )
     {

test/indirect_iter_member_types.cpp

@@ -9,12 +9,10 @@
 
 
 #include <boost/config.hpp>
-#include <iostream>
 
 #include <boost/iterator/indirect_iterator.hpp>
-#include <boost/static_assert.hpp>
 #include "static_assert_same.hpp"
-#include <boost/type_traits/same_traits.hpp>
+#include <type_traits>
 
 struct zow { };
 
@@ -40,10 +38,12 @@ int main()
     STATIC_ASSERT_SAME(Iter::pointer, int*);
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
 
-    BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
-             std::random_access_iterator_tag>::value));
-    BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
-             boost::random_access_traversal_tag>::value));
+    static_assert(std::is_convertible<Iter::iterator_category,
+                                      std::random_access_iterator_tag>::value,
+                  "Iter must have a random access category.");
+    static_assert(std::is_convertible<boost::iterator_traversal<Iter>::type,
+                                      boost::random_access_traversal_tag>::value,
+                  "Iter must have a random_access_traversal_tag.");
   }
   {
     typedef boost::indirect_iterator<int const**> Iter;
@@ -71,10 +71,12 @@ int main()
 
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
 
-    BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
-             std::random_access_iterator_tag>::value));
-    BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
-             boost::random_access_traversal_tag>::value));
+    static_assert(std::is_convertible<Iter::iterator_category,
+                                      std::random_access_iterator_tag>::value,
+                  "Iter must have a random access category.");
+    static_assert(std::is_convertible<boost::iterator_traversal<Iter>::type,
+                                      boost::random_access_traversal_tag>::value,
+                  "Iter must have a random_access_traversal_tag.");
   }
   {
     typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;

test/indirect_iterator_test.cpp

@@ -37,8 +37,7 @@
 
 #if !defined(__SGI_STL_PORT)                            \
     && (defined(BOOST_MSVC_STD_ITERATOR)                \
-        || BOOST_WORKAROUND(_CPPLIB_VER, <= 310)        \
-        || BOOST_WORKAROUND(__GNUC__, <= 2))
+        || BOOST_WORKAROUND(_CPPLIB_VER, <= 310))
 
 // std container random-access iterators don't support mutable/const
 // interoperability (but may support const/mutable interop).

test/is_convertible_fail.cpp

@@ -8,12 +8,13 @@
 //
 #include <boost/iterator/reverse_iterator.hpp>
 #include <boost/cstdlib.hpp>
+#include <type_traits>
 
 int main()
 {
     typedef boost::reverse_iterator<int*>  rev_iter1;
     typedef boost::reverse_iterator<char*> rev_iter2;
 
-    return boost::is_convertible<rev_iter1, rev_iter2>::value
+    return std::is_convertible<rev_iter1, rev_iter2>::value
         ? boost::exit_failure : boost::exit_success;
 }

test/is_lvalue_iterator.cpp

@@ -4,15 +4,10 @@
 
 #include <deque>
 #include <iterator>
-#include <iostream>
 #include <cstddef> // std::ptrdiff_t
-#include <boost/static_assert.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/iterator/is_lvalue_iterator.hpp>
 
-// Last, for BOOST_NO_LVALUE_RETURN_DETECTION
-#include <boost/iterator/detail/config_def.hpp>
-
 struct v
 {
     v();
@@ -88,61 +83,90 @@ struct constant_lvalue_iterator
     constant_lvalue_iterator operator++(int);
 };
 
-
 int main()
 {
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<v*>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<v const*>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<std::deque<v>::iterator>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<std::deque<v>::const_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<std::ostream_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<proxy_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<proxy_iterator<int> >::value);
-#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<value_iterator>::value);
-#endif
+    static_assert(boost::is_lvalue_iterator<v*>::value,
+                  "boost::is_lvalue_iterator<v*>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<v const*>::value,
+                  "boost::is_lvalue_iterator<v const*>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<std::deque<v>::iterator>::value,
+                  "boost::is_lvalue_iterator<std::deque<v>::iterator>::value.");
+    static_assert(boost::is_lvalue_iterator<std::deque<v>::const_iterator>::value,
+                  "boost::is_lvalue_iterator<std::deque<v>::const_iterator>::value is expected to be true.");
+    static_assert(!boost::is_lvalue_iterator<std::back_insert_iterator<std::deque<v>>>::value,
+                  "boost::is_lvalue_iterator<std::back_insert_iterator<std::deque<v>>>::value is expected to be false.");
+    static_assert(!boost::is_lvalue_iterator<std::ostream_iterator<v>>::value,
+                  "boost::is_lvalue_iterator<std::ostream_iterator<v>>::value is expected to be false.");
+    static_assert(!boost::is_lvalue_iterator<proxy_iterator<v>>::value,
+                  "boost::is_lvalue_iterator<proxy_iterator<v>>::value is expected to be false.");
+    static_assert(!boost::is_lvalue_iterator<proxy_iterator<int>>::value,
+                  "boost::is_lvalue_iterator<proxy_iterator<int>>::value is expected to be false.");
+    static_assert(!boost::is_lvalue_iterator<value_iterator>::value,
+                  "boost::is_lvalue_iterator<value_iterator>::value is expected to be false.");
     // Make sure inaccessible copy constructor doesn't prevent
     // reference binding
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<noncopyable_iterator>::value);
+    static_assert(boost::is_lvalue_iterator<noncopyable_iterator>::value,
+                  "boost::is_lvalue_iterator<noncopyable_iterator>::value is expected to be true.");
 
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<int> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<float> >::value);
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<v>>::value,
+                  "boost::is_lvalue_iterator<lvalue_iterator<v>>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<int>>::value,
+                  "boost::is_lvalue_iterator<lvalue_iterator<int>>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<char*>>::value,
+                  "boost::is_lvalue_iterator<lvalue_iterator<char*>>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<float>>::value,
+                  "boost::is_lvalue_iterator<lvalue_iterator<float>>::value is expected to be true.");
 
 
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<int> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<float> >::value);
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<v>>::value,
+                  "boost::is_lvalue_iterator<constant_lvalue_iterator<v>>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<int>>::value,
+                  "boost::is_lvalue_iterator<constant_lvalue_iterator<int>>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<char*>>::value,
+                  "boost::is_lvalue_iterator<constant_lvalue_iterator<char*>>::value is expected to be true.");
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<float>>::value,
+                  "boost::is_lvalue_iterator<constant_lvalue_iterator<float>>::value is expected to be true.");
 
 
 
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<v*>::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<v const*>::value);
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::deque<v>::const_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::ostream_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<proxy_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<proxy_iterator<int> >::value);
-#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<value_iterator>::value);
-#endif
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value);
+    static_assert(boost::is_non_const_lvalue_iterator<v*>::value,
+                  "boost::is_non_const_lvalue_iterator<v*>::value is expected to be true.");
+    static_assert(!boost::is_non_const_lvalue_iterator<v const*>::value,
+                  "boost::is_non_const_lvalue_iterator<v const*>::value is expected to be false.");
+    static_assert(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value,
+                  "boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value is expected to be true.");
+    static_assert(!boost::is_non_const_lvalue_iterator<std::deque<v>::const_iterator>::value,
+                  "boost::is_non_const_lvalue_iterator<std::deque<v>::const_iterator>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<std::back_insert_iterator<std::deque<v>>>::value,
+                  "boost::is_non_const_lvalue_iterator<std::back_insert_iterator<std::deque<v>>>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<std::ostream_iterator<v>>::value,
+                  "boost::is_non_const_lvalue_iterator<std::ostream_iterator<v>>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<proxy_iterator<v>>::value,
+                  "boost::is_non_const_lvalue_iterator<proxy_iterator<v>>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<proxy_iterator<int>>::value,
+                  "boost::is_non_const_lvalue_iterator<proxy_iterator<int>>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<value_iterator>::value,
+                  "boost::is_non_const_lvalue_iterator<value_iterator>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value,
+                  "boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value is expected to be false.");
 
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<v> >::value);
-#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<int> >::value);
-#endif
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<float> >::value);
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<v>>::value,
+                  "boost::is_non_const_lvalue_iterator<lvalue_iterator<v>>::value is expected to be true.");
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<int>>::value,
+                  "boost::is_non_const_lvalue_iterator<lvalue_iterator<int>>::value is expected to be true.");
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*>>::value,
+                  "boost::is_non_const_lvalue_iterator<lvalue_iterator<char*>>::value is expected to be true.");
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<float>>::value,
+                  "boost::is_non_const_lvalue_iterator<lvalue_iterator<float>>::value is expected to be true.");
 
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float> >::value);
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v>>::value,
+                  "boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v>>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int>>::value,
+                  "boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int>>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*>>::value,
+                  "boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*>>::value is expected to be false.");
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float>>::value,
+                  "boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float>>::value is expected to be false.");
 
     return 0;
 }

test/is_readable_iterator.cpp

@@ -4,15 +4,10 @@
 
 #include <deque>
 #include <iterator>
-#include <iostream>
 #include <cstddef> // std::ptrdiff_t
-#include <boost/static_assert.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/iterator/is_readable_iterator.hpp>
 
-// Last, for BOOST_NO_LVALUE_RETURN_DETECTION
-#include <boost/iterator/detail/config_def.hpp>
-
 struct v
 {
     v();
@@ -78,19 +73,29 @@ struct proxy_iterator2
 
 int main()
 {
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<v*>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<v const*>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<std::deque<v>::iterator>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<std::deque<v>::const_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_readable_iterator<std::back_insert_iterator<std::deque<v> > >::value);
-    BOOST_STATIC_ASSERT(!boost::is_readable_iterator<std::ostream_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<proxy_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_readable_iterator<proxy_iterator2>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<value_iterator>::value);
+    static_assert(boost::is_readable_iterator<v*>::value,
+                  "boost::is_readable_iterator<v*>::value is expected to be true.");
+    static_assert(boost::is_readable_iterator<v const*>::value,
+                  "boost::is_readable_iterator<v const*>::value is expected to be true.");
+    static_assert(boost::is_readable_iterator<std::deque<v>::iterator>::value,
+                  "boost::is_readable_iterator<std::deque<v>::iterator>::value is expected to be true.");
+    static_assert(boost::is_readable_iterator<std::deque<v>::const_iterator>::value,
+                  "boost::is_readable_iterator<std::deque<v>::const_iterator>::value is expected to be true.");
+    static_assert(!boost::is_readable_iterator<std::back_insert_iterator<std::deque<v>>>::value,
+                  "boost::is_readable_iterator<std::back_insert_iterator<std::deque<v>>>::value is expected to be false.");
+    static_assert(!boost::is_readable_iterator<std::ostream_iterator<v>>::value,
+                  "boost::is_readable_iterator<std::ostream_iterator<v>>::value is expected to be false.");
+    static_assert(boost::is_readable_iterator<proxy_iterator>::value,
+                  "boost::is_readable_iterator<proxy_iterator>::value is expected to be true.");
+    static_assert(!boost::is_readable_iterator<proxy_iterator2>::value,
+                  "boost::is_readable_iterator<proxy_iterator2>::value is expected to be false.");
+    static_assert(boost::is_readable_iterator<value_iterator>::value,
+                  "boost::is_readable_iterator<value_iterator>::value is expected to be true.");
 
     // Make sure inaccessible copy constructor doesn't prevent
     // readability
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<noncopyable_iterator>::value);
+    static_assert(boost::is_readable_iterator<noncopyable_iterator>::value,
+                  "boost::is_readable_iterator<noncopyable_iterator>::value is expected to be true.");
 
     return 0;
 }

test/iterator_adaptor_cc.cpp

@@ -27,7 +27,7 @@ int main()
 #if defined(__SGI_STL_PORT)                                                             \
     || !BOOST_WORKAROUND(__GNUC__, <= 2)                                                \
     && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1))    \
-    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                          \
+    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                        \
     && !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29))                      \
     && !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
   {

test/iterator_adaptor_test.cpp

@@ -13,10 +13,8 @@
 #include <numeric>
 
 #include <boost/iterator/iterator_adaptor.hpp>
-#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-# include <boost/iterator/is_readable_iterator.hpp>
-# include <boost/iterator/is_lvalue_iterator.hpp>
-#endif
+#include <boost/iterator/is_readable_iterator.hpp>
+#include <boost/iterator/is_lvalue_iterator.hpp>
 #include <boost/pending/iterator_tests.hpp>
 
 # include <boost/core/lightweight_test.hpp>
@@ -29,8 +27,6 @@
 
 #include "static_assert_same.hpp"
 
-#include <boost/iterator/detail/config_def.hpp>
-
 using boost::dummyT;
 
 typedef std::deque<int> storage;
@@ -56,9 +52,6 @@ struct ptr_iterator
       , V*
       , V
       , boost::random_access_traversal_tag
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-      , V&
-#endif
    >
 {
 private:
@@ -67,9 +60,6 @@ private:
       , V*
       , V
       , boost::random_access_traversal_tag
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-      , V&
-#endif
     > super_t;
 
 public:
@@ -208,9 +198,10 @@ main()
     test = static_assert_same<Iter1::reference, int&>::value;
     test = static_assert_same<Iter1::pointer, int*>::value;
     test = static_assert_same<Iter1::difference_type, std::ptrdiff_t>::value;
-#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-    BOOST_STATIC_ASSERT((boost::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value));
-#endif
+    static_assert(
+        std::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value,
+        "Iterator must have a random access category."
+    );
   }
 
   {
@@ -219,16 +210,10 @@ main()
     test = static_assert_same<Iter1::value_type, int>::value;
     test = static_assert_same<Iter1::reference, const int&>::value;
 
-#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<Iter1>::value);
-# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter1>::value);
-# endif
-#endif
+    static_assert(boost::is_readable_iterator<Iter1>::value, "Iter1 is expected to be readable.");
+    static_assert(boost::is_lvalue_iterator<Iter1>::value, "Iter1 is expected to be lvalue iterator.");
 
-#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness
     test = static_assert_same<Iter1::pointer, int const*>::value;
-#endif
   }
 
   {
@@ -238,14 +223,16 @@ main()
 
     test = static_assert_same<Iter::value_type, int>::value;
     test = static_assert_same<Iter::reference, int const&>::value;
-#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness
     test = static_assert_same<Iter::pointer, int const*>::value;
-#endif
 
-#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<BaseIter>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter>::value);
-#endif
+    static_assert(
+      boost::is_non_const_lvalue_iterator<BaseIter>::value,
+      "boost::is_non_const_lvalue_iterator<BaseIter>::value is expected to be true."
+    );
+    static_assert(
+      boost::is_lvalue_iterator<Iter>::value,
+      "boost::is_lvalue_iterator<Iter>::value is expected to be true."
+    );
 
     typedef modify_traversal<BaseIter, boost::incrementable_traversal_tag> IncrementableIter;
 

test/iterator_facade.cpp

@@ -8,8 +8,9 @@
 #include <boost/iterator/new_iterator_tests.hpp>
 
 #include <boost/call_traits.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/core/enable_if.hpp>
+#include <type_traits>
+
+#include "static_assert_same.hpp"
 
 // This is a really, really limited test so far.  All we're doing
 // right now is checking that the postfix++ proxy for single-pass
@@ -120,7 +121,7 @@ struct wrapper
     { }
     template <class U>
     wrapper(const wrapper<U>& other,
-        typename boost::enable_if< boost::is_convertible<U,T> >::type* = 0)
+        typename std::enable_if< std::is_convertible<U,T>::value >::type* = 0)
         : m_x(other.m_x)
     { }
 };
@@ -144,19 +145,15 @@ struct iterator_with_proxy_reference
     { return wrapper<int&>(m_x); }
 };
 
-template <class T, class U>
-void same_type(U const&)
-{ BOOST_STATIC_ASSERT((boost::is_same<T,U>::value)); }
-
 template <class I, class A>
 struct abstract_iterator
     : boost::iterator_facade<
           abstract_iterator<I, A>
-        , A &
+        , A&
         // In order to be value type as a reference, traversal category has
         // to satisfy least forward traversal.
         , boost::forward_traversal_tag
-        , A &
+        , A&
       >
 {
     abstract_iterator(I iter) : iter(iter) {}
@@ -164,7 +161,7 @@ struct abstract_iterator
     void increment()
     { ++iter; }
 
-    A & dereference() const
+    A& dereference() const
     { return *iter; }
 
     bool equal(abstract_iterator const& y) const
@@ -175,30 +172,30 @@ struct abstract_iterator
 
 struct base
 {
-    virtual void assign(const base &) = 0;
-    virtual bool equal(const base &) const = 0;
+    virtual void assign(const base&) = 0;
+    virtual bool equal(const base&) const = 0;
 };
 
 struct derived : base
 {
     derived(int state) : state(state) { }
-    derived(const derived &d) : state(d.state) { }
-    derived(const base &b) { derived::assign(b); }
+    derived(const derived& d) : state(d.state) { }
+    derived(const base& b) { derived::assign(b); }
 
-    virtual void assign(const base &b)
+    virtual void assign(const base& b)
     {
-        state = dynamic_cast<const derived &>(b).state;
+        state = dynamic_cast<const derived& >(b).state;
     }
 
-    virtual bool equal(const base &b) const
+    virtual bool equal(const base& b) const
     {
-        return state == dynamic_cast<const derived &>(b).state;
+        return state == dynamic_cast<const derived&>(b).state;
     }
 
     int state;
 };
 
-inline bool operator==(const base &lhs, const base &rhs)
+inline bool operator==(const base& lhs, const base& rhs)
 {
     return lhs.equal(rhs);
 }
@@ -226,7 +223,7 @@ int main()
         BOOST_TEST_EQ(val.private_mutator_count, 0); // mutator() should be invoked on an object returned by value
         BOOST_TEST_EQ(shared_mutator_count, 2);
 
-        same_type<input_iter::pointer>(p.operator->());
+        STATIC_ASSERT_SAME(input_iter::pointer, std::remove_cv<std::remove_reference<decltype(p.operator->())>::type>::type);
     }
 
     {

test/iterator_traits_test.cpp

@@ -20,15 +20,13 @@
 //              reference type from operator* (David Abrahams)
 //  19 Jan 2001 Initial version with iterator operators (David Abrahams)
 
-#include <boost/type_traits/is_same.hpp>
 #include <boost/operators.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/config.hpp>
 #include <iterator>
 #include <vector>
 #include <list>
 #include <boost/core/lightweight_test.hpp>
-#include <iostream>
+#include <type_traits>
 
 // A UDT for which we can specialize std::iterator_traits<element*> on
 // compilers which don't support partial specialization. There's no
@@ -98,7 +96,7 @@ template <> struct assertion<true>
 
 template <class T, class U>
 struct assert_same
-    : assertion<(::boost::is_same<T,U>::value)>
+    : assertion<(std::is_same<T,U>::value)>
 {
 };
 

test/minimum_category.cpp

@@ -6,10 +6,10 @@
 
 #include <boost/iterator/minimum_category.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <iterator>
+#include <type_traits>
 
-using boost::is_same;
+using std::is_same;
 using boost::iterators::minimum_category;
 
 int main(int, char*[])

test/permutation_iterator_test.cpp

@@ -8,7 +8,6 @@
 #include <boost/core/lightweight_test.hpp>
 
 #include <boost/iterator/permutation_iterator.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/iterator/iterator_concepts.hpp>
 #include <boost/concept/assert.hpp>
 
@@ -44,7 +43,8 @@ void permutation_test()
   const int element_range_size = 10;
   const int index_size = 7;
 
-  BOOST_STATIC_ASSERT(index_size <= element_range_size);
+  static_assert(index_size < element_range_size, "The permutation of some elements is checked.");
+
   element_range_type elements( element_range_size );
   for( element_range_type::iterator el_it = elements.begin(); el_it != elements.end(); ++el_it )
     { *el_it = std::distance(elements.begin(), el_it); }

test/pointee.cpp

@@ -3,10 +3,10 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/pointee.hpp>
-#include <boost/type_traits/add_const.hpp>
 #include "static_assert_same.hpp"
 #include <memory>
 #include <list>
+#include <type_traits>
 
 template <class T, class Ref>
 struct proxy_ptr
@@ -27,7 +27,7 @@ struct proxy_ref_ptr : proxy_ptr<T,T&>
 template <class T>
 struct proxy_value_ptr : proxy_ptr<T,T>
 {
-    typedef typename boost::add_const<T>::type element_type;
+    typedef typename std::add_const<T>::type element_type;
 };
 
 struct X {

test/reverse_iterator_test.cpp

@@ -161,7 +161,7 @@ int main()
 #if defined(__SGI_STL_PORT)                                                             \
     || !BOOST_WORKAROUND(__GNUC__, <= 2)                                                \
     && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1))    \
-    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                          \
+    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                        \
     && !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29))                      \
     && !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
 

test/static_assert_same.hpp

@@ -5,10 +5,9 @@
 #ifndef STATIC_ASSERT_SAME_DWA2003530_HPP
 # define STATIC_ASSERT_SAME_DWA2003530_HPP
 
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include <type_traits>
 
-#define STATIC_ASSERT_SAME( T1,T2 ) BOOST_STATIC_ASSERT((::boost::is_same< T1, T2 >::value))
+#define STATIC_ASSERT_SAME( T1,T2 ) static_assert(std::is_same<T1, T2>::value, "T1 and T2 are expected to be the same types.")
 
 template <class T1, class T2>
 struct static_assert_same

test/transform_iterator_test.cpp

@@ -21,15 +21,7 @@
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/concept_check.hpp>
 
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace boost { namespace detail
-{
-  template<> struct function_object_result<int (*)(int)>
-  {
-      typedef int type;
-  };
-}}
-#endif
+#include "static_assert_same.hpp"
 
 struct mult_functor {
   // Functors used with transform_iterator must be
@@ -172,20 +164,20 @@ main()
   {
     {
       typedef boost::transform_iterator<adaptable_mult_functor, int*, float> iter_t;
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference,  float>::value));
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, float>::value));
+      STATIC_ASSERT_SAME(iter_t::reference,  float);
+      STATIC_ASSERT_SAME(iter_t::value_type, float);
     }
 
     {
       typedef boost::transform_iterator<adaptable_mult_functor, int*, boost::use_default, float> iter_t;
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference,  int>::value));
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, float>::value));
+      STATIC_ASSERT_SAME(iter_t::reference,  int);
+      STATIC_ASSERT_SAME(iter_t::value_type, float);
     }
 
     {
       typedef boost::transform_iterator<adaptable_mult_functor, int*, float, double> iter_t;
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference,  float>::value));
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, double>::value));
+      STATIC_ASSERT_SAME(iter_t::reference,  float);
+      STATIC_ASSERT_SAME(iter_t::value_type, double);
     }
   }
 

test/unit_tests.cpp

@@ -3,10 +3,10 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/static_assert.hpp>
 
 #include "static_assert_same.hpp"
 
+#include <type_traits>
 #include <boost/iterator/minimum_category.hpp>
 
 struct X { int a; };
@@ -38,32 +38,30 @@ void category_test()
     using namespace boost::iterators;
     using namespace boost::iterators::detail;
 
-    BOOST_STATIC_ASSERT((
-        !boost::is_convertible<
-            std::input_iterator_tag
-          , input_output_iterator_tag>::value));
+    static_assert(
+        !std::is_convertible<std::input_iterator_tag, input_output_iterator_tag>::value,
+        "std::input_iterator_tag is not expected to be convertible to input_output_iterator_tag.");
 
-    BOOST_STATIC_ASSERT((
-        !boost::is_convertible<
-            std::output_iterator_tag
-          , input_output_iterator_tag>::value));
+    static_assert(
+        !std::is_convertible<std::output_iterator_tag , input_output_iterator_tag>::value,
+        "std::output_iterator_tag is not expected to be convertible to input_output_iterator_tag.");
 
-    BOOST_STATIC_ASSERT((
-        boost::is_convertible<
-            input_output_iterator_tag
-          , std::input_iterator_tag>::value));
+    static_assert(
+        std::is_convertible<input_output_iterator_tag, std::input_iterator_tag>::value,
+        "input_output_iterator_tag is expected to be convertible to std::input_iterator_tag.");
 
-    BOOST_STATIC_ASSERT((
-        boost::is_convertible<
-            input_output_iterator_tag
-          , std::output_iterator_tag>::value));
+    static_assert(
+        std::is_convertible<input_output_iterator_tag, std::output_iterator_tag>::value,
+        "input_output_iterator_tag is expected to be convertible to std::output_iterator_tag.");
 
 #if 0 // This seems wrong; we're not advertising
       // input_output_iterator_tag are we?
-    BOOST_STATIC_ASSERT((
+    static_assert(
         boost::is_convertible<
             std::forward_iterator_tag
-          , input_output_iterator_tag>::value));
+          , input_output_iterator_tag
+        >::value,
+        "");
 #endif
 
     int test = static_assert_min_cat<
@@ -104,4 +102,3 @@ int main()
     operator_arrow_test();
     return 0;
 }
-