diff --git a/CMakeLists.txt b/CMakeLists.txt index a0dcf8477..bedf55ba3 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 88bf37ff6..9f47fcba1 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 1f5d834ab..86bfc9e35 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 3ae7bec5a..9d224b43c 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/indirect_reference.hpp b/include/boost/indirect_reference.hpp index 3279cd052..21f090403 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/counting_iterator.hpp b/include/boost/iterator/counting_iterator.hpp index 65c11e94b..a05ca2c52 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/config_def.hpp b/include/boost/iterator/detail/config_def.hpp index bd04b75d8..dd0c96d09 100644 --- a/include/boost/iterator/detail/config_def.hpp +++ b/include/boost/iterator/detail/config_def.hpp @@ -46,7 +46,7 @@ #endif -#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x5A0)) \ +#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x5A0)) \ || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \ || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) @@ -92,7 +92,7 @@ # define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile: # if 0 // test code - #include + #include template struct foo { @@ -104,16 +104,11 @@ T p; }; - bool x = boost::is_convertible, foo >::value; + bool x = std::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 diff --git a/include/boost/iterator/detail/config_undef.hpp b/include/boost/iterator/detail/config_undef.hpp index a32529c02..b1ebc658b 100644 --- a/include/boost/iterator/detail/config_undef.hpp +++ b/include/boost/iterator/detail/config_undef.hpp @@ -13,7 +13,6 @@ #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 diff --git a/include/boost/iterator/detail/enable_if.hpp b/include/boost/iterator/detail/enable_if.hpp deleted file mode 100644 index dcc9adb73..000000000 --- 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 9d41320f6..7bac8d6c8 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 + 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 + 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,17 +132,19 @@ 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); + 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."); # if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) - BOOST_STATIC_ASSERT(is_iterator_traversal::value); + static_assert(is_iterator_traversal::value, "Traversal must be a traversal tag."); # endif }; @@ -157,17 +153,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/type_traits/conjunction.hpp b/include/boost/iterator/detail/type_traits/conjunction.hpp new file mode 100644 index 000000000..9f61f4fee --- /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 000000000..e0d2ad333 --- /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 000000000..9be4b6e91 --- /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 18c6186aa..34549a813 100644 --- a/include/boost/iterator/filter_iterator.hpp +++ b/include/boost/iterator/filter_iterator.hpp @@ -7,20 +7,14 @@ #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 - namespace boost { namespace iterators { @@ -36,11 +30,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,20 +56,20 @@ 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); + static_assert(std::is_class::value, "Predicate must be a class."); #endif satisfy_predicate(); } @@ -119,19 +113,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< + 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 diff --git a/include/boost/iterator/function_input_iterator.hpp b/include/boost/iterator/function_input_iterator.hpp index 610c1338f..dcda07cd1 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 @@ -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 @@ -60,7 +56,7 @@ namespace iterators { public: function_object_input_iterator() {} function_object_input_iterator(Function & f_, Input state_ = Input()) - : f(boost::addressof(f_)), state(state_) {} + : f(addressof(f_)), state(state_) {} void increment() { if (value) @@ -130,13 +126,13 @@ 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 diff --git a/include/boost/iterator/function_output_iterator.hpp b/include/boost/iterator/function_output_iterator.hpp index ea2a668bb..d562475ce 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 e15ac87e4..ff02c4206 100644 --- a/include/boost/iterator/indirect_iterator.hpp +++ b/include/boost/iterator/indirect_iterator.hpp @@ -14,21 +14,16 @@ #include -#include -#include - -#include #include #include -#include #include #include +#include #ifdef BOOST_MPL_CFG_NO_HAS_XXX # include # include -# include # include #endif @@ -57,9 +52,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 diff --git a/include/boost/iterator/interoperable.hpp b/include/boost/iterator/interoperable.hpp index 6f3c872a2..b278eebb4 100644 --- a/include/boost/iterator/interoperable.hpp +++ b/include/boost/iterator/interoperable.hpp @@ -7,11 +7,9 @@ #ifndef BOOST_INTEROPERABLE_23022003THW_HPP # define BOOST_INTEROPERABLE_23022003THW_HPP -# include -# include - -# include +# include +# include # include // must appear last namespace boost { @@ -33,13 +31,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> { }; diff --git a/include/boost/iterator/is_iterator.hpp b/include/boost/iterator/is_iterator.hpp index 5740b19eb..d9830a077 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 46f0483e2..66cdd191a 100644 --- a/include/boost/iterator/is_lvalue_iterator.hpp +++ b/include/boost/iterator/is_lvalue_iterator.hpp @@ -6,15 +6,13 @@ #include -#include #include -#include #include #include +#include // should be the last #includes -#include #include #ifndef BOOST_NO_IS_CONVERTIBLE @@ -54,7 +52,7 @@ namespace detail // convertible to Value const& struct conversion_eater { - conversion_eater(typename add_lvalue_reference::type); + conversion_eater(typename std::add_lvalue_reference::type); }; static char tester(conversion_eater, int); @@ -87,7 +85,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -96,7 +94,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -104,7 +102,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -112,7 +110,7 @@ namespace detail struct is_lvalue_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; #endif @@ -137,14 +135,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)) diff --git a/include/boost/iterator/is_readable_iterator.hpp b/include/boost/iterator/is_readable_iterator.hpp index 26827c4c5..5cfce27a4 100644 --- a/include/boost/iterator/is_readable_iterator.hpp +++ b/include/boost/iterator/is_readable_iterator.hpp @@ -4,16 +4,14 @@ #ifndef IS_READABLE_ITERATOR_DWA2003112_HPP # define IS_READABLE_ITERATOR_DWA2003112_HPP -#include #include -#include #include #include +#include // should be the last #include -#include #include #ifndef BOOST_NO_IS_CONVERTIBLE @@ -29,7 +27,7 @@ namespace detail template struct is_readable_iterator_impl { - static char tester(typename add_lvalue_reference::type, int); + static char tester(typename std::add_lvalue_reference::type, int); static char (& tester(any_conversion_eater, ...) )[2]; template @@ -57,7 +55,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -66,7 +64,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -74,7 +72,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; @@ -82,7 +80,7 @@ namespace detail struct is_readable_iterator_impl { template - struct rebind : boost::mpl::false_ + struct rebind : std::false_type {}; }; #endif @@ -100,7 +98,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)) diff --git a/include/boost/iterator/iterator_adaptor.hpp b/include/boost/iterator/iterator_adaptor.hpp index db1c4daa3..9c6cbfafb 100644 --- a/include/boost/iterator/iterator_adaptor.hpp +++ b/include/boost/iterator/iterator_adaptor.hpp @@ -7,28 +7,13 @@ #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 namespace boost { @@ -41,13 +26,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 +80,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 +98,7 @@ namespace iterators { template struct ia_dflt_help : mpl::eval_if< - is_same + std::is_same , DefaultNullaryFn , mpl::identity > @@ -173,9 +124,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 +143,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 +155,6 @@ namespace iterators { > type; }; - - // workaround for aC++ CR JAGaf33512 - template - inline void iterator_adaptor_assert_traversal () - { - BOOST_STATIC_ASSERT((is_convertible::value)); - } } // @@ -220,7 +164,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 @@ -309,12 +253,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 +266,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 +279,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 +290,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 1d2591528..6696445cf 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 baf805af6..d201083cd 100644 --- a/include/boost/iterator/iterator_categories.hpp +++ b/include/boost/iterator/iterator_categories.hpp @@ -16,10 +16,7 @@ # include # include -# include - -# include - +#include #include namespace boost { @@ -77,19 +74,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 +104,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 +143,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 > diff --git a/include/boost/iterator/iterator_concepts.hpp b/include/boost/iterator/iterator_concepts.hpp index 3c65553e8..0fca16368 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 c4b5ae4c1..292fcb9d9 100644 --- a/include/boost/iterator/iterator_facade.hpp +++ b/include/boost/iterator/iterator_facade.hpp @@ -8,36 +8,27 @@ #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 +#include +#include +#include #include // this goes last namespace boost { @@ -64,7 +55,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 +67,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 +82,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,13 +108,13 @@ 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) \ @@ -240,38 +231,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; @@ -311,18 +279,17 @@ namespace iterators { }; # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template struct is_non_proxy_reference_impl { static Reference r; template - static typename mpl::if_< - is_convertible< + static typename std::conditional< + std::is_convertible< R const volatile* , Value const volatile* - > + >::value , char[1] , char[2] >::type& helper(R const&); @@ -332,15 +299,16 @@ namespace iterators { template struct is_non_proxy_reference - : mpl::bool_< - is_non_proxy_reference_impl::value + : std::integral_constant< + 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* > @@ -365,22 +333,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 > @@ -463,11 +431,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,21 +443,21 @@ 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; } @@ -504,7 +471,7 @@ namespace iterators { iterator_difference # else mpl::eval_if< - is_convertible + std::is_convertible , iterator_difference , iterator_difference > @@ -528,17 +495,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 +507,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 +516,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 // @@ -644,13 +602,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 +621,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); } @@ -811,11 +769,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; + const auto use_proxy = boost::iterators::detail::use_operator_brackets_proxy::value; return boost::iterators::detail::make_operator_brackets_result( this->derived() + n - , use_proxy() + , std::integral_constant{} ); } @@ -951,18 +909,14 @@ namespace iterators { // # ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP -# define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_() +# define BOOST_ITERATOR_CONVERTIBLE(a,b) std::true_type() # else -# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() +# define BOOST_ITERATOR_CONVERTIBLE(a,b) std::is_convertible() # endif # 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 +927,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 +940,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) diff --git a/include/boost/iterator/minimum_category.hpp b/include/boost/iterator/minimum_category.hpp index 15679bc77..913cec43e 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 2091e5976..a8a833517 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,54 +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 +#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_) -{ - T v2(*i1++); - BOOST_TEST(v == v2); +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_) -{ - ++i1; // we just wrote into that position - *i1++ = v; - Iterator x(i1++); - (void)x; +void writable_iterator_traversal_test(Iterator i1, T v, std::true_type) { + ++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) -{ +void readable_iterator_test(const Iterator i1, T v) { Iterator i2(i1); // Copy Constructible typedef typename std::iterator_traits::reference ref_t; ref_t r1 = *i1; @@ -85,33 +76,35 @@ 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()); +#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) + 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."); +#endif } 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) +#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 +#endif } -template -void swappable_iterator_test(Iterator i, Iterator j) -{ +template void swappable_iterator_test(Iterator i, Iterator j) { Iterator i2(i), j2(j); typename std::iterator_traits::value_type bi = *i, bj = *j; iter_swap(i2, j2); @@ -120,45 +113,49 @@ 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)); - const T& v2 = *i2; + 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)); - T& v3 = *i2; + 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; + 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 +#ifndef BOOST_NO_LVALUE_RETURN_DETECTION + 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."); +#endif } template -void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) -{ +void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) { Iterator i2; Iterator i3(i); i2 = i; @@ -179,8 +176,7 @@ void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) } template -void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) -{ +void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) { forward_readable_iterator_test(i, j, val1, val2); Iterator i2 = i; ++i2; @@ -190,8 +186,7 @@ void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) // bidirectional // Preconditions: *i == v1, *++i == v2 template -void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) -{ +void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) { Iterator j(i); ++j; forward_readable_iterator_test(i, j, v1, v2); @@ -220,14 +215,12 @@ void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) // random access // Preconditions: [i,i+N) is a valid range template -void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) -{ +void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) { bidirectional_readable_iterator_test(i, vals[0], vals[1]); 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]); typename std::iterator_traits::value_type x = j[c]; @@ -242,8 +235,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]); typename std::iterator_traits::value_type x = j[N - 1 - c]; @@ -260,6 +252,6 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) } // namespace boost -# include +#include #endif // BOOST_NEW_ITERATOR_TESTS_HPP diff --git a/include/boost/iterator/transform_iterator.hpp b/include/boost/iterator/transform_iterator.hpp index 5b2b810e0..512b0d0ce 100644 --- a/include/boost/iterator/transform_iterator.hpp +++ b/include/boost/iterator/transform_iterator.hpp @@ -9,28 +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 @@ -103,7 +88,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 } @@ -149,8 +134,8 @@ 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) diff --git a/include/boost/iterator/zip_iterator.hpp b/include/boost/iterator/zip_iterator.hpp index f5780aeb8..f97fb29a2 100644 --- a/include/boost/iterator/zip_iterator.hpp +++ b/include/boost/iterator/zip_iterator.hpp @@ -8,7 +8,6 @@ #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 @@ -19,9 +18,6 @@ #include // for std::pair #include // for backward compatibility -#include -#include - #include #include #include @@ -83,7 +79,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 a68368365..6c50b9d74 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 69efa940e..b177e735a 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 { @@ -49,13 +47,13 @@ namespace detail BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1); - typedef typename mpl::if_c< + typedef typename std::conditional< # if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) ::boost::detail::iterator_pointee::is_constant # else is_constant # endif - , typename add_const::type + , typename std::add_const::type , value_type >::type type; }; diff --git a/test/counting_iterator_test.cpp b/test/counting_iterator_test.cpp index 09d4295b5..d26938a78 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 cf850bcf7..be34c3bb0 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 f64e9f59d..6668d8332 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 c18592d63..c55c16080 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 240e664fb..86b893fa3 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/is_convertible_fail.cpp b/test/is_convertible_fail.cpp index 757b5c6ac..89255fc84 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 16de01413..e52356836 100644 --- a/test/is_lvalue_iterator.cpp +++ b/test/is_lvalue_iterator.cpp @@ -4,9 +4,7 @@ #include #include -#include #include // std::ptrdiff_t -#include #include #include @@ -88,61 +86,96 @@ 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); + 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."); #ifndef BOOST_NO_LVALUE_RETURN_DETECTION - BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator::value); + static_assert(!boost::is_lvalue_iterator::value, + "boost::is_lvalue_iterator::value is expected to be false."); #endif // Make sure inaccessible copy constructor doesn't prevent // reference binding - 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); - 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); - BOOST_STATIC_ASSERT(boost::is_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::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); + 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."); + 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."); + static_assert(boost::is_lvalue_iterator>::value, + "boost::is_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 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."); #ifndef BOOST_NO_LVALUE_RETURN_DETECTION - 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."); #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 false."); - 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."); #if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) - 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."); #endif - 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); - 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 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 1d33a64ab..5e929ee9b 100644 --- a/test/is_readable_iterator.cpp +++ b/test/is_readable_iterator.cpp @@ -4,9 +4,7 @@ #include #include -#include #include // std::ptrdiff_t -#include #include #include @@ -78,19 +76,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 2ea758256..6b0b73ca4 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 4b37c14b3..4305d1867 100644 --- a/test/iterator_adaptor_test.cpp +++ b/test/iterator_adaptor_test.cpp @@ -209,7 +209,10 @@ main() test = static_assert_same::value; test = static_assert_same::value; #if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) - BOOST_STATIC_ASSERT((boost::is_convertible::value)); + static_assert( + std::is_convertible::value, + "Iterator must have a random access category." + ); #endif } @@ -220,9 +223,9 @@ main() test = static_assert_same::value; #if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) - BOOST_STATIC_ASSERT(boost::is_readable_iterator::value); + static_assert(boost::is_readable_iterator::value, "Iter1 is expected to be readable."); # ifndef BOOST_NO_LVALUE_RETURN_DETECTION - BOOST_STATIC_ASSERT(boost::is_lvalue_iterator::value); + static_assert(boost::is_lvalue_iterator::value, "Iter1 is expected to be lvalue iterator."); # endif #endif @@ -243,8 +246,14 @@ main() #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); + 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." + ); #endif typedef modify_traversal IncrementableIter; diff --git a/test/iterator_facade.cpp b/test/iterator_facade.cpp index 7351dd3fc..a44325a53 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,10 +145,6 @@ 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< @@ -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 40da04973..d2b84c38f 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 3f89d6c6a..54f7e7a87 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 81cdefedc..db601e871 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 32e34962f..4e545990e 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 c2e4a4190..4be97343d 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 5d96da935..fb1c84783 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 ans 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 b22cb161f..5b15f4fe8 100644 --- a/test/transform_iterator_test.cpp +++ b/test/transform_iterator_test.cpp @@ -21,6 +21,8 @@ #include #include +#include "static_assert_same.hpp" + #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { namespace detail { @@ -172,20 +174,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 656e72ffa..76bbffb35 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; } -