// (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_TRANSFORM_ITERATOR_23022003THW_HPP #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP #include <boost/function.hpp> #include <boost/iterator.hpp> #include <boost/iterator/detail/enable_if.hpp> #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_categories.hpp> #include <boost/mpl/not.hpp> #include <boost/mpl/bool.hpp> #include <boost/type_traits/function_traits.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/is_class.hpp> #include <boost/type_traits/is_function.hpp> #include <boost/type_traits/is_reference.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) # include <boost/type_traits/is_base_and_derived.hpp> #endif #include <boost/iterator/detail/config_def.hpp> namespace boost { template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default> class transform_iterator; namespace detail { template <class UnaryFunc> struct function_object_result { typedef typename UnaryFunc::result_type type; }; #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template <class Return, class Argument> struct function_object_result<Return(*)(Argument)> { typedef Return type; }; #endif // Compute the iterator_adaptor instantiation to be used for transform_iterator template <class UnaryFunc, class Iterator, class Reference, class Value> struct transform_iterator_base { private: // By default, dereferencing the iterator yields the same as // the function. Do we need to adjust the way // function_object_result is computed for the standard // proposal (e.g. using Doug's result_of)? typedef typename ia_dflt_help< Reference , function_object_result<UnaryFunc> >::type reference; // 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. typedef typename ia_dflt_help< Value , remove_reference<reference> >::type cv_value_type; public: typedef iterator_adaptor< transform_iterator<UnaryFunc, Iterator, Reference, Value> , Iterator , cv_value_type , use_default // Leave the traversal category alone , reference > type; }; } template <class UnaryFunc, class Iterator, class Reference, class Value> class transform_iterator : public boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type { typedef typename boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type super_t; friend class iterator_core_access; public: transform_iterator() { } transform_iterator(Iterator const& x, UnaryFunc f) : super_t(x), m_f(f) { } 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. BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value); #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 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0 #endif ) : super_t(t.base()), m_f(t.functor()) {} UnaryFunc functor() const { return m_f; } private: typename super_t::reference dereference() const { return m_f(*this->base()); } // Probably should be the initial base class so it can be // optimized away via EBO if it is an empty class. UnaryFunc m_f; }; template <class UnaryFunc, class Iterator> 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 <class UnaryFunc, class Iterator> #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) typename mpl::if_< #else typename iterators::enable_if< #endif is_class<UnaryFunc> // We should probably find a cheaper test than is_class<> , transform_iterator<UnaryFunc, Iterator> #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) , int[3] #endif >::type make_transform_iterator(Iterator it) { return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc()); } #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) template <class Return, class Argument, class Iterator> transform_iterator< Return (*)(Argument), Iterator, Return> make_transform_iterator(Iterator it, Return (*fun)(Argument)) { return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun); } #endif } // namespace boost #include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP