boost_mirror/iterator
1
0
Fork 0
mirror of https://github.com/boostorg/iterator.git synced 2025-05-10 07:33:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Modernized transform_iterator.hpp, use EBO to store the transform function.

Browse Source
This commit is contained in:
Andrey Semashev 2025-02-07 00:54:12 +03:00
parent 1a58ca89d1
commit 6e6def930f
1 changed files with 109 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

184
include/boost/iterator/transform_iterator.hpp
View File

@ -4,45 +4,47 @@
// Distributed under the Boost Software License, Version 1.0. (See // Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at // accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP #ifndef BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP
#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP #define BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP
#include <iterator>
#include <type_traits>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <boost/core/use_default.hpp> #include <boost/core/use_default.hpp>
#include <boost/core/empty_value.hpp>
#include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/enable_if_convertible.hpp> #include <boost/iterator/enable_if_convertible.hpp>
#include <boost/iterator/detail/eval_if_default.hpp> #include <boost/iterator/detail/eval_if_default.hpp>
#include <boost/utility/result_of.hpp>
#include <type_traits>
#include <iterator>
namespace boost { namespace boost {
namespace iterators { namespace iterators {
template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default> template<
class transform_iterator; typename UnaryFunction,
typename Iterator,
typename Reference = use_default,
typename Value = use_default
>
class transform_iterator;
namespace detail namespace detail {
{
// Compute the iterator_adaptor instantiation to be used for transform_iterator template< typename UnaryFunc, typename Iterator >
template <class UnaryFunc, class Iterator, class Reference, class Value> struct transform_iterator_default_reference
struct transform_iterator_base {
{ using type = decltype(std::declval< UnaryFunc const& >()(std::declval< typename std::iterator_traits< Iterator >::reference >()));
private: };
// 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 // By default, dereferencing the iterator yields the same as
// the function. // the function.
using reference = detail::eval_if_default_t< using reference = detail::eval_if_default_t<
Reference, Reference,
#ifdef BOOST_RESULT_OF_USE_TR1 transform_iterator_default_reference< UnaryFunc, Iterator >
result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
#else
result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)>
#endif
>; >;
// To get the default for Value: remove any reference on the // To get the default for Value: remove any reference on the
@ -52,96 +54,88 @@ namespace iterators {
// we'd need to strip constness here as well. // we'd need to strip constness here as well.
using cv_value_type = detail::eval_if_default_t< using cv_value_type = detail::eval_if_default_t<
Value, Value,
remove_reference<reference> std::remove_reference< reference >
>; >;
public: public:
using type = iterator_adaptor< using type = iterator_adaptor<
transform_iterator<UnaryFunc, Iterator, Reference, Value>, transform_iterator< UnaryFunc, Iterator, Reference, Value >,
Iterator, Iterator,
cv_value_type, cv_value_type,
use_default, // Leave the traversal category alone use_default, // Leave the traversal category alone
reference reference
>; >;
}; };
}
template <class UnaryFunc, class Iterator, class Reference, class Value> } // namespace detail
class transform_iterator
: public boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
{
typedef typename
boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
super_t;
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; friend class iterator_core_access;
public: private:
transform_iterator() { } 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) public:
: super_t(x), m_f(f) { } transform_iterator() = default;
explicit transform_iterator(Iterator const& x) transform_iterator(Iterator const& x, UnaryFunc f) :
: super_t(x) super_t(x),
{ functor_base(boost::empty_init_t{}, f)
// 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<UnaryFunc>::value, "Transform function must not be a function pointer.");
#endif
}
template <
class OtherUnaryFunction
, class OtherIterator
, class OtherReference
, class OtherValue>
transform_iterator(
transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
, typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
, typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0
)
: super_t(t.base()), m_f(t.functor())
{} {}
UnaryFunc functor() const // don't provide this constructor if UnaryFunc is a
{ return m_f; } // 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)
{}
private: template<
typename super_t::reference dereference() const typename OtherUnaryFunction,
{ return m_f(*this->base()); } 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())
{}
// Probably should be the initial base class so it can be UnaryFunc functor() const { return functor_base::get(); }
// optimized away via EBO if it is an empty class.
UnaryFunc m_f;
};
template <class UnaryFunc, class Iterator> private:
inline transform_iterator<UnaryFunc, Iterator> typename super_t::reference dereference() const { return functor_base::get()(*this->base()); }
make_transform_iterator(Iterator it, UnaryFunc fun) };
{
return transform_iterator<UnaryFunc, 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 <class UnaryFunc, class 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, UnaryFunc());
}
} // namespace iterators } // namespace iterators
using iterators::transform_iterator; using iterators::transform_iterator;
@ -149,4 +143,4 @@ using iterators::make_transform_iterator;
} // namespace boost } // namespace boost
#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP #endif // BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP