Ticket #7748: range.diff

boost/range/adaptor/transformed.hpp

@@ -13 +13 @@
 
 #include <boost/range/adaptor/argument_fwd.hpp>
 #include <boost/range/iterator_range.hpp>
+#include <boost/range/reference.hpp>
 #include <boost/iterator/transform_iterator.hpp>
 #include <boost/utility/result_of.hpp>
 
@@ -48 +49 @@
             { }
         };
 
+        template< class R, class T, class U >
+        struct ret_wrapper
+        {
+          T val;
+          explicit ret_wrapper(T v) : val(v) {}
+
+          typedef R result_type;
+
+          R operator()(U u) const
+          { return val(u); }
+        };
+
         template< class T >
         struct transform_holder : holder<T>
         {
@@ -55 +68 @@
             { }
         };
 
+        template< class R, class T >
+        struct ret_transform_holder : transform_holder<T>
+        {
+            ret_transform_holder( T r ) : transform_holder<T>(r)
+            { }
+        };
+
+
+        template< class InputRng, class R, class UnaryFunction >
+        inline transformed_range<ret_wrapper<R,UnaryFunction,
+          BOOST_DEDUCED_TYPENAME range_reference<InputRng>::type>, InputRng>
+        operator|( InputRng& r,
+                   const ret_transform_holder<R, UnaryFunction>& f )
+        {
+          typedef BOOST_DEDUCED_TYPENAME range_reference<InputRng>::type InRef;
+            return transformed_range<ret_wrapper<R, UnaryFunction, InRef>,
+                   InputRng>( ret_wrapper<R, UnaryFunction, InRef>(f.val), r );
+        }
+
+        template< class InputRng, class R, class UnaryFunction >
+        inline transformed_range<ret_wrapper<R,UnaryFunction,
+          BOOST_DEDUCED_TYPENAME range_reference<const InputRng>::type>, const InputRng>
+        operator|( const InputRng& r,
+                   const ret_transform_holder<R, UnaryFunction>& f )
+        {
+          typedef BOOST_DEDUCED_TYPENAME range_reference<const InputRng>::type InRef;
+            return transformed_range<ret_wrapper<R, UnaryFunction, InRef>,
+              const InputRng>( ret_wrapper<R, UnaryFunction, InRef>(f.val), r );
+        }
+
         template< class InputRng, class UnaryFunction >
         inline transformed_range<UnaryFunction,InputRng>
         operator|( InputRng& r,
@@ -77 +120 @@
 
     namespace adaptors
     {
-        namespace
+        template< class R, class T >
+        range_detail::ret_transform_holder<R,T> transformed( T t )
         {
-            const range_detail::forwarder<range_detail::transform_holder>
-                    transformed =
-                      range_detail::forwarder<range_detail::transform_holder>();
+            return range_detail::ret_transform_holder<R,T>(t);
         }
+        template< class T >
+        range_detail::transform_holder<T> transformed( T t )
+        {
+            return range_detail::transform_holder<T>(t);
+        }
 
+        template< class R, class InputRng, class UnaryFunction >
+        inline transformed_range<range_detail::ret_wrapper<R, UnaryFunction,
+               BOOST_DEDUCED_TYPENAME range_reference<InputRng>::type>,InputRng>
+        transform(InputRng& r, UnaryFunction fn)
+        {
+          typedef BOOST_DEDUCED_TYPENAME range_reference<InputRng>::type InRef;
+            return transformed_range<range_detail::ret_wrapper<R, UnaryFunction, InRef>,
+                   InputRng>(range_detail::ret_wrapper<R, UnaryFunction, InRef>(fn), r );
+        }
+        template< class R, class InputRng, class UnaryFunction >
+        inline transformed_range<range_detail::ret_wrapper<R, UnaryFunction,
+               BOOST_DEDUCED_TYPENAME range_reference<const InputRng>::type>, const InputRng>
+        transform(const InputRng& r, UnaryFunction fn)
+        {
+          typedef BOOST_DEDUCED_TYPENAME range_reference<const InputRng>::type InRef;
+            return transformed_range<range_detail::ret_wrapper<R, UnaryFunction, InRef>,
+              const InputRng>(range_detail::ret_wrapper<R, UnaryFunction, InRef>(fn), r );
+        }
+
         template<class UnaryFunction, class InputRange>
         inline transformed_range<UnaryFunction, InputRange>
         transform(InputRange& rng, UnaryFunction fn)

libs/range/test/adaptor_test/transformed.cpp

@@ -92 +92 @@
             transformed_test_impl< std::set< int > >();
             transformed_test_impl< std::multiset< int > >();
         }
+
+        //Unmodifiable struct which doesn't follow result_of.
+        struct hands_off
+        {
+            int operator()(double d) const
+            { return static_cast<int>(d); }
+        };
+
+        //Previous tests verify that transform/transformed which followed
+        // result_type worked.  This checks only cases which don't (and thus
+        // require an explicit result) (assuming no decltype support)
+        void transformed_result_test()
+        {
+            using namespace boost::assign;
+
+            hands_off fn;
+            std::vector< double > c;
+            c += 1,2,3,4,5,6,7,8,9;
+            std::vector< int > result1, result2, result3, result4;
+            boost::push_back(result1, c | adaptors::transformed<int>(fn));
+            boost::push_back(result2, adaptors::transform<int>(c, fn));
+
+            BOOST_CHECK_EQUAL_COLLECTIONS( result1.begin(), result1.end(),
+                                           result2.begin(), result2.end() );
+
+            const std::vector< double >& c2 = c;
+            boost::push_back(result3, c2 | adaptors::transformed<int>(fn));
+            boost::push_back(result4, adaptors::transform<int>(c2, fn));
+
+            BOOST_CHECK_EQUAL_COLLECTIONS( result3.begin(), result3.end(),
+                                           result4.begin(), result4.end() );
+
+            BOOST_CHECK_EQUAL_COLLECTIONS( result1.begin(), result1.end(),
+                                           result3.begin(), result3.end() );
+        }
     }
 }
 
@@ -102 +137 @@
         = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.transformed" );
 
     test->add( BOOST_TEST_CASE( &boost::transformed_test ) );
+    test->add( BOOST_TEST_CASE( &boost::transformed_result_test ) );
 
     return test;
 }