From c7fc3470d021a8607e99204ea4fbf86f952a019d Mon Sep 17 00:00:00 2001 From: "Jeffrey Lee Hellrung, Jr." Date: Tue, 24 Apr 2012 21:28:07 +0000 Subject: [PATCH] merging from trunk; fix #5127 from M. Morin; fix for refs #5697 [SVN r78184] --- doc/transform_iterator.html | 6 +- doc/transform_iterator_ref.rst | 6 +- include/boost/iterator/iterator_facade.hpp | 66 +++++++-------- include/boost/iterator/transform_iterator.hpp | 2 +- test/iterator_facade.cpp | 80 ++++++++++++++++--- test/transform_iterator_test.cpp | 12 ++- 6 files changed, 114 insertions(+), 58 deletions(-) diff --git a/doc/transform_iterator.html b/doc/transform_iterator.html index ed69c45..2281737 100644 --- a/doc/transform_iterator.html +++ b/doc/transform_iterator.html @@ -99,7 +99,7 @@ private:

If Reference is use_default then the reference member of transform_iterator is -result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type. +result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type. Otherwise, reference is Reference.

If Value is use_default then the value_type member is remove_cv<remove_reference<reference> >::type. Otherwise, @@ -117,10 +117,10 @@ convertible to input_iterator_tag

transform_iterator requirements

The type UnaryFunction must be Assignable, Copy Constructible, and -the expression f(*i) must be valid where f is an object of +the expression f(*i) must be valid where f is a const object of type UnaryFunction, i is an object of type Iterator, and where the type of f(*i) must be -result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type.

+result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type.

The argument Iterator shall model Readable Iterator.

diff --git a/doc/transform_iterator_ref.rst b/doc/transform_iterator_ref.rst index 74347a0..70becc5 100644 --- a/doc/transform_iterator_ref.rst +++ b/doc/transform_iterator_ref.rst @@ -41,7 +41,7 @@ If ``Reference`` is ``use_default`` then the ``reference`` member of ``transform_iterator`` is -``result_of::reference)>::type``. +``result_of::reference)>::type``. Otherwise, ``reference`` is ``Reference``. If ``Value`` is ``use_default`` then the ``value_type`` member is @@ -64,10 +64,10 @@ convertible to ``input_iterator_tag``. ................................... The type ``UnaryFunction`` must be Assignable, Copy Constructible, and -the expression ``f(*i)`` must be valid where ``f`` is an object of +the expression ``f(*i)`` must be valid where ``f`` is a const object of type ``UnaryFunction``, ``i`` is an object of type ``Iterator``, and where the type of ``f(*i)`` must be -``result_of::reference)>::type``. +``result_of::reference)>::type``. The argument ``Iterator`` shall model Readable Iterator. diff --git a/include/boost/iterator/iterator_facade.hpp b/include/boost/iterator/iterator_facade.hpp index 5ee73b5..1ca0902 100644 --- a/include/boost/iterator/iterator_facade.hpp +++ b/include/boost/iterator/iterator_facade.hpp @@ -14,8 +14,8 @@ #include #include -#include #include +#include #include #include @@ -294,46 +294,43 @@ namespace boost // operator->() needs special support for input iterators to strictly meet the // standard's requirements. If *i is not a reference type, we must still - // produce a lvalue to which a pointer can be formed. We do that by - // returning an instantiation of this special proxy class template. - template - struct operator_arrow_proxy + // produce a lvalue to which a pointer can be formed. We do that by + // returning a proxy object containing an instance of the reference object. + template + struct operator_arrow_dispatch // proxy references { - operator_arrow_proxy(T const* px) : m_value(*px) {} - T* operator->() const { return &m_value; } - // This function is needed for MWCW and BCC, which won't call operator-> - // again automatically per 13.3.1.2 para 8 - operator T*() const { return &m_value; } - mutable T m_value; + struct proxy + { + explicit proxy(Reference const & x) : m_ref(x) {} + Reference* operator->() { return boost::addressof(m_ref); } + // This function is needed for MWCW and BCC, which won't call + // operator-> again automatically per 13.3.1.2 para 8 + operator Reference*() { return boost::addressof(m_ref); } + Reference m_ref; + }; + typedef proxy result_type; + static result_type apply(Reference const & x) + { + return result_type(x); + } }; - // A metafunction that gets the result type for operator->. Also - // has a static function make() which builds the result from a - // Reference - template - struct operator_arrow_result + template + struct operator_arrow_dispatch // "real" references { - // CWPro8.3 won't accept "operator_arrow_result::type", and we - // need that type below, so metafunction forwarding would be a - // losing proposition here. - typedef typename mpl::if_< - is_reference - , Pointer - , operator_arrow_proxy - >::type type; - - static type make(Reference x) + typedef Pointer result_type; + static result_type apply(T& x) { - return boost::implicit_cast(&x); + return boost::addressof(x); } }; # if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // Deal with ETI template<> - struct operator_arrow_result + struct operator_arrow_dispatch { - typedef int type; + typedef int result_type; }; # endif @@ -618,11 +615,10 @@ namespace boost Value, CategoryOrTraversal, Reference, Difference > associated_types; - typedef boost::detail::operator_arrow_result< - typename associated_types::value_type - , Reference + typedef boost::detail::operator_arrow_dispatch< + Reference , typename associated_types::pointer - > pointer_; + > operator_arrow_dispatch_; protected: // For use by derived classes @@ -634,7 +630,7 @@ namespace boost typedef Reference reference; typedef Difference difference_type; - typedef typename pointer_::type pointer; + typedef typename operator_arrow_dispatch_::result_type pointer; typedef typename associated_types::iterator_category iterator_category; @@ -645,7 +641,7 @@ namespace boost pointer operator->() const { - return pointer_::make(*this->derived()); + return operator_arrow_dispatch_::apply(*this->derived()); } typename boost::detail::operator_brackets_result::type diff --git a/include/boost/iterator/transform_iterator.hpp b/include/boost/iterator/transform_iterator.hpp index 86565b8..b79a440 100644 --- a/include/boost/iterator/transform_iterator.hpp +++ b/include/boost/iterator/transform_iterator.hpp @@ -46,7 +46,7 @@ namespace boost // the function. typedef typename ia_dflt_help< Reference - , result_of::reference)> + , result_of::reference)> >::type reference; // To get the default for Value: remove any reference on the diff --git a/test/iterator_facade.cpp b/test/iterator_facade.cpp index 5efd51d..9585298 100644 --- a/test/iterator_facade.cpp +++ b/test/iterator_facade.cpp @@ -7,6 +7,10 @@ #include #include +#include +#include +#include + // This is a really, really limited test so far. All we're doing // right now is checking that the postfix++ proxy for single-pass // iterators works properly. @@ -87,26 +91,76 @@ struct input_iter } }; +template +struct wrapper +{ + T m_x; + explicit wrapper(typename boost::call_traits::param_type x) + : m_x(x) + { } + template + wrapper(const wrapper& other, + typename boost::enable_if< boost::is_convertible >::type* = 0) + : m_x(other.m_x) + { } +}; + +struct iterator_with_proxy_reference + : boost::iterator_facade< + iterator_with_proxy_reference + , wrapper + , boost::incrementable_traversal_tag + , wrapper + > +{ + int& m_x; + explicit iterator_with_proxy_reference(int& x) + : m_x(x) + { } + + void increment() + { } + wrapper dereference() const + { return wrapper(m_x); } +}; + template void same_type(U const&) { BOOST_MPL_ASSERT((boost::is_same)); } int main() { - int state = 0; - boost::readable_iterator_test(counter_iterator(&state), 0); - state = 3; - boost::readable_iterator_test(counter_iterator(&state), 3); - boost::writable_iterator_test(counter_iterator(&state), 9, 7); - BOOST_TEST(state == 8); + { + int state = 0; + boost::readable_iterator_test(counter_iterator(&state), 0); + state = 3; + boost::readable_iterator_test(counter_iterator(&state), 3); + boost::writable_iterator_test(counter_iterator(&state), 9, 7); + BOOST_TEST(state == 8); + } - // test for a fix to http://tinyurl.com/zuohe - // These two lines should be equivalent (and both compile) - input_iter p; - (*p).mutator(); - p->mutator(); + { + // test for a fix to http://tinyurl.com/zuohe + // These two lines should be equivalent (and both compile) + input_iter p; + (*p).mutator(); + p->mutator(); + + same_type(p.operator->()); + } + + { + int x = 0; + iterator_with_proxy_reference i(x); + BOOST_TEST(x == 0); + BOOST_TEST(i.m_x == 0); + ++(*i).m_x; + BOOST_TEST(x == 1); + BOOST_TEST(i.m_x == 1); + ++i->m_x; + BOOST_TEST(x == 2); + BOOST_TEST(i.m_x == 2); + } - same_type(p.operator->()); - return boost::report_errors(); } diff --git a/test/transform_iterator_test.cpp b/test/transform_iterator_test.cpp index 255eab4..3caad2a 100644 --- a/test/transform_iterator_test.cpp +++ b/test/transform_iterator_test.cpp @@ -12,6 +12,7 @@ // Moved test of transform iterator into its own file. It to // to be in iterator_adaptor_test.cpp. +#include #include #include #include @@ -106,12 +107,17 @@ struct polymorphic_mult_functor { //Implement result_of protocol template struct result; - template struct result {typedef T type;}; - template struct result {typedef T type;}; - template struct result {typedef T type;}; + template struct result {typedef T type;}; + template struct result {typedef T type;}; + template struct result {typedef T type;}; + template struct result {typedef void type;}; + template struct result {typedef void type;}; + template struct result {typedef void type;}; template T operator()(const T& _arg) const {return _arg*2;} + template + void operator()(const T& _arg) { BOOST_ASSERT(0); } }; int