From 6e6def930f50b8c91a68366db9d07dac247f3b01 Mon Sep 17 00:00:00 2001 From: Andrey Semashev Date: Fri, 7 Feb 2025 00:54:12 +0300 Subject: [PATCH] Modernized transform_iterator.hpp, use EBO to store the transform function. --- include/boost/iterator/transform_iterator.hpp | 224 +++++++++--------- 1 file changed, 109 insertions(+), 115 deletions(-) diff --git a/include/boost/iterator/transform_iterator.hpp b/include/boost/iterator/transform_iterator.hpp index a5b23f1..d15e6dd 100644 --- a/include/boost/iterator/transform_iterator.hpp +++ b/include/boost/iterator/transform_iterator.hpp @@ -4,144 +4,138 @@ // 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_TRANSFORM_ITERATOR_23022003THW_HPP -#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP +#ifndef BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP +#define BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP + +#include +#include -#include -#include #include +#include #include -#include #include #include -#include - -#include -#include - - namespace boost { namespace iterators { - template - class transform_iterator; +template< + typename UnaryFunction, + typename Iterator, + typename Reference = use_default, + typename Value = use_default +> +class transform_iterator; - namespace detail - { - // Compute the iterator_adaptor instantiation to be used for transform_iterator - template - struct transform_iterator_base - { - private: - // By default, dereferencing the iterator yields the same as - // the function. - using reference = detail::eval_if_default_t< - Reference, -#ifdef BOOST_RESULT_OF_USE_TR1 - result_of::reference)> -#else - result_of::reference)> -#endif - >; +namespace detail { - // To get the default for Value: remove any reference on the - // result type, but retain any constness to signal - // non-writability. Note that if we adopt Thomas' suggestion - // to key non-writability *only* on the Reference argument, - // we'd need to strip constness here as well. - using cv_value_type = detail::eval_if_default_t< - Value, - remove_reference - >; +template< typename UnaryFunc, typename Iterator > +struct transform_iterator_default_reference +{ + using type = decltype(std::declval< UnaryFunc const& >()(std::declval< typename std::iterator_traits< Iterator >::reference >())); +}; - public: - using type = iterator_adaptor< - transform_iterator, - Iterator, - cv_value_type, - use_default, // Leave the traversal category alone - reference - >; - }; - } +// Compute the iterator_adaptor instantiation to be used for transform_iterator +template< typename UnaryFunc, typename Iterator, typename Reference, typename Value > +struct transform_iterator_base +{ +private: + // By default, dereferencing the iterator yields the same as + // the function. + using reference = detail::eval_if_default_t< + Reference, + transform_iterator_default_reference< UnaryFunc, Iterator > + >; - template - class transform_iterator - : public boost::iterators::detail::transform_iterator_base::type - { - typedef typename - boost::iterators::detail::transform_iterator_base::type - super_t; + // To get the default for Value: remove any reference on the + // result type, but retain any constness to signal + // non-writability. Note that if we adopt Thomas' suggestion + // to key non-writability *only* on the Reference argument, + // we'd need to strip constness here as well. + using cv_value_type = detail::eval_if_default_t< + Value, + std::remove_reference< reference > + >; + public: + using type = iterator_adaptor< + transform_iterator< UnaryFunc, Iterator, Reference, Value >, + Iterator, + cv_value_type, + use_default, // Leave the traversal category alone + reference + >; +}; + +} // namespace detail + +template< typename UnaryFunc, typename Iterator, typename Reference, typename Value > +class transform_iterator : + public detail::transform_iterator_base< UnaryFunc, Iterator, Reference, Value >::type, + private boost::empty_value< UnaryFunc > +{ friend class iterator_core_access; - public: - transform_iterator() { } +private: + using super_t = typename detail::transform_iterator_base< UnaryFunc, Iterator, Reference, Value >::type; + using functor_base = boost::empty_value< UnaryFunc >; - transform_iterator(Iterator const& x, UnaryFunc f) - : super_t(x), m_f(f) { } +public: + transform_iterator() = default; - explicit transform_iterator(Iterator const& x) - : super_t(x) - { - // Pro8 is a little too aggressive about instantiating the - // body of this function. -#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. - static_assert(std::is_class::value, "Transform function must not be a function pointer."); -#endif - } + transform_iterator(Iterator const& x, UnaryFunc f) : + super_t(x), + functor_base(boost::empty_init_t{}, f) + {} - template < - class OtherUnaryFunction - , class OtherIterator - , class OtherReference - , class OtherValue> - transform_iterator( - transform_iterator const& t - , typename enable_if_convertible::type* = 0 - , typename enable_if_convertible::type* = 0 - ) - : super_t(t.base()), m_f(t.functor()) - {} + // don't provide this constructor if UnaryFunc is a + // function pointer type, since it will be 0. Too dangerous. + template< bool Requires = std::is_class< UnaryFunc >::value, typename = typename std::enable_if< Requires >::type > + explicit transform_iterator(Iterator const& x) : + super_t(x) + {} - UnaryFunc functor() const - { return m_f; } + template< + typename OtherUnaryFunction, + typename OtherIterator, + typename OtherReference, + typename OtherValue, + typename = enable_if_convertible_t< OtherIterator, Iterator >, + typename = enable_if_convertible_t< OtherUnaryFunction, UnaryFunc > + > + transform_iterator(transform_iterator< OtherUnaryFunction, OtherIterator, OtherReference, OtherValue > const& t) : + super_t(t.base()), + functor_base(boost::empty_init_t{}, t.functor()) + {} - private: - typename super_t::reference dereference() const - { return m_f(*this->base()); } + UnaryFunc functor() const { return functor_base::get(); } - // Probably should be the initial base class so it can be - // optimized away via EBO if it is an empty class. - UnaryFunc m_f; - }; +private: + typename super_t::reference dereference() const { return functor_base::get()(*this->base()); } +}; - template - inline transform_iterator - make_transform_iterator(Iterator it, UnaryFunc fun) - { - return transform_iterator(it, fun); - } +template< typename UnaryFunc, typename Iterator > +inline transform_iterator< UnaryFunc, Iterator > make_transform_iterator(Iterator it, UnaryFunc fun) +{ + return transform_iterator< UnaryFunc, Iterator >(it, fun); +} + +// Version which allows explicit specification of the UnaryFunc +// type. +// +// This generator is not provided if UnaryFunc is a function +// pointer type, because it's too dangerous: the default-constructed +// function pointer in the iterator be 0, leading to a runtime +// crash. +template< typename UnaryFunc, typename Iterator > +inline typename std::enable_if< + std::is_class< UnaryFunc >::value, // We should probably find a cheaper test than is_class<> + transform_iterator< UnaryFunc, Iterator > +>::type make_transform_iterator(Iterator it) +{ + return transform_iterator< UnaryFunc, Iterator >(it); +} - // Version which allows explicit specification of the UnaryFunc - // type. - // - // This generator is not provided if UnaryFunc is a function - // pointer type, because it's too dangerous: the default-constructed - // function pointer in the iterator be 0, leading to a runtime - // crash. - template - 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()); - } } // namespace iterators using iterators::transform_iterator; @@ -149,4 +143,4 @@ using iterators::make_transform_iterator; } // namespace boost -#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP +#endif // BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP