From f9effffb6dd6c602653f1a0a3058e6d15e3154c6 Mon Sep 17 00:00:00 2001 From: Georgy Guminov Date: Sun, 26 Jan 2025 15:17:36 +0300 Subject: [PATCH] Mostly remove pre-CXX11 workarounds. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ะก++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 741a627b736ba81fe0054e5bf373141b04a8a597 Author: Georgy Guminov Date: Sat Jan 25 12:13:05 2025 +0300 Replace testers with standard metafunctions. commit bf4cce611454713f1c8e5f46a2c3e599c548656d Author: Georgy Guminov Date: Sat Jan 25 11:51:32 2025 +0300 Refactor is_lvalue_iterator.hpp. commit 8d080c6c58726269cf55aedd64aa239f7d098fc7 Author: Georgy Guminov Date: Sat Jan 25 10:27:32 2025 +0300 Remove more workarounds. commit 5a4ba24d361ac0676d2cce95fdff22824ecdc287 Author: Georgy Guminov Date: Sun Jan 19 16:38:30 2025 +0300 Fixes. commit fdfafce2b9a71b1d85cbc697983652788f1c4bb7 Author: Georgy Guminov 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 c69ac1408af2fe5a105b288644367bbb6e0bc30d Author: Georgy Guminov Date: Sat Oct 26 14:48:51 2024 +0300 Correct static_assert messages. commit b5df827151a6d752168a59fa8c20c9ffd3766c0b Author: Georqy Guminov Date: Sun Jun 23 16:12:29 2024 +0300 Fixes. Remove some Boost.MPL usages. Remove unused includes. commit 01fd35e9f87d43f4bb46ed525a0e8eec46cba44a Author: Georgiy Guminov Date: Wed Jun 12 17:14:21 2024 +0300 abstract conjunction. commit c02def8acf68e0829082761d26955320974e5078 Author: Georgiy Guminov Date: Wed Jun 12 16:35:43 2024 +0300 return addressof & conjunction. commit 3b3d1625752cbe8c9ec62662e594a1af1fd9a458 Author: Georgiy Guminov Date: Wed Jun 12 16:30:44 2024 +0300 Make macro more readable. commit 4ab19e045fc535dc80228062d11bb6584ccd17ff Author: Georgiy Guminov Date: Wed Jun 12 15:56:49 2024 +0300 Add static_assert messages. commit 82b5c44cd34435d63af5cdbc7fcc1b07b39394de Author: Georgiy Guminov Date: Wed Jun 12 14:12:10 2024 +0300 Return is iterator CXX17 test. commit 2d58d65462e837430a0990c2a414d5c397e9fa31 Author: Georgiy Guminov Date: Tue Jun 11 14:04:17 2024 +0300 Omitted. commit a0d04d9491de818df990188436e04afc3ddba3ad Author: Georgiy Guminov Date: Tue Jun 11 14:00:35 2024 +0300 Replace move with static_cast commit 4a49b8a1a2d44d2da728dd064fe810ca86d8d1fd Author: Georgiy Guminov Date: Mon Jun 10 21:38:53 2024 +0300 Return BOOST_NOEXCEPT commit 054c013bba75c42710537a819de91d6abfe25658 Author: Georgiy Guminov Date: Sun Jun 9 15:20:41 2024 +0300 CXX11 --- CMakeLists.txt | 1 - build.jam | 1 - example/node_iterator2.hpp | 18 +- example/node_iterator3.hpp | 12 +- include/boost/generator_iterator.hpp | 2 +- include/boost/indirect_reference.hpp | 1 - include/boost/iterator/advance.hpp | 10 - include/boost/iterator/counting_iterator.hpp | 27 +- .../iterator/detail/any_conversion_eater.hpp | 21 -- include/boost/iterator/detail/config_def.hpp | 82 +----- .../boost/iterator/detail/config_undef.hpp | 6 +- include/boost/iterator/detail/enable_if.hpp | 83 ------ .../detail/facade_iterator_category.hpp | 76 +++-- .../iterator/detail/minimum_category.hpp | 19 -- .../detail/type_traits/conjunction.hpp | 53 ++++ .../detail/type_traits/disjunction.hpp | 53 ++++ .../iterator/detail/type_traits/negation.hpp | 53 ++++ include/boost/iterator/filter_iterator.hpp | 40 +-- .../iterator/function_input_iterator.hpp | 48 ++-- .../iterator/function_output_iterator.hpp | 24 +- include/boost/iterator/indirect_iterator.hpp | 25 +- include/boost/iterator/interoperable.hpp | 17 +- include/boost/iterator/is_iterator.hpp | 32 +-- include/boost/iterator/is_lvalue_iterator.hpp | 79 +---- .../boost/iterator/is_readable_iterator.hpp | 48 +--- include/boost/iterator/iterator_adaptor.hpp | 101 ++----- .../boost/iterator/iterator_archetypes.hpp | 36 +-- .../boost/iterator/iterator_categories.hpp | 34 +-- include/boost/iterator/iterator_concepts.hpp | 14 +- include/boost/iterator/iterator_facade.hpp | 269 +++++------------- include/boost/iterator/minimum_category.hpp | 13 +- include/boost/iterator/new_iterator_tests.hpp | 96 +++---- include/boost/iterator/transform_iterator.hpp | 39 +-- include/boost/iterator/zip_iterator.hpp | 9 +- include/boost/pending/iterator_tests.hpp | 16 +- include/boost/pointee.hpp | 30 +- test/counting_iterator_test.cpp | 5 +- test/filter_iterator_test.cpp | 11 +- test/function_input_iterator_test.cpp | 5 - test/function_output_iterator_test.cpp | 2 - test/indirect_iter_member_types.cpp | 24 +- test/indirect_iterator_test.cpp | 3 +- test/is_convertible_fail.cpp | 3 +- test/is_lvalue_iterator.cpp | 120 ++++---- test/is_readable_iterator.cpp | 35 ++- test/iterator_adaptor_cc.cpp | 2 +- test/iterator_adaptor_test.cpp | 45 ++- test/iterator_facade.cpp | 37 ++- test/iterator_traits_test.cpp | 6 +- test/minimum_category.cpp | 4 +- test/permutation_iterator_test.cpp | 4 +- test/pointee.cpp | 4 +- test/reverse_iterator_test.cpp | 2 +- test/static_assert_same.hpp | 5 +- test/transform_iterator_test.cpp | 22 +- test/unit_tests.cpp | 37 ++- 56 files changed, 683 insertions(+), 1181 deletions(-) delete mode 100644 include/boost/iterator/detail/any_conversion_eater.hpp delete mode 100644 include/boost/iterator/detail/enable_if.hpp delete mode 100644 include/boost/iterator/detail/minimum_category.hpp create mode 100644 include/boost/iterator/detail/type_traits/conjunction.hpp create mode 100644 include/boost/iterator/detail/type_traits/disjunction.hpp create mode 100644 include/boost/iterator/detail/type_traits/negation.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index a0dcf84..bedf55b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -24,7 +24,6 @@ target_link_libraries(boost_iterator Boost::mpl Boost::optional Boost::smart_ptr - Boost::static_assert Boost::type_traits Boost::utility ) diff --git a/build.jam b/build.jam index 88bf37f..9f47fcb 100644 --- a/build.jam +++ b/build.jam @@ -16,7 +16,6 @@ constant boost_dependencies : /boost/mpl//boost_mpl /boost/optional//boost_optional /boost/smart_ptr//boost_smart_ptr - /boost/static_assert//boost_static_assert /boost/type_traits//boost_type_traits /boost/utility//boost_utility ; diff --git a/example/node_iterator2.hpp b/example/node_iterator2.hpp index 1f5d834..86bfc9e 100644 --- a/example/node_iterator2.hpp +++ b/example/node_iterator2.hpp @@ -6,11 +6,7 @@ # include "node.hpp" # include - -# ifndef BOOST_NO_SFINAE -# include -# include -# endif +# include template class node_iter @@ -33,21 +29,13 @@ class node_iter template node_iter( node_iter const& other -# ifndef BOOST_NO_SFINAE - , typename boost::enable_if< - boost::is_convertible + , typename std::enable_if< + std::is_convertible::value , enabler >::type = enabler() -# endif ) : m_node(other.m_node) {} - -# if !BOOST_WORKAROUND(__GNUC__, == 2) - private: // GCC2 can't grant friendship to template member functions - friend class boost::iterator_core_access; -# endif - template bool equal(node_iter const& other) const { diff --git a/example/node_iterator3.hpp b/example/node_iterator3.hpp index 3ae7bec..9d224b4 100644 --- a/example/node_iterator3.hpp +++ b/example/node_iterator3.hpp @@ -6,11 +6,7 @@ # include "node.hpp" # include - -# ifndef BOOST_NO_SFINAE -# include -# include -# endif +# include template class node_iter @@ -38,12 +34,10 @@ class node_iter template node_iter( node_iter const& other -# ifndef BOOST_NO_SFINAE - , typename boost::enable_if< - boost::is_convertible + , typename std::enable_if< + std::is_convertible::value , enabler >::type = enabler() -# endif ) : super_t(other.base()) {} diff --git a/include/boost/generator_iterator.hpp b/include/boost/generator_iterator.hpp index 0fe1569..e5c2459 100644 --- a/include/boost/generator_iterator.hpp +++ b/include/boost/generator_iterator.hpp @@ -68,7 +68,7 @@ struct generator_iterator_generator template inline generator_iterator -make_generator_iterator(Generator & gen) +make_generator_iterator(Generator& gen) { typedef generator_iterator result_t; return result_t(&gen); diff --git a/include/boost/indirect_reference.hpp b/include/boost/indirect_reference.hpp index 3279cd0..21f0904 100644 --- a/include/boost/indirect_reference.hpp +++ b/include/boost/indirect_reference.hpp @@ -13,7 +13,6 @@ # include # include -# include # include # include diff --git a/include/boost/iterator/advance.hpp b/include/boost/iterator/advance.hpp index 2b74256..f20e159 100644 --- a/include/boost/iterator/advance.hpp +++ b/include/boost/iterator/advance.hpp @@ -29,12 +29,6 @@ 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 inline BOOST_CXX14_CONSTEXPR void advance_impl( @@ -57,10 +51,6 @@ namespace iterators { } } -#if BOOST_WORKAROUND(BOOST_GCC_VERSION, >= 40600) -#pragma GCC diagnostic pop -#endif - template inline BOOST_CXX14_CONSTEXPR void advance_impl( diff --git a/include/boost/iterator/counting_iterator.hpp b/include/boost/iterator/counting_iterator.hpp index 65c11e9..a05ca2c 100644 --- a/include/boost/iterator/counting_iterator.hpp +++ b/include/boost/iterator/counting_iterator.hpp @@ -5,19 +5,14 @@ #ifndef COUNTING_ITERATOR_DWA200348_HPP # define COUNTING_ITERATOR_DWA200348_HPP +# include + # include -# include +# include # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS # include -# elif !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) -# include -# else -# include # endif -# include # include -# include -# include # include # include @@ -38,8 +33,6 @@ namespace detail template struct is_numeric_impl { - // For a while, this wasn't true, but we rely on it below. This is a regression assert. - BOOST_STATIC_ASSERT(::boost::is_integral::value); # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS @@ -50,11 +43,11 @@ namespace detail # if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) BOOST_STATIC_CONSTANT( bool, value = ( - boost::is_convertible::value - && boost::is_convertible::value + std::is_convertible::value + && std::is_convertible::value )); # else - BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic::value); + BOOST_STATIC_CONSTANT(bool, value = std::is_arithmetic::value); # endif # endif @@ -62,7 +55,7 @@ namespace detail template struct is_numeric - : boost::integral_constant::value> + : std::integral_constant::value> {}; # if defined(BOOST_HAS_LONG_LONG) @@ -116,7 +109,7 @@ namespace detail { typedef typename detail::ia_dflt_help< CategoryOrTraversal - , typename boost::conditional< + , typename std::conditional< is_numeric::value , boost::type_identity , iterator_traversal @@ -125,7 +118,7 @@ namespace detail typedef typename detail::ia_dflt_help< Difference - , typename boost::conditional< + , typename std::conditional< is_numeric::value , numeric_difference , iterator_difference @@ -225,7 +218,7 @@ class counting_iterator difference_type distance_to(counting_iterator const& y) const { - typedef typename boost::conditional< + typedef typename std::conditional< detail::is_numeric::value , detail::number_distance , detail::iterator_distance diff --git a/include/boost/iterator/detail/any_conversion_eater.hpp b/include/boost/iterator/detail/any_conversion_eater.hpp deleted file mode 100644 index 429421f..0000000 --- a/include/boost/iterator/detail/any_conversion_eater.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright David Abrahams 2003. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -#ifndef ANY_CONVERSION_EATER_DWA20031117_HPP -# define ANY_CONVERSION_EATER_DWA20031117_HPP - -namespace boost { -namespace iterators { -namespace detail { - -// This type can be used in traits to "eat" up the one user-defined -// implicit conversion allowed. -struct any_conversion_eater -{ - template - any_conversion_eater(T const&); -}; - -}}} // namespace boost::iterators::detail - -#endif // ANY_CONVERSION_EATER_DWA20031117_HPP diff --git a/include/boost/iterator/detail/config_def.hpp b/include/boost/iterator/detail/config_def.hpp index bd04b75..06029e5 100644 --- a/include/boost/iterator/detail/config_def.hpp +++ b/include/boost/iterator/detail/config_def.hpp @@ -26,8 +26,7 @@ // 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(BOOST_BORLANDC, BOOST_TESTED_AT(0x531)) +#if 1 // Recall that in general, compilers without partial specialization // can't strip constness. Consider counting_iterator, which normally @@ -46,83 +45,4 @@ #endif -#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 - struct v {}; - - typedef char (&no)[3]; - - template - no foo(T const&, ...); - - template - char foo(T&, int); - - - struct value_iterator - { - v operator*() const; - }; - - template - struct lvalue_deref_helper - { - static T& x; - enum { value = (sizeof(foo(*x,0)) == 1) }; - }; - - int z2[(lvalue_deref_helper::value == 1) ? 1 : -1]; - int z[(lvalue_deref_helper::value) == 1 ? -1 : 1 ]; -# endif - -#endif - -#if BOOST_WORKAROUND(__MWERKS__, <=0x2407) -# define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types" -#endif - -#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \ - || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) -# define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile: - -# if 0 // test code - #include - template - struct foo - { - foo(T); - - template - foo(foo const& other) : p(other.p) { } - - T p; - }; - - bool x = boost::is_convertible, foo >::value; -# endif - -#endif - - -#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 - -# 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. -// -// Borland's problems are harder to diagnose due to lack of an -// 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 - // no include guard; multiple inclusion intended diff --git a/include/boost/iterator/detail/config_undef.hpp b/include/boost/iterator/detail/config_undef.hpp index a32529c..aca964b 100644 --- a/include/boost/iterator/detail/config_undef.hpp +++ b/include/boost/iterator/detail/config_undef.hpp @@ -11,11 +11,7 @@ // 23/02/03 thw // -#undef BOOST_NO_IS_CONVERTIBLE -#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE -#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY -#undef BOOST_NO_LVALUE_RETURN_DETECTION -#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP +#undef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY #ifdef BOOST_ITERATOR_CONFIG_DEF # undef BOOST_ITERATOR_CONFIG_DEF diff --git a/include/boost/iterator/detail/enable_if.hpp b/include/boost/iterator/detail/enable_if.hpp deleted file mode 100644 index dcc9adb..0000000 --- a/include/boost/iterator/detail/enable_if.hpp +++ /dev/null @@ -1,83 +0,0 @@ -// (C) Copyright David Abrahams 2002. -// (C) Copyright Jeremy Siek 2002. -// (C) Copyright Thomas Witt 2002. -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -#ifndef BOOST_ENABLE_IF_23022003THW_HPP -#define BOOST_ENABLE_IF_23022003THW_HPP - -#include -#include -#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) -#include -#endif - -// -// Boost iterators uses its own enable_if cause we need -// special semantics for deficient compilers. -// 23/02/03 thw -// - -namespace boost -{ - - namespace iterators - { - // - // Base machinery for all kinds of enable if - // - template - struct enabled - { - template - struct base - { - typedef T type; - }; - }; - - // - // For compilers that don't support "Substitution Failure Is Not An Error" - // enable_if falls back to always enabled. See comments - // on operator implementation for consequences. - // - template<> - struct enabled - { - template - struct base - { -#ifdef BOOST_NO_SFINAE - typedef T type; - - // This way to do it would give a nice error message containing - // invalid overload, but has the big disadvantage that - // there is no reference to user code in the error message. - // - // struct invalid_overload; - // typedef invalid_overload type; - // -#endif - }; - }; - - - template - struct enable_if -# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE) - : enabled<(Cond::value)>::template base -# else - : boost::type_identity -# endif - { - }; - - } // namespace iterators - -} // namespace boost - -#include - -#endif // BOOST_ENABLE_IF_23022003THW_HPP diff --git a/include/boost/iterator/detail/facade_iterator_category.hpp b/include/boost/iterator/detail/facade_iterator_category.hpp index 9d41320..f3f5848 100644 --- a/include/boost/iterator/detail/facade_iterator_category.hpp +++ b/include/boost/iterator/detail/facade_iterator_category.hpp @@ -8,19 +8,13 @@ # include -# include // used in iterator_tag inheritance logic -# include -# include # include # include -# include - -# include -# include -# include -# include +# include +# include +# include # include // try to keep this last # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY @@ -61,13 +55,13 @@ struct input_output_iterator_tag template struct iterator_writability_disabled # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic? - : mpl::or_< - is_const - , boost::detail::indirect_traits::is_reference_to_const - , is_const + : disjunction< + std::is_const + , std::integral_constant::value> + , std::is_const > # else - : is_const + : std::is_const # endif {}; @@ -83,25 +77,25 @@ struct iterator_writability_disabled template struct iterator_facade_default_category : mpl::eval_if< - mpl::and_< - is_reference - , is_convertible + detail::conjunction< + std::is_reference + , std::is_convertible > , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity - , mpl::if_< - is_convertible + , std::conditional< + std::is_convertible::value , std::bidirectional_iterator_tag , std::forward_iterator_tag > > - , typename mpl::eval_if< - mpl::and_< - is_convertible + , mpl::eval_if< + detail::conjunction< + std::is_convertible // check for readability - , is_convertible + , std::is_convertible > , mpl::identity , mpl::identity @@ -113,16 +107,16 @@ struct iterator_facade_default_category // True iff T is convertible to an old-style iterator category. template struct is_iterator_category - : mpl::or_< - is_convertible - , is_convertible + : disjunction< + std::is_convertible + , std::is_convertible > { }; template struct is_iterator_traversal - : is_convertible + : std::is_convertible {}; // @@ -138,18 +132,18 @@ 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_STATIC_ASSERT(( - !is_convertible< + static_assert( + !std::is_convertible< typename iterator_category_to_traversal::type , Traversal - >::value)); + >::value, + "Category transformed to corresponding traversal must be convertible to Traversal." + ); - BOOST_STATIC_ASSERT(is_iterator_category::value); - BOOST_STATIC_ASSERT(!is_iterator_category::value); - BOOST_STATIC_ASSERT(!is_iterator_traversal::value); -# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) - BOOST_STATIC_ASSERT(is_iterator_traversal::value); -# endif + static_assert(is_iterator_category::value, "Category must be an STL iterator category."); + static_assert(!is_iterator_category::value, "Traversal must not be an STL iterator category."); + static_assert(!is_iterator_traversal::value, "Category must not be a traversal tag."); + static_assert(is_iterator_traversal::value, "Traversal must be a traversal tag."); }; // Computes an iterator_category tag whose traversal is Traversal and @@ -157,17 +151,17 @@ struct iterator_category_with_traversal template struct facade_iterator_category_impl { - BOOST_STATIC_ASSERT(!is_iterator_category::value); + static_assert(!is_iterator_category::value, "Traversal must not be an STL iterator category."); typedef typename iterator_facade_default_category< Traversal,ValueParam,Reference >::type category; - typedef typename mpl::if_< - is_same< + typedef typename std::conditional< + std::is_same< Traversal , typename iterator_category_to_traversal::type - > + >::value , category , iterator_category_with_traversal >::type type; diff --git a/include/boost/iterator/detail/minimum_category.hpp b/include/boost/iterator/detail/minimum_category.hpp deleted file mode 100644 index 748c0d3..0000000 --- a/include/boost/iterator/detail/minimum_category.hpp +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright David Abrahams 2003. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -#ifndef MINIMUM_CATEGORY_DWA20031119_HPP -# define MINIMUM_CATEGORY_DWA20031119_HPP - -# include - -namespace boost { - -// This import below (as well as the whole header) is for backward compatibility -// with boost/token_iterator.hpp. It should be removed as soon as that header is fixed. -namespace detail { -using iterators::minimum_category; -} // namespace detail - -} // namespace boost - -#endif // MINIMUM_CATEGORY_DWA20031119_HPP diff --git a/include/boost/iterator/detail/type_traits/conjunction.hpp b/include/boost/iterator/detail/type_traits/conjunction.hpp new file mode 100644 index 0000000..9f61f4f --- /dev/null +++ b/include/boost/iterator/detail/type_traits/conjunction.hpp @@ -0,0 +1,53 @@ +/* + * 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) 2024 Georgiy Guminov + */ +/*! + * \file iterator/detail/type_traits/conjunction.hpp + * + * This header contains definition of \c conjunction type trait. + */ + +#ifndef BOOST_ITERATOR_DETAIL_TYPE_TRAITS_CONJUNCTION_HPP_INCLUDED_ +#define BOOST_ITERATOR_DETAIL_TYPE_TRAITS_CONJUNCTION_HPP_INCLUDED_ + +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if (defined(__cpp_lib_logical_traits) && (__cpp_lib_logical_traits >= 201510l)) || \ + (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 140) && (_MSC_FULL_VER >= 190023918) && (BOOST_CXX_VERSION >= 201703l)) + +namespace boost { +namespace iterators { +namespace detail { + +using std::conjunction; + +} // namespace detail +} // namespace iterator +} // namespace boost + +#else + +#include + +namespace boost { +namespace iterators { +namespace detail { + +using boost::conjunction; + +} // namespace detail +} // namespace iterator +} // namespace boost + +#endif + +#endif // BOOST_ITERATOR_DETAIL_TYPE_TRAITS_CONJUNCTION_HPP_INCLUDED_ diff --git a/include/boost/iterator/detail/type_traits/disjunction.hpp b/include/boost/iterator/detail/type_traits/disjunction.hpp new file mode 100644 index 0000000..e0d2ad3 --- /dev/null +++ b/include/boost/iterator/detail/type_traits/disjunction.hpp @@ -0,0 +1,53 @@ +/* + * 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) 2024 Georgiy Guminov + */ +/*! + * \file iterator/detail/type_traits/disjunction.hpp + * + * This header contains definition of \c disjunction type trait. + */ + +#ifndef BOOST_ITERATOR_DETAIL_TYPE_TRAITS_DISJUNCTION_HPP_INCLUDED_ +#define BOOST_ITERATOR_DETAIL_TYPE_TRAITS_DISJUNCTION_HPP_INCLUDED_ + +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if (defined(__cpp_lib_logical_traits) && (__cpp_lib_logical_traits >= 201510l)) || \ + (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 140) && (_MSC_FULL_VER >= 190023918) && (BOOST_CXX_VERSION >= 201703l)) + +namespace boost { +namespace iterators { +namespace detail { + +using std::disjunction; + +} // namespace detail +} // namespace iterator +} // namespace boost + +#else + +#include + +namespace boost { +namespace iterators { +namespace detail { + +using boost::disjunction; + +} // namespace detail +} // namespace iterator +} // namespace boost + +#endif + +#endif // BOOST_ITERATOR_DETAIL_TYPE_TRAITS_DISJUNCTION_HPP_INCLUDED_ diff --git a/include/boost/iterator/detail/type_traits/negation.hpp b/include/boost/iterator/detail/type_traits/negation.hpp new file mode 100644 index 0000000..9be4b6e --- /dev/null +++ b/include/boost/iterator/detail/type_traits/negation.hpp @@ -0,0 +1,53 @@ +/* + * 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) 2024 Georgiy Guminov + */ +/*! + * \file iterator/detail/type_traits/negation.hpp + * + * This header contains definition of \c negation type trait. + */ + +#ifndef BOOST_ITERATOR_DETAIL_TYPE_TRAITS_NEGATION_HPP_INCLUDED_ +#define BOOST_ITERATOR_DETAIL_TYPE_TRAITS_NEGATION_HPP_INCLUDED_ + +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if (defined(__cpp_lib_logical_traits) && (__cpp_lib_logical_traits >= 201510l)) || \ + (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 140) && (_MSC_FULL_VER >= 190023918) && (BOOST_CXX_VERSION >= 201703l)) + +namespace boost { +namespace iterators { +namespace detail { + +using std::negation; + +} // namespace detail +} // namespace iterator +} // namespace boost + +#else + +#include + +namespace boost { +namespace iterators { +namespace detail { + +using boost::negation; + +} // namespace detail +} // namespace iterator +} // namespace boost + +#endif + +#endif // BOOST_ITERATOR_DETAIL_TYPE_TRAITS_NEGATION_HPP_INCLUDED_ diff --git a/include/boost/iterator/filter_iterator.hpp b/include/boost/iterator/filter_iterator.hpp index 18c6186..133fffe 100644 --- a/include/boost/iterator/filter_iterator.hpp +++ b/include/boost/iterator/filter_iterator.hpp @@ -7,19 +7,11 @@ #ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP #define BOOST_FILTER_ITERATOR_23022003THW_HPP +#include + #include #include - -#include -#include -#include -#include - -#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 +#include namespace boost { namespace iterators { @@ -36,11 +28,11 @@ namespace iterators { filter_iterator , Iterator , use_default - , typename mpl::if_< - is_convertible< + , typename std::conditional< + std::is_convertible< typename iterator_traversal::type , random_access_traversal_tag - > + >::value , bidirectional_traversal_tag , use_default >::type @@ -62,21 +54,17 @@ namespace iterators { filter_iterator() { } filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator()) - : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f)), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_)) + : super_t(static_cast(x)), m_predicate(static_cast(f)), m_end(static_cast(end_)) { satisfy_predicate(); } filter_iterator(Iterator x, Iterator end_ = Iterator()) - : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_)) + : super_t(static_cast(x)), m_predicate(), m_end(static_cast(end_)) { - // Pro8 is a little too aggressive about instantiating the - // body of this function. -#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) // Don't allow use of this constructor if Predicate is a // function pointer type, since it will be 0. - BOOST_STATIC_ASSERT(is_class::value); -#endif + static_assert(std::is_class::value, "Predicate must be a class."); satisfy_predicate(); } @@ -119,19 +107,19 @@ namespace iterators { inline filter_iterator make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator()) { - return filter_iterator(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f), BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end)); + return filter_iterator(static_cast(f), static_cast(x), static_cast(end)); } template inline filter_iterator make_filter_iterator( - typename iterators::enable_if< - is_class + typename std::enable_if< + std::is_class::value , Iterator >::type x , Iterator end = Iterator()) { - return filter_iterator(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end)); + return filter_iterator(static_cast(x), static_cast(end)); } } // namespace iterators @@ -141,6 +129,4 @@ using iterators::make_filter_iterator; } // namespace boost -#undef BOOST_ITERATOR_DETAIL_MOVE - #endif // BOOST_FILTER_ITERATOR_23022003THW_HPP diff --git a/include/boost/iterator/function_input_iterator.hpp b/include/boost/iterator/function_input_iterator.hpp index 610c133..be72a42 100644 --- a/include/boost/iterator/function_input_iterator.hpp +++ b/include/boost/iterator/function_input_iterator.hpp @@ -9,10 +9,10 @@ #ifndef BOOST_FUNCTION_INPUT_ITERATOR #define BOOST_FUNCTION_INPUT_ITERATOR +#include +#include + #include -#include -#include -#include #include #include #include @@ -20,10 +20,6 @@ #include #include -#ifdef BOOST_RESULT_OF_USE_TR1 -#include -#endif - namespace boost { namespace iterators { @@ -41,7 +37,7 @@ namespace iterators { { typedef typename result_of< #ifdef BOOST_RESULT_OF_USE_TR1 - typename boost::conditional::value, F&, F>::type() + typename std::conditional::value, F&, F>::type() #else F&() #endif @@ -54,13 +50,13 @@ namespace iterators { iterators::function_input_iterator, typename result_of_nullary_lvalue_call::type, single_pass_traversal_tag, - typename result_of_nullary_lvalue_call::type const & + typename result_of_nullary_lvalue_call::type const& > { public: function_object_input_iterator() {} - function_object_input_iterator(Function & f_, Input state_ = Input()) - : f(boost::addressof(f_)), state(state_) {} + function_object_input_iterator(Function& f_, Input state_ = Input()) + : f(std::addressof(f_)), state(state_) {} void increment() { if (value) @@ -70,14 +66,14 @@ namespace iterators { ++state; } - typename result_of_nullary_lvalue_call::type const & + typename result_of_nullary_lvalue_call::type const& dereference() const { if (!value) value = (*f)(); return value.get(); } - bool equal(function_object_input_iterator const & other) const { + bool equal(function_object_input_iterator const& other) const { return f == other.f && state == other.state; } @@ -93,12 +89,12 @@ namespace iterators { iterators::function_input_iterator, typename function_types::result_type::type, single_pass_traversal_tag, - typename function_types::result_type::type const & + typename function_types::result_type::type const& > { public: function_pointer_input_iterator() {} - function_pointer_input_iterator(Function &f_, Input state_ = Input()) + function_pointer_input_iterator(Function& f_, Input state_ = Input()) : f(f_), state(state_) {} void increment() { @@ -109,14 +105,14 @@ namespace iterators { ++state; } - typename function_types::result_type::type const & + typename function_types::result_type::type const& dereference() const { if (!value) value = (*f)(); return value.get(); } - bool equal(function_pointer_input_iterator const & other) const { + bool equal(function_pointer_input_iterator const& other) const { return f == other.f && state == other.state; } @@ -130,42 +126,42 @@ namespace iterators { template class function_input_iterator : - public boost::conditional< + public std::conditional< function_types::is_function_pointer::value, impl::function_pointer_input_iterator, impl::function_object_input_iterator >::type { - typedef typename boost::conditional< + typedef typename std::conditional< function_types::is_function_pointer::value, impl::function_pointer_input_iterator, impl::function_object_input_iterator >::type base_type; public: - function_input_iterator(Function & f, Input i) + function_input_iterator(Function& f, Input i) : base_type(f, i) {} }; template inline function_input_iterator - make_function_input_iterator(Function & f, Input state) { + make_function_input_iterator(Function& f, Input state) { typedef function_input_iterator result_t; return result_t(f, state); } template inline function_input_iterator - make_function_input_iterator(Function * f, Input state) { + make_function_input_iterator(Function* f, Input state) { typedef function_input_iterator result_t; return result_t(f, state); } struct infinite { - infinite & operator++() { return *this; } - infinite & operator++(int) { return *this; } - bool operator==(infinite &) const { return false; }; - bool operator==(infinite const &) const { return false; }; + infinite& operator++() { return *this; } + infinite& operator++(int) { return *this; } + bool operator==(infinite&) const { return false; }; + bool operator==(infinite const&) const { return false; }; }; } // namespace iterators diff --git a/include/boost/iterator/function_output_iterator.hpp b/include/boost/iterator/function_output_iterator.hpp index ea2a668..d562475 100644 --- a/include/boost/iterator/function_output_iterator.hpp +++ b/include/boost/iterator/function_output_iterator.hpp @@ -13,13 +13,9 @@ #include #include +#include + #include -#include -#include -#include -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES -#include -#endif namespace boost { namespace iterators { @@ -33,25 +29,15 @@ namespace iterators { public: explicit output_proxy(UnaryFunction& f) BOOST_NOEXCEPT : m_f(f) { } -#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES template - typename boost::disable_if_c< - boost::is_same< typename boost::remove_cv< T >::type, output_proxy >::value, - output_proxy const& - >::type operator=(const T& value) const { - m_f(value); - return *this; - } -#else - template - typename boost::disable_if_c< - boost::is_same< typename boost::remove_cv< typename boost::remove_reference< T >::type >::type, output_proxy >::value, + + typename std::enable_if< + !std::is_same< typename std::remove_cv< typename std::remove_reference< T >::type >::type, output_proxy >::value, output_proxy const& >::type operator=(T&& value) const { 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&)) diff --git a/include/boost/iterator/indirect_iterator.hpp b/include/boost/iterator/indirect_iterator.hpp index e15ac87..e3ef075 100644 --- a/include/boost/iterator/indirect_iterator.hpp +++ b/include/boost/iterator/indirect_iterator.hpp @@ -14,25 +14,12 @@ #include -#include -#include - -#include #include #include -#include #include #include - -#ifdef BOOST_MPL_CFG_NO_HAS_XXX -# include -# include -# include -# include -#endif - -#include // must be last #include +#include namespace boost { namespace iterators { @@ -57,9 +44,9 @@ namespace iterators { , typename ia_dflt_help< Reference , mpl::eval_if< - is_same + std::is_same , indirect_reference - , add_reference + , std::add_lvalue_reference > >::type , Difference @@ -111,11 +98,7 @@ namespace iterators { private: typename super_t::reference dereference() const { -# if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x5A0 ) - return const_cast(**this->base()); -# else return **this->base(); -# endif } }; @@ -140,6 +123,4 @@ using iterators::make_indirect_iterator; } // namespace boost -#include - #endif // BOOST_INDIRECT_ITERATOR_23022003THW_HPP diff --git a/include/boost/iterator/interoperable.hpp b/include/boost/iterator/interoperable.hpp index 6f3c872..5b9fd6f 100644 --- a/include/boost/iterator/interoperable.hpp +++ b/include/boost/iterator/interoperable.hpp @@ -7,12 +7,7 @@ #ifndef BOOST_INTEROPERABLE_23022003THW_HPP # define BOOST_INTEROPERABLE_23022003THW_HPP -# include -# include - -# include - -# include // must appear last +# include namespace boost { namespace iterators { @@ -33,13 +28,7 @@ namespace iterators { // template struct is_interoperable -# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY - : mpl::true_ -# else - : mpl::or_< - is_convertible< A, B > - , is_convertible< B, A > > -# endif + : detail::disjunction, std::is_convertible> { }; @@ -49,6 +38,4 @@ using iterators::is_interoperable; } // namespace boost -# include - #endif // BOOST_INTEROPERABLE_23022003THW_HPP diff --git a/include/boost/iterator/is_iterator.hpp b/include/boost/iterator/is_iterator.hpp index 5740b19..d9830a0 100644 --- a/include/boost/iterator/is_iterator.hpp +++ b/include/boost/iterator/is_iterator.hpp @@ -16,15 +16,15 @@ #include #include -#include -#include -#include #include -#include +#include +#include #if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS) #include #endif +#include + #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif @@ -59,56 +59,56 @@ no_type check(...); template< typename T > struct is_iterator_impl : - public boost::integral_constant< + public std::integral_constant< bool, - sizeof(has_iterator_category_detail::check< T >(0)) == sizeof(has_iterator_category_detail::yes_type) + sizeof(has_iterator_category_detail::check(0)) == sizeof(has_iterator_category_detail::yes_type) > { }; template< typename T > struct is_iterator_impl< T* > : - public boost::conjunction< - boost::is_complete< T >, - boost::negation< boost::is_function< T > > + public conjunction< + boost::is_complete, + negation< std::is_function< T > > >::type { }; template< typename T, typename U > struct is_iterator_impl< T U::* > : - public boost::false_type + public std::false_type { }; template< typename T > -struct is_iterator_impl< T& > : - public boost::false_type +struct is_iterator_impl : + public std::false_type { }; template< typename T, std::size_t N > struct is_iterator_impl< T[N] > : - public boost::false_type + public std::false_type { }; #if !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE) template< typename T > struct is_iterator_impl< T[] > : - public boost::false_type + public std::false_type { }; template< > struct is_iterator_impl< void > : - public boost::false_type + public std::false_type { }; template< > struct is_iterator_impl< void* > : - public boost::false_type + public std::false_type { }; #endif // !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE) diff --git a/include/boost/iterator/is_lvalue_iterator.hpp b/include/boost/iterator/is_lvalue_iterator.hpp index 46f0483..3e4b22f 100644 --- a/include/boost/iterator/is_lvalue_iterator.hpp +++ b/include/boost/iterator/is_lvalue_iterator.hpp @@ -6,18 +6,11 @@ #include -#include -#include -#include +#include #include #include - -// should be the last #includes -#include -#include - -#ifndef BOOST_NO_IS_CONVERTIBLE +#include namespace boost { @@ -25,61 +18,23 @@ namespace iterators { namespace detail { -#ifndef BOOST_NO_LVALUE_RETURN_DETECTION - // Calling lvalue_preserver( , 0 ) returns a reference - // to the expression's result if is an lvalue, or - // not_an_lvalue() otherwise. - struct not_an_lvalue {}; - - template - T& lvalue_preserver(T&, int); - - template - not_an_lvalue lvalue_preserver(U const&, ...); - -# define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0) - -#else - -# define BOOST_LVALUE_PRESERVER(expr) expr - -#endif - // Guts of is_lvalue_iterator. Value is the iterator's value_type // and the result is computed in the nested rebind template. template struct is_lvalue_iterator_impl - { - // Eat implicit conversions so we don't report true for things - // convertible to Value const& - struct conversion_eater - { - conversion_eater(typename add_lvalue_reference::type); - }; - - static char tester(conversion_eater, int); - static char (& tester(any_conversion_eater, ...) )[2]; + { + template + using DerefT = decltype(*std::declval()); template - struct rebind + struct rebind : detail::conjunction< + std::is_convertible, typename std::add_lvalue_reference::type> + , std::is_lvalue_reference> + >::type { - static It& x; - - BOOST_STATIC_CONSTANT( - bool - , value = ( - sizeof( - is_lvalue_iterator_impl::tester( - BOOST_LVALUE_PRESERVER(*x), 0 - ) - ) == 1 - ) - ); }; }; -#undef BOOST_LVALUE_PRESERVER - // // void specializations to handle std input and output iterators // @@ -87,7 +42,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -96,7 +51,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -104,7 +59,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -112,7 +67,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; #endif @@ -137,14 +92,14 @@ namespace detail } // namespace detail template< typename T > struct is_lvalue_iterator -: public ::boost::integral_constant::value> +: public std::integral_constant::value> { public: BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_lvalue_iterator,(T)) }; template< typename T > struct is_non_const_lvalue_iterator -: public ::boost::integral_constant::value> +: public std::integral_constant::value> { public: BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T)) @@ -157,8 +112,4 @@ using iterators::is_non_const_lvalue_iterator; } // namespace boost -#endif - -#include - #endif // IS_LVALUE_ITERATOR_DWA2003112_HPP diff --git a/include/boost/iterator/is_readable_iterator.hpp b/include/boost/iterator/is_readable_iterator.hpp index 26827c4..698f2ff 100644 --- a/include/boost/iterator/is_readable_iterator.hpp +++ b/include/boost/iterator/is_readable_iterator.hpp @@ -4,19 +4,10 @@ #ifndef IS_READABLE_ITERATOR_DWA2003112_HPP # define IS_READABLE_ITERATOR_DWA2003112_HPP -#include #include -#include - -#include #include - -// should be the last #include -#include -#include - -#ifndef BOOST_NO_IS_CONVERTIBLE +#include namespace boost { @@ -29,27 +20,14 @@ namespace detail template struct is_readable_iterator_impl { - static char tester(typename add_lvalue_reference::type, int); - static char (& tester(any_conversion_eater, ...) )[2]; - template - struct rebind - { - static It& x; - - BOOST_STATIC_CONSTANT( - bool - , value = ( - sizeof( - is_readable_iterator_impl::tester(*x, 1) - ) == 1 - ) - ); - }; + struct rebind : std::is_convertible< + decltype(*std::declval()) + , typename std::add_lvalue_reference::type + > + {}; }; -#undef BOOST_READABLE_PRESERVER - // // void specializations to handle std input and output iterators // @@ -57,7 +35,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -66,7 +44,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -74,7 +52,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -82,7 +60,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; #endif @@ -100,7 +78,7 @@ namespace detail } // namespace detail template< typename T > struct is_readable_iterator -: public ::boost::integral_constant::value> +: public std::integral_constant::value> { public: BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T)) @@ -112,8 +90,4 @@ using iterators::is_readable_iterator; } // namespace boost -#endif - -#include - #endif // IS_READABLE_ITERATOR_DWA2003112_HPP diff --git a/include/boost/iterator/iterator_adaptor.hpp b/include/boost/iterator/iterator_adaptor.hpp index db1c4da..7106f3b 100644 --- a/include/boost/iterator/iterator_adaptor.hpp +++ b/include/boost/iterator/iterator_adaptor.hpp @@ -7,30 +7,16 @@ #ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP -#include - #include +#include + #include #include -#include - -#include -#include -#include - -#include -#include - -#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY -# include -#endif - -#include -#include - #include +#include + namespace boost { namespace iterators { @@ -41,13 +27,6 @@ namespace iterators { } // namespace iterators -// the incompleteness of use_default causes massive problems for -// is_convertible (naturally). This workaround is fortunately not -// needed for vc6/vc7. -template -struct is_convertible - : mpl::false_ {}; - namespace iterators { namespace detail @@ -102,41 +81,14 @@ namespace iterators { // false positives for user/library defined iterator types. See comments // on operator implementation for consequences. // -# if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE) - - template - struct enable_if_convertible - { - typedef boost::iterators::detail::enable_type type; - }; - -# elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) - - // For some reason vc7.1 needs us to "cut off" instantiation - // of is_convertible in a few cases. template struct enable_if_convertible - : iterators::enable_if< - mpl::or_< - is_same - , is_convertible - > - , boost::iterators::detail::enable_type - > - {}; - -# else - - template - struct enable_if_convertible - : iterators::enable_if< - is_convertible + : std::enable_if< + std::is_convertible::value , boost::iterators::detail::enable_type > {}; -# endif - // // Default template argument handling for iterator_adaptor // @@ -147,7 +99,7 @@ namespace iterators { template struct ia_dflt_help : mpl::eval_if< - is_same + std::is_same , DefaultNullaryFn , mpl::identity > @@ -173,9 +125,9 @@ namespace iterators { , typename boost::iterators::detail::ia_dflt_help< Value , mpl::eval_if< - is_same + std::is_same , iterator_value - , remove_reference + , std::remove_reference > >::type # else @@ -192,9 +144,9 @@ namespace iterators { , typename boost::iterators::detail::ia_dflt_help< Reference , mpl::eval_if< - is_same + std::is_same , iterator_reference - , add_reference + , std::add_lvalue_reference > >::type @@ -204,13 +156,6 @@ namespace iterators { > type; }; - - // workaround for aC++ CR JAGaf33512 - template - inline void iterator_adaptor_assert_traversal () - { - BOOST_STATIC_ASSERT((is_convertible::value)); - } } // @@ -220,7 +165,7 @@ namespace iterators { // versions of iterator_adaptor The idea is that when the user needs // to fiddle with the reference type it is highly likely that the // iterator category has to be adjusted as well. Any of the - // following four template arguments may be ommitted or explicitly + // following four template arguments may be omitted or explicitly // replaced by use_default. // // Value - if supplied, the value_type of the resulting iterator, unless @@ -260,7 +205,7 @@ namespace iterators { public: iterator_adaptor() {} - explicit iterator_adaptor(Base const &iter) + explicit iterator_adaptor(Base const& iter) : m_iterator(iter) { } @@ -309,12 +254,12 @@ namespace iterators { typename super_t::iterator_category >::type my_traversal; -# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \ - boost::iterators::detail::iterator_adaptor_assert_traversal(); - void advance(typename super_t::difference_type n) { - BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) + static_assert( + std::is_convertible::value, + "Iterator must support random access traversal." + ); m_iterator += n; } @@ -322,7 +267,10 @@ namespace iterators { void decrement() { - BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag) + static_assert( + std::is_convertible::value, + "Iterator must support bidirectional traversal." + ); --m_iterator; } @@ -332,7 +280,10 @@ namespace iterators { typename super_t::difference_type distance_to( iterator_adaptor const& y) const { - BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) + static_assert( + std::is_convertible::value, + "Super iterator must support random access traversal." + ); // Maybe readd with same_distance // BOOST_STATIC_ASSERT( // (detail::same_category_and_difference::value) @@ -340,8 +291,6 @@ namespace iterators { return y.base() - m_iterator; } -# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL - private: // data members Base m_iterator; }; diff --git a/include/boost/iterator/iterator_archetypes.hpp b/include/boost/iterator/iterator_archetypes.hpp index 1d25915..6696445 100644 --- a/include/boost/iterator/iterator_archetypes.hpp +++ b/include/boost/iterator/iterator_archetypes.hpp @@ -8,23 +8,17 @@ #include #include -#include #include -#include -#include -#include -#include +#include #include #include #include #include -#include #include -#include #include #include @@ -119,18 +113,18 @@ namespace detail template struct operator_brackets : mpl::eval_if< - is_convertible + std::is_convertible , mpl::eval_if< archetypes::has_access< AccessCategory , archetypes::writable_iterator_t > , mpl::identity > - , mpl::if_< + , std::conditional< archetypes::has_access< AccessCategory , archetypes::readable_iterator_t - > + >::value , readable_operator_brackets , no_operator_brackets > @@ -280,9 +274,9 @@ namespace detail template struct convertible_type - : mpl::if_< is_const, - typename remove_const::type, - bogus_type > + : std::conditional< std::is_const::value, + typename std::remove_const::type, + bogus_type > {}; } // namespace detail @@ -312,9 +306,9 @@ struct iterator_access_archetype_impl< template struct archetype { - typedef typename remove_cv::type value_type; - typedef Value reference; - typedef Value* pointer; + typedef typename std::remove_cv::type value_type; + typedef Value reference; + typedef Value* pointer; value_type operator*() const { return static_object::get(); } @@ -330,7 +324,7 @@ struct iterator_access_archetype_impl< template struct archetype { - BOOST_STATIC_ASSERT(!is_const::value); + static_assert(!std::is_const::value, "Value type must not be const."); typedef void value_type; typedef void reference; typedef void pointer; @@ -381,7 +375,7 @@ struct iterator_access_archetype_impl Value, archetypes::readable_lvalue_iterator_t > { - BOOST_STATIC_ASSERT((!is_const::value)); + static_assert(!std::is_const::value, "Value type must not be const."); }; }; @@ -392,7 +386,7 @@ struct iterator_archetype; template struct traversal_archetype_base : detail::operator_brackets< - typename remove_cv::type + typename std::remove_cv::type , AccessCategory , TraversalCategory > @@ -419,8 +413,8 @@ namespace detail archetypes::has_access< AccessCategory, archetypes::writable_iterator_t > - , remove_const - , add_const + , std::remove_const + , std::add_const >::type , typename access::reference >::type iterator_category; diff --git a/include/boost/iterator/iterator_categories.hpp b/include/boost/iterator/iterator_categories.hpp index baf805a..34c02ef 100644 --- a/include/boost/iterator/iterator_categories.hpp +++ b/include/boost/iterator/iterator_categories.hpp @@ -6,20 +6,12 @@ #ifndef BOOST_ITERATOR_CATEGORIES_HPP # define BOOST_ITERATOR_CATEGORIES_HPP -# include -# include - -# include - # include # include # include # include -# include - -# include - +#include #include namespace boost { @@ -77,19 +69,19 @@ namespace detail template struct old_category_to_traversal : mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , void > @@ -107,7 +99,7 @@ namespace detail template struct iterator_category_to_traversal : mpl::eval_if< // if already convertible to a traversal tag, we're done. - is_convertible + std::is_convertible , mpl::identity , boost::iterators::detail::old_category_to_traversal > @@ -146,19 +138,19 @@ struct iterator_traversal template struct pure_traversal_tag : mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , mpl::eval_if< - is_convertible + std::is_convertible , mpl::identity , void > @@ -211,6 +203,4 @@ using iterators::pure_traversal_tag; } // namespace boost -#include - #endif // BOOST_ITERATOR_CATEGORIES_HPP diff --git a/include/boost/iterator/iterator_concepts.hpp b/include/boost/iterator/iterator_concepts.hpp index 3c65553..0fca163 100644 --- a/include/boost/iterator/iterator_concepts.hpp +++ b/include/boost/iterator/iterator_concepts.hpp @@ -9,15 +9,7 @@ #include #include -#include -#include - -#include -#include -#include -#include - -#include +#include // Use boost/limits to work around missing limits headers on some compilers #include @@ -144,8 +136,8 @@ namespace boost_concepts { typedef typename std::iterator_traits::difference_type difference_type; - BOOST_STATIC_ASSERT(boost::is_integral::value); - BOOST_STATIC_ASSERT(std::numeric_limits::is_signed); + static_assert(std::is_integral::value, "difference_type must be integral."); + static_assert(std::numeric_limits::is_signed, "difference_type must be signed."); BOOST_CONCEPT_ASSERT(( boost::Convertible< diff --git a/include/boost/iterator/iterator_facade.hpp b/include/boost/iterator/iterator_facade.hpp index c4b5ae4..0833c10 100644 --- a/include/boost/iterator/iterator_facade.hpp +++ b/include/boost/iterator/iterator_facade.hpp @@ -8,37 +8,24 @@ #define BOOST_ITERATOR_FACADE_23022003THW_HPP #include + #include #include #include - #include -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include #include -#include -#include -#include -#include + #include #include #include +#include #include - -#include // this goes last +#include +#include namespace boost { namespace iterators { @@ -64,7 +51,7 @@ namespace iterators { // The type trait checks if the category or traversal is at least as advanced as the specified required traversal template< typename CategoryOrTraversal, typename Required > struct is_traversal_at_least : - public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required > + public std::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required > {}; // @@ -76,8 +63,8 @@ namespace iterators { , class Return > struct enable_if_interoperable : - public boost::iterators::enable_if< - is_interoperable< Facade1, Facade2 > + public std::enable_if< + is_interoperable::value , Return > {}; @@ -91,12 +78,12 @@ namespace iterators { , class Return > struct enable_if_interoperable_and_random_access_traversal : - public boost::iterators::enable_if< - mpl::and_< + public std::enable_if< + detail::conjunction< is_interoperable< Facade1, Facade2 > , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag > , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag > - > + >::value , Return > {}; @@ -117,31 +104,14 @@ namespace iterators { CategoryOrTraversal, ValueParam, Reference >::type iterator_category; - typedef typename remove_const::type value_type; + typedef typename std::remove_const::type value_type; // Not the real associated pointer type typedef typename mpl::eval_if< boost::iterators::detail::iterator_writability_disabled - , add_pointer - , add_pointer + , std::add_pointer + , std::add_pointer >::type pointer; - -# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ - && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452)) \ - || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310))) \ - || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101)) \ - || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310) - - // To interoperate with some broken library/compiler - // combinations, user-defined iterators must be derived from - // std::iterator. It is possible to implement a standard - // library for broken compilers without this limitation. -# define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1 - - typedef - iterator - base; -# endif }; // iterators whose dereference operators reference the same value @@ -180,7 +150,7 @@ namespace iterators { // Provides (r++)->foo() value_type* operator->() const { - return boost::addressof(stored_value); + return std::addressof(stored_value); } private: @@ -240,38 +210,15 @@ namespace iterators { } // Provides writability of *r++ -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) template - typename iterators::enable_if< - is_not_writable_postfix_increment_dereference_proxy< T >, + typename std::enable_if< + is_not_writable_postfix_increment_dereference_proxy::value, writable_postfix_increment_dereference_proxy const& >::type operator=(T&& x) const { *this->stored_iterator = static_cast< T&& >(x); return *this; } -#else - template - 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 - 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; @@ -303,49 +250,21 @@ namespace iterators { // Provides (r++)->foo() value_type* operator->() const { - return boost::addressof(dereference_proxy.stored_value); + return std::addressof(dereference_proxy.stored_value); } private: writable_postfix_increment_dereference_proxy dereference_proxy; }; -# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - template - struct is_non_proxy_reference_impl - { - static Reference r; - - template - static typename mpl::if_< - is_convertible< - R const volatile* - , Value const volatile* - > - , char[1] - , char[2] - >::type& helper(R const&); - - BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1); - }; - template struct is_non_proxy_reference - : mpl::bool_< - is_non_proxy_reference_impl::value - > - {}; -# else - template - struct is_non_proxy_reference - : is_convertible< - typename remove_reference::type + : std::is_convertible< + typename std::remove_reference::type const volatile* , Value const volatile* > {}; -# endif // A metafunction to choose the result type of postfix ++ // @@ -365,22 +284,22 @@ namespace iterators { template struct postfix_increment_result : mpl::eval_if< - mpl::and_< + detail::conjunction< // A proxy is only needed for readable iterators - is_convertible< + std::is_convertible< Reference // Use add_lvalue_reference to form `reference to Value` due to // some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject // 'reference-to-reference' in the template which described in CWG // DR106. // http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106 - , typename add_lvalue_reference::type + , typename std::add_lvalue_reference::type > // No multipass iterator can have values that disappear // before positions can be re-visited - , mpl::not_< - is_convertible< + , detail::negation< + std::is_convertible< typename iterator_category_to_traversal::type , forward_traversal_tag > @@ -404,15 +323,15 @@ namespace iterators { { struct proxy { - explicit proxy(Reference const & x) : m_ref(x) {} - Reference* operator->() { return boost::addressof(m_ref); } + explicit proxy(Reference const& x) : m_ref(x) {} + Reference* operator->() { return std::addressof(m_ref); } // This function is needed for MWCW and BCC, which won't call // operator-> again automatically per 13.3.1.2 para 8 - operator Reference*() { return boost::addressof(m_ref); } + operator Reference*() { return std::addressof(m_ref); } Reference m_ref; }; typedef proxy result_type; - static result_type apply(Reference const & x) + static result_type apply(Reference const& x) { return result_type(x); } @@ -424,7 +343,7 @@ namespace iterators { typedef Pointer result_type; static result_type apply(T& x) { - return boost::addressof(x); + return std::addressof(x); } }; @@ -463,11 +382,10 @@ namespace iterators { // proxy, or whether it can simply return a copy of the value_type. template struct use_operator_brackets_proxy - : mpl::not_< - mpl::and_< - // Really we want an is_copy_constructible trait here, - // but is_POD will have to suffice in the meantime. - boost::is_POD + : detail::negation< + detail::conjunction< + std::is_copy_constructible + , std::is_trivial , iterator_writability_disabled > > @@ -476,41 +394,34 @@ namespace iterators { template struct operator_brackets_result { - typedef typename mpl::if_< - use_operator_brackets_proxy + typedef typename std::conditional< + use_operator_brackets_proxy::value , operator_brackets_proxy , Value >::type type; }; template - operator_brackets_proxy make_operator_brackets_result(Iterator const& iter, mpl::true_) + operator_brackets_proxy make_operator_brackets_result(Iterator const& iter, std::true_type) { return operator_brackets_proxy(iter); } template - typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_) + typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, std::false_type) { - return *iter; + return *iter; } struct choose_difference_type { template - struct apply - : -# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP - iterator_difference -# else - mpl::eval_if< - is_convertible - , iterator_difference - , iterator_difference - > -# endif + struct apply : mpl::eval_if< + std::is_convertible + , iterator_difference + , iterator_difference + > {}; - }; template < @@ -528,17 +439,6 @@ namespace iterators { // Macros which describe the declarations of binary operators -# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY -# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \ - template < \ - class Derived1, class V1, class TC1, class Reference1, class Difference1 \ - , class Derived2, class V2, class TC2, class Reference2, class Difference2 \ - > \ - prefix typename mpl::apply2::type \ - operator op( \ - iterator_facade const& lhs \ - , iterator_facade const& rhs) -# else # define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \ template < \ class Derived1, class V1, class TC1, class Reference1, class Difference1 \ @@ -551,7 +451,6 @@ namespace iterators { operator op( \ iterator_facade const& lhs \ , iterator_facade const& rhs) -# endif # define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \ BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable) @@ -561,9 +460,12 @@ namespace iterators { # define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \ template \ - prefix typename boost::iterators::enable_if< \ - boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, \ - Derived \ + prefix typename std::enable_if< \ + boost::iterators::detail::is_traversal_at_least< \ + TC \ + , boost::iterators::random_access_traversal_tag \ + >::value \ + , Derived \ >::type operator+ args // @@ -577,12 +479,6 @@ namespace iterators { // class iterator_core_access { -# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) - // Tasteless as this may seem, making all members public allows member templates - // to work in the absence of member template friends. - public: -# else - template friend class iterator_facade; template friend class detail::iterator_facade_base; @@ -623,8 +519,6 @@ namespace iterators { ) ; -# endif - template static typename Facade::reference dereference(Facade const& f) { @@ -644,13 +538,13 @@ namespace iterators { } template - static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_) + static bool equal(Facade1 const& f1, Facade2 const& f2, std::true_type) { return f1.equal(f2); } template - static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_) + static bool equal(Facade1 const& f1, Facade2 const& f2, std::false_type) { return f2.equal(f1); } @@ -663,14 +557,14 @@ namespace iterators { template static typename Facade1::difference_type distance_from( - Facade1 const& f1, Facade2 const& f2, mpl::true_) + Facade1 const& f1, Facade2 const& f2, std::true_type) { return -f1.distance_to(f2); } template static typename Facade2::difference_type distance_from( - Facade1 const& f1, Facade2 const& f2, mpl::false_) + Facade1 const& f1, Facade2 const& f2, std::false_type) { return f2.distance_to(f1); } @@ -705,12 +599,6 @@ namespace iterators { , class Difference > class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false > -# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE - : public boost::iterators::detail::iterator_facade_types< - Value, CategoryOrTraversal, Reference, Difference - >::base -# undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE -# endif { private: typedef boost::iterators::detail::iterator_facade_types< @@ -811,11 +699,11 @@ namespace iterators { typename boost::iterators::detail::operator_brackets_result::type operator[](difference_type n) const { - typedef boost::iterators::detail::use_operator_brackets_proxy use_proxy; + using use_proxy = boost::iterators::detail::use_operator_brackets_proxy; return boost::iterators::detail::make_operator_brackets_result( this->derived() + n - , use_proxy() + , std::integral_constant{} ); } @@ -950,19 +838,11 @@ namespace iterators { // ---------------- // -# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP -# define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_() -# else -# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() -# endif +# define BOOST_ITERATOR_CONVERTIBLE(a,b) std::is_convertible() # define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \ BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type) \ { \ - /* For those compilers that do not support enable_if */ \ - BOOST_STATIC_ASSERT(( \ - is_interoperable< Derived1, Derived2 >::value \ - )); \ return_prefix iterator_core_access::base_op( \ *static_cast(&lhs) \ , *static_cast(&rhs) \ @@ -973,7 +853,7 @@ namespace iterators { # define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \ BOOST_ITERATOR_FACADE_INTEROP( \ op \ - , boost::iterators::detail::always_bool2 \ + , boost::iterators::detail::always_bool2 \ , return_prefix \ , base_op \ ) @@ -986,26 +866,21 @@ namespace iterators { # define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type) \ - { \ - /* For those compilers that do not support enable_if */ \ - BOOST_STATIC_ASSERT(( \ - is_interoperable< Derived1, Derived2 >::value && \ - boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \ - boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \ - )); \ - return_prefix iterator_core_access::base_op( \ - *static_cast(&lhs) \ - , *static_cast(&rhs) \ - , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ - ); \ + { \ + using boost::iterators::detail::is_traversal_at_least; \ + return_prefix iterator_core_access::base_op( \ + *static_cast(&lhs) \ + , *static_cast(&rhs) \ + , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ + ); \ } # define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( \ - op \ - , boost::iterators::detail::always_bool2 \ - , return_prefix \ - , base_op \ + op \ + , boost::iterators::detail::always_bool2 \ + , return_prefix \ + , base_op \ ) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from) @@ -1057,6 +932,4 @@ using iterators::iterator_facade; } // namespace boost -#include - #endif // BOOST_ITERATOR_FACADE_23022003THW_HPP diff --git a/include/boost/iterator/minimum_category.hpp b/include/boost/iterator/minimum_category.hpp index 15679bc..913cec4 100644 --- a/include/boost/iterator/minimum_category.hpp +++ b/include/boost/iterator/minimum_category.hpp @@ -4,9 +4,7 @@ #ifndef BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_ # define BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_ -# include -# include -# include +# include # include # include @@ -44,7 +42,10 @@ struct minimum_category_impl { template struct apply { - BOOST_STATIC_ASSERT((is_same::value)); + static_assert( + std::is_same::value, + "Iterator category types must be the same when they are equivalent." + ); typedef T1 type; }; }; @@ -68,8 +69,8 @@ template struct minimum_category { typedef boost::iterators::detail::minimum_category_impl< - ::boost::is_convertible::value - , ::boost::is_convertible::value + std::is_convertible::value + , std::is_convertible::value > outer; typedef typename outer::template apply inner; diff --git a/include/boost/iterator/new_iterator_tests.hpp b/include/boost/iterator/new_iterator_tests.hpp index 2091e59..9981b3d 100644 --- a/include/boost/iterator/new_iterator_tests.hpp +++ b/include/boost/iterator/new_iterator_tests.hpp @@ -1,5 +1,5 @@ #ifndef BOOST_NEW_ITERATOR_TESTS_HPP -# define BOOST_NEW_ITERATOR_TESTS_HPP +#define BOOST_NEW_ITERATOR_TESTS_HPP // // Copyright (c) David Abrahams 2001. @@ -28,50 +28,45 @@ // 04 Feb 2001 Added lvalue test, corrected preconditions // (David Abrahams) -# include -# include -# include // for detail::dummy_constructor -# include -# include -# include -# include -# include -# include +#include // for detail::dummy_constructor +#include +#include +#include +#include +#include +#include -# include -# include -# include +#include +#include namespace boost { - // Do separate tests for *i++ so we can treat, e.g., smart pointers, // as readable and/or writable iterators. template -void readable_iterator_traversal_test(Iterator i1, T v, mpl::true_) +void readable_iterator_traversal_test(Iterator i1, T v, std::true_type) { T v2(*i1++); BOOST_TEST(v == v2); } template -void readable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) +void readable_iterator_traversal_test(const Iterator i1, T v, std::false_type) {} template -void writable_iterator_traversal_test(Iterator i1, T v, mpl::true_) +void writable_iterator_traversal_test(Iterator i1, T v, std::true_type) { - ++i1; // we just wrote into that position + ++i1; // we just wrote into that position *i1++ = v; Iterator x(i1++); (void)x; } template -void writable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) +void writable_iterator_traversal_test(const Iterator i1, T v, std::false_type) {} - // Preconditions: *i == v template void readable_iterator_test(const Iterator i1, T v) @@ -85,28 +80,28 @@ void readable_iterator_test(const Iterator i1, T v) BOOST_TEST(v1 == v); BOOST_TEST(v2 == v); -# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) - readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable()); + readable_iterator_traversal_test( + i1, v, + std::integral_constant< + bool, detail::is_postfix_incrementable::value>{}); // I think we don't really need this as it checks the same things as // the above code. - BOOST_STATIC_ASSERT(is_readable_iterator::value); -# endif + static_assert(is_readable_iterator::value, + "Iterator must be readable."); } template -void writable_iterator_test(Iterator i, T v, T v2) -{ +void writable_iterator_test(Iterator i, T v, T v2) { Iterator i2(i); // Copy Constructible *i2 = v; -# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) writable_iterator_traversal_test( - i, v2, mpl::and_< - detail::is_incrementable - , detail::is_postfix_incrementable + i, v2, + iterators::detail::conjunction< + std::integral_constant::value>, + std::integral_constant::value> >()); -# endif } template @@ -120,40 +115,43 @@ void swappable_iterator_test(Iterator i, Iterator j) } template -void constant_lvalue_iterator_test(Iterator i, T v1) -{ +void constant_lvalue_iterator_test(Iterator i, T v1) { Iterator i2(i); typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::reference reference; - BOOST_STATIC_ASSERT((is_same::value)); + static_assert(std::is_same::value, + "reference type must be the same as const value_type& for " + "constant lvalue iterator."); const T& v2 = *i2; BOOST_TEST(v1 == v2); -# ifndef BOOST_NO_LVALUE_RETURN_DETECTION - BOOST_STATIC_ASSERT(is_lvalue_iterator::value); - BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator::value); -# endif +#ifndef BOOST_NO_LVALUE_RETURN_DETECTION + static_assert(is_lvalue_iterator::value + && !is_non_const_lvalue_iterator::value, + "Iterator must be a const lvalue iterator."); +#endif } template -void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) -{ +void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) { Iterator i2(i); typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::reference reference; - BOOST_STATIC_ASSERT((is_same::value)); + static_assert(std::is_same::value, + "reference type must be the same as value_type& for " + "non-constant lvalue iterator."); T& v3 = *i2; BOOST_TEST(v1 == v3); - // A non-const lvalue iterator is not neccessarily writable, but we + // A non-const lvalue iterator is not necessarily 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::value); - BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator::value); -# endif + static_assert(is_lvalue_iterator::value, + "Iterator must be an lvalue iterator."); + static_assert(is_non_const_lvalue_iterator::value, + "Iterator must be non-const."); } template @@ -226,7 +224,7 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) const Iterator j = i; int c; - for (c = 0; c < N-1; ++c) + for (c = 0; c < N - 1; ++c) { BOOST_TEST(i == j + c); BOOST_TEST(*i == vals[c]); @@ -242,7 +240,7 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) } Iterator k = j + N - 1; - for (c = 0; c < N-1; ++c) + for (c = 0; c < N - 1; ++c) { BOOST_TEST(i == k - c); BOOST_TEST(*i == vals[N - 1 - c]); @@ -260,6 +258,4 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) } // namespace boost -# include - #endif // BOOST_NEW_ITERATOR_TESTS_HPP diff --git a/include/boost/iterator/transform_iterator.hpp b/include/boost/iterator/transform_iterator.hpp index 5b2b810..fa10a27 100644 --- a/include/boost/iterator/transform_iterator.hpp +++ b/include/boost/iterator/transform_iterator.hpp @@ -9,30 +9,13 @@ #include #include -#include #include #include -#include -#include -#include -#include -#include -#include -#include #include +#include #include -#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) -#include -#endif - -#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) -#include -#endif - -#include - namespace boost { namespace iterators { @@ -103,7 +86,7 @@ namespace iterators { #if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) // don't provide this constructor if UnaryFunc is a // function pointer type, since it will be 0. Too dangerous. - BOOST_STATIC_ASSERT(is_class::value); + static_assert(std::is_class::value, "Transform function must not be a function pointer."); #endif } @@ -115,9 +98,7 @@ namespace iterators { transform_iterator( transform_iterator const& t , typename enable_if_convertible::type* = 0 -#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) , typename enable_if_convertible::type* = 0 -#endif ) : super_t(t.base()), m_f(t.functor()) {} @@ -149,24 +130,14 @@ namespace iterators { // function pointer in the iterator be 0, leading to a runtime // crash. template - inline typename iterators::enable_if< - is_class // We should probably find a cheaper test than is_class<> + inline typename std::enable_if< + std::is_class::value // We should probably find a cheaper test than is_class<> , transform_iterator >::type make_transform_iterator(Iterator it) { return transform_iterator(it, UnaryFunc()); } - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - template - inline transform_iterator< Return (*)(Argument), Iterator, Return> - make_transform_iterator(Iterator it, Return (*fun)(Argument)) - { - return transform_iterator(it, fun); - } -#endif - } // namespace iterators using iterators::transform_iterator; @@ -174,6 +145,4 @@ using iterators::make_transform_iterator; } // namespace boost -#include - #endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP diff --git a/include/boost/iterator/zip_iterator.hpp b/include/boost/iterator/zip_iterator.hpp index f5780ae..87695a5 100644 --- a/include/boost/iterator/zip_iterator.hpp +++ b/include/boost/iterator/zip_iterator.hpp @@ -8,25 +8,20 @@ #ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_ # define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_ -#include #include #include #include // for enable_if_convertible #include - #include #include // for std::pair -#include // for backward compatibility - -#include -#include #include #include #include #include +#include // for backward compatibility #include #include #include @@ -83,7 +78,7 @@ namespace iterators { struct result { typedef typename - remove_cv::type>::type + std::remove_cv::type>::type iterator; typedef typename iterator_reference::type type; diff --git a/include/boost/pending/iterator_tests.hpp b/include/boost/pending/iterator_tests.hpp index a683683..6c50b9d 100644 --- a/include/boost/pending/iterator_tests.hpp +++ b/include/boost/pending/iterator_tests.hpp @@ -20,13 +20,10 @@ // (David Abrahams) # include -# include +# include # include // for detail::dummy_constructor # include # include -# include -# include -# include namespace boost { @@ -143,10 +140,11 @@ template struct lvalue_test typedef typename Iterator::reference reference; typedef typename Iterator::value_type value_type; # endif - BOOST_STATIC_ASSERT(boost::is_reference::value); - BOOST_STATIC_ASSERT((boost::is_same::value - || boost::is_same::value - )); + static_assert(std::is_reference::value, "reference must be a reference type."); + static_assert( + std::is_same::value || std::is_same::value, + "reference must either be a reference to value_type or constant reference to value_type." + ); } }; @@ -180,7 +178,7 @@ void forward_iterator_test(Iterator i, T v1, T v2) // borland doesn't allow non-type template parameters # if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551) - lvalue_test<(boost::is_pointer::value)>::check(i); + lvalue_test::value>::check(i); #endif } diff --git a/include/boost/pointee.hpp b/include/boost/pointee.hpp index 69efa94..e040894 100644 --- a/include/boost/pointee.hpp +++ b/include/boost/pointee.hpp @@ -15,12 +15,10 @@ # include # include -# include -# include -# include # include #include +#include namespace boost { @@ -36,26 +34,12 @@ namespace detail struct iterator_pointee { typedef typename std::iterator_traits::value_type value_type; - - struct impl - { - template - static char test(T const&); - - static char (& test(value_type&) )[2]; - - static Iterator& x; - }; - - BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1); - - typedef typename mpl::if_c< -# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) - ::boost::detail::iterator_pointee::is_constant -# else - is_constant -# endif - , typename add_const::type + + typedef typename std::conditional< + std::is_const< + typename std::remove_reference())>::type + >::value + , typename std::add_const::type , value_type >::type type; }; diff --git a/test/counting_iterator_test.cpp b/test/counting_iterator_test.cpp index 09d4295..d26938a 100644 --- a/test/counting_iterator_test.cpp +++ b/test/counting_iterator_test.cpp @@ -30,13 +30,12 @@ #include #include -#include #include #include #include -#include #include +#include #include #ifndef BOOST_BORLANDC # include @@ -68,7 +67,7 @@ struct unsigned_assert_nonnegative template struct assert_nonnegative - : boost::conditional< + : std::conditional< std::numeric_limits::is_signed , signed_assert_nonnegative , unsigned_assert_nonnegative diff --git a/test/filter_iterator_test.cpp b/test/filter_iterator_test.cpp index cf850bc..be34c3b 100644 --- a/test/filter_iterator_test.cpp +++ b/test/filter_iterator_test.cpp @@ -7,15 +7,14 @@ #include #include #include -#include #include #include #include #include #include +#include #include -#include 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::type , boost::random_access_traversal_tag - >::value - )); + >::value, + "Filter interator must have a random_access_traversal_tag."); //# endif diff --git a/test/function_input_iterator_test.cpp b/test/function_input_iterator_test.cpp index f64e9f5..6668d83 100644 --- a/test/function_input_iterator_test.cpp +++ b/test/function_input_iterator_test.cpp @@ -11,14 +11,12 @@ #include -#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 #include @@ -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(42 + i)); -#endif // BOOST_NO_CXX11_LAMBDAS return boost::report_errors(); } diff --git a/test/function_output_iterator_test.cpp b/test/function_output_iterator_test.cpp index c18592d..c55c160 100644 --- a/test/function_output_iterator_test.cpp +++ b/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 ) { diff --git a/test/indirect_iter_member_types.cpp b/test/indirect_iter_member_types.cpp index 240e664..86b893f 100644 --- a/test/indirect_iter_member_types.cpp +++ b/test/indirect_iter_member_types.cpp @@ -9,12 +9,10 @@ #include -#include #include -#include #include "static_assert_same.hpp" -#include +#include 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::value)); - BOOST_STATIC_ASSERT((boost::is_convertible::type, - boost::random_access_traversal_tag>::value)); + static_assert(std::is_convertible::value, + "Iter must have a random access category."); + static_assert(std::is_convertible::type, + boost::random_access_traversal_tag>::value, + "Iter must have a random_access_traversal_tag."); } { typedef boost::indirect_iterator Iter; @@ -71,10 +71,12 @@ int main() STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t); - BOOST_STATIC_ASSERT((boost::is_convertible::value)); - BOOST_STATIC_ASSERT((boost::is_convertible::type, - boost::random_access_traversal_tag>::value)); + static_assert(std::is_convertible::value, + "Iter must have a random access category."); + static_assert(std::is_convertible::type, + boost::random_access_traversal_tag>::value, + "Iter must have a random_access_traversal_tag."); } { typedef boost::indirect_iterator Iter; diff --git a/test/indirect_iterator_test.cpp b/test/indirect_iterator_test.cpp index a08afa8..d7b4e6d 100644 --- a/test/indirect_iterator_test.cpp +++ b/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). diff --git a/test/is_convertible_fail.cpp b/test/is_convertible_fail.cpp index 757b5c6..89255fc 100644 --- a/test/is_convertible_fail.cpp +++ b/test/is_convertible_fail.cpp @@ -8,12 +8,13 @@ // #include #include +#include int main() { typedef boost::reverse_iterator rev_iter1; typedef boost::reverse_iterator rev_iter2; - return boost::is_convertible::value + return std::is_convertible::value ? boost::exit_failure : boost::exit_success; } diff --git a/test/is_lvalue_iterator.cpp b/test/is_lvalue_iterator.cpp index 16de014..6a41600 100644 --- a/test/is_lvalue_iterator.cpp +++ b/test/is_lvalue_iterator.cpp @@ -4,15 +4,10 @@ #include #include -#include #include // std::ptrdiff_t -#include #include #include -// Last, for BOOST_NO_LVALUE_RETURN_DETECTION -#include - 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::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator::iterator>::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator::const_iterator>::value); - BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator > >::value); - BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator >::value); -#ifndef BOOST_NO_LVALUE_RETURN_DETECTION - BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator::value); -#endif + static_assert(boost::is_lvalue_iterator::value, + "boost::is_lvalue_iterator::value is expected to be true."); + static_assert(boost::is_lvalue_iterator::value, + "boost::is_lvalue_iterator::value is expected to be true."); + static_assert(boost::is_lvalue_iterator::iterator>::value, + "boost::is_lvalue_iterator::iterator>::value."); + static_assert(boost::is_lvalue_iterator::const_iterator>::value, + "boost::is_lvalue_iterator::const_iterator>::value is expected to be true."); + static_assert(!boost::is_lvalue_iterator>>::value, + "boost::is_lvalue_iterator>>::value is expected to be false."); + static_assert(!boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_lvalue_iterator::value, + "boost::is_lvalue_iterator::value is expected to be false."); // Make sure inaccessible copy constructor doesn't prevent // reference binding - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator::value); + static_assert(boost::is_lvalue_iterator::value, + "boost::is_lvalue_iterator::value is expected to be true."); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator >::value); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_lvalue_iterator>::value is expected to be true."); - BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator::value); - BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator::iterator>::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator::const_iterator>::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator > >::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator >::value); -#ifndef BOOST_NO_LVALUE_RETURN_DETECTION - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator::value); -#endif - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator::value); + static_assert(boost::is_non_const_lvalue_iterator::value, + "boost::is_non_const_lvalue_iterator::value is expected to be true."); + static_assert(!boost::is_non_const_lvalue_iterator::value, + "boost::is_non_const_lvalue_iterator::value is expected to be false."); + static_assert(boost::is_non_const_lvalue_iterator::iterator>::value, + "boost::is_non_const_lvalue_iterator::iterator>::value is expected to be true."); + static_assert(!boost::is_non_const_lvalue_iterator::const_iterator>::value, + "boost::is_non_const_lvalue_iterator::const_iterator>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator>>::value, + "boost::is_non_const_lvalue_iterator>>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator::value, + "boost::is_non_const_lvalue_iterator::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator::value, + "boost::is_non_const_lvalue_iterator::value is expected to be false."); - BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator >::value); -#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) - BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator >::value); -#endif - BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator >::value); + static_assert(boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be true."); + static_assert(boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be true."); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator >::value); - BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator >::value); + static_assert(!boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be false."); + static_assert(!boost::is_non_const_lvalue_iterator>::value, + "boost::is_non_const_lvalue_iterator>::value is expected to be false."); return 0; } diff --git a/test/is_readable_iterator.cpp b/test/is_readable_iterator.cpp index 1d33a64..d25d060 100644 --- a/test/is_readable_iterator.cpp +++ b/test/is_readable_iterator.cpp @@ -4,15 +4,10 @@ #include #include -#include #include // std::ptrdiff_t -#include #include #include -// Last, for BOOST_NO_LVALUE_RETURN_DETECTION -#include - struct v { v(); @@ -78,19 +73,29 @@ struct proxy_iterator2 int main() { - BOOST_STATIC_ASSERT(boost::is_readable_iterator::value); - BOOST_STATIC_ASSERT(boost::is_readable_iterator::value); - BOOST_STATIC_ASSERT(boost::is_readable_iterator::iterator>::value); - BOOST_STATIC_ASSERT(boost::is_readable_iterator::const_iterator>::value); - BOOST_STATIC_ASSERT(!boost::is_readable_iterator > >::value); - BOOST_STATIC_ASSERT(!boost::is_readable_iterator >::value); - BOOST_STATIC_ASSERT(boost::is_readable_iterator::value); - BOOST_STATIC_ASSERT(!boost::is_readable_iterator::value); - BOOST_STATIC_ASSERT(boost::is_readable_iterator::value); + static_assert(boost::is_readable_iterator::value, + "boost::is_readable_iterator::value is expected to be true."); + static_assert(boost::is_readable_iterator::value, + "boost::is_readable_iterator::value is expected to be true."); + static_assert(boost::is_readable_iterator::iterator>::value, + "boost::is_readable_iterator::iterator>::value is expected to be true."); + static_assert(boost::is_readable_iterator::const_iterator>::value, + "boost::is_readable_iterator::const_iterator>::value is expected to be true."); + static_assert(!boost::is_readable_iterator>>::value, + "boost::is_readable_iterator>>::value is expected to be false."); + static_assert(!boost::is_readable_iterator>::value, + "boost::is_readable_iterator>::value is expected to be false."); + static_assert(boost::is_readable_iterator::value, + "boost::is_readable_iterator::value is expected to be true."); + static_assert(!boost::is_readable_iterator::value, + "boost::is_readable_iterator::value is expected to be false."); + static_assert(boost::is_readable_iterator::value, + "boost::is_readable_iterator::value is expected to be true."); // Make sure inaccessible copy constructor doesn't prevent // readability - BOOST_STATIC_ASSERT(boost::is_readable_iterator::value); + static_assert(boost::is_readable_iterator::value, + "boost::is_readable_iterator::value is expected to be true."); return 0; } diff --git a/test/iterator_adaptor_cc.cpp b/test/iterator_adaptor_cc.cpp index 2ea7582..6b0b73c 100644 --- a/test/iterator_adaptor_cc.cpp +++ b/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) { diff --git a/test/iterator_adaptor_test.cpp b/test/iterator_adaptor_test.cpp index 4b37c14..9ed8385 100644 --- a/test/iterator_adaptor_test.cpp +++ b/test/iterator_adaptor_test.cpp @@ -13,10 +13,8 @@ #include #include -#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) -# include -# include -#endif +#include +#include #include # include @@ -29,8 +27,6 @@ #include "static_assert_same.hpp" -#include - using boost::dummyT; typedef std::deque 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::value; test = static_assert_same::value; test = static_assert_same::value; -#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) - BOOST_STATIC_ASSERT((boost::is_convertible::value)); -#endif + static_assert( + std::is_convertible::value, + "Iterator must have a random access category." + ); } { @@ -219,16 +210,10 @@ main() test = static_assert_same::value; test = static_assert_same::value; -#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) - BOOST_STATIC_ASSERT(boost::is_readable_iterator::value); -# ifndef BOOST_NO_LVALUE_RETURN_DETECTION - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator::value); -# endif -#endif + static_assert(boost::is_readable_iterator::value, "Iter1 is expected to be readable."); + static_assert(boost::is_lvalue_iterator::value, "Iter1 is expected to be lvalue iterator."); -#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness test = static_assert_same::value; -#endif } { @@ -238,14 +223,16 @@ main() test = static_assert_same::value; test = static_assert_same::value; -#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness test = static_assert_same::value; -#endif -#ifndef BOOST_NO_LVALUE_RETURN_DETECTION - BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator::value); - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator::value); -#endif + static_assert( + boost::is_non_const_lvalue_iterator::value, + "boost::is_non_const_lvalue_iterator::value is expected to be true." + ); + static_assert( + boost::is_lvalue_iterator::value, + "boost::is_lvalue_iterator::value is expected to be true." + ); typedef modify_traversal IncrementableIter; diff --git a/test/iterator_facade.cpp b/test/iterator_facade.cpp index 7351dd3..a216e55 100644 --- a/test/iterator_facade.cpp +++ b/test/iterator_facade.cpp @@ -8,8 +8,9 @@ #include #include -#include -#include +#include + +#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 wrapper(const wrapper& other, - typename boost::enable_if< boost::is_convertible >::type* = 0) + typename std::enable_if< std::is_convertible::value >::type* = 0) : m_x(other.m_x) { } }; @@ -144,19 +145,15 @@ struct iterator_with_proxy_reference { return wrapper(m_x); } }; -template -void same_type(U const&) -{ BOOST_STATIC_ASSERT((boost::is_same::value)); } - template struct abstract_iterator : boost::iterator_facade< abstract_iterator - , 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(b).state; + state = dynamic_cast(b).state; } - virtual bool equal(const base &b) const + virtual bool equal(const base& b) const { - return state == dynamic_cast(b).state; + return state == dynamic_cast(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(p.operator->()); + STATIC_ASSERT_SAME(input_iter::pointer, std::remove_cv())>::type>::type); } { diff --git a/test/iterator_traits_test.cpp b/test/iterator_traits_test.cpp index 40da049..d2b84c3 100644 --- a/test/iterator_traits_test.cpp +++ b/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 #include -#include #include #include #include #include #include -#include +#include // A UDT for which we can specialize std::iterator_traits on // compilers which don't support partial specialization. There's no @@ -98,7 +96,7 @@ template <> struct assertion template struct assert_same - : assertion<(::boost::is_same::value)> + : assertion<(std::is_same::value)> { }; diff --git a/test/minimum_category.cpp b/test/minimum_category.cpp index 3f89d6c..54f7e7a 100644 --- a/test/minimum_category.cpp +++ b/test/minimum_category.cpp @@ -6,10 +6,10 @@ #include #include -#include #include +#include -using boost::is_same; +using std::is_same; using boost::iterators::minimum_category; int main(int, char*[]) diff --git a/test/permutation_iterator_test.cpp b/test/permutation_iterator_test.cpp index 81cdefe..db601e8 100644 --- a/test/permutation_iterator_test.cpp +++ b/test/permutation_iterator_test.cpp @@ -8,7 +8,6 @@ #include #include -#include #include #include @@ -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); } diff --git a/test/pointee.cpp b/test/pointee.cpp index 32e3496..4e54599 100644 --- a/test/pointee.cpp +++ b/test/pointee.cpp @@ -3,10 +3,10 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #include -#include #include "static_assert_same.hpp" #include #include +#include template struct proxy_ptr @@ -27,7 +27,7 @@ struct proxy_ref_ptr : proxy_ptr template struct proxy_value_ptr : proxy_ptr { - typedef typename boost::add_const::type element_type; + typedef typename std::add_const::type element_type; }; struct X { diff --git a/test/reverse_iterator_test.cpp b/test/reverse_iterator_test.cpp index c2e4a41..4be9734 100644 --- a/test/reverse_iterator_test.cpp +++ b/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) diff --git a/test/static_assert_same.hpp b/test/static_assert_same.hpp index 5d96da9..12d5066 100644 --- a/test/static_assert_same.hpp +++ b/test/static_assert_same.hpp @@ -5,10 +5,9 @@ #ifndef STATIC_ASSERT_SAME_DWA2003530_HPP # define STATIC_ASSERT_SAME_DWA2003530_HPP -#include -#include +#include -#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::value, "T1 and T2 are expected to be the same types.") template struct static_assert_same diff --git a/test/transform_iterator_test.cpp b/test/transform_iterator_test.cpp index b22cb16..d9b8a66 100644 --- a/test/transform_iterator_test.cpp +++ b/test/transform_iterator_test.cpp @@ -21,15 +21,7 @@ #include #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -namespace boost { namespace detail -{ - template<> struct function_object_result - { - 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 iter_t; - BOOST_STATIC_ASSERT((boost::is_same::value)); - BOOST_STATIC_ASSERT((boost::is_same::value)); + STATIC_ASSERT_SAME(iter_t::reference, float); + STATIC_ASSERT_SAME(iter_t::value_type, float); } { typedef boost::transform_iterator iter_t; - BOOST_STATIC_ASSERT((boost::is_same::value)); - BOOST_STATIC_ASSERT((boost::is_same::value)); + STATIC_ASSERT_SAME(iter_t::reference, int); + STATIC_ASSERT_SAME(iter_t::value_type, float); } { typedef boost::transform_iterator iter_t; - BOOST_STATIC_ASSERT((boost::is_same::value)); - BOOST_STATIC_ASSERT((boost::is_same::value)); + STATIC_ASSERT_SAME(iter_t::reference, float); + STATIC_ASSERT_SAME(iter_t::value_type, double); } } diff --git a/test/unit_tests.cpp b/test/unit_tests.cpp index 656e72f..76bbffb 100644 --- a/test/unit_tests.cpp +++ b/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 -#include #include "static_assert_same.hpp" +#include #include 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::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::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::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::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; } -