ticket 6172 - added unit test to ensure transformed works with bind.

include/boost/range/adaptor/transformed.hpp

@@ -41,20 +41,32 @@ namespace boost
             typedef F transform_fn_type;
             typedef R source_range_type;
 
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
             transformed_range( F f, R& r )
                 : base( boost::make_transform_iterator( boost::begin(r), f ),
                         boost::make_transform_iterator( boost::end(r), f ) )
 
-            { }
+            {
+            }
+#else
+            transformed_range(F&& f, R&& r)
+                : base(typename base::iterator(boost::begin(r), std::forward(f),
+                       typename base::iterator(boost::end(r), std::forward(f))))
+            {
+            }
+
+#endif
         };
 
         template< class T >
         struct transform_holder : holder<T>
         {
             transform_holder( T r ) : holder<T>(r)
-            { }
+            {
+            }
         };
 
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
         template< class InputRng, class UnaryFunction >
         inline transformed_range<UnaryFunction,InputRng>
         operator|( InputRng& r,
@@ -70,6 +82,16 @@ namespace boost
         {
            return transformed_range<UnaryFunction, const InputRng>( f.val, r );
         }
+#else
+        template<class InputRng, class UnaryFunction>
+        inline transformed_range<UnaryFunction,InputRng>
+        operator|(InputRng&& r,
+                  transform_holder<UnaryFunction>&& f)
+        {
+            return transformed_range<UnaryFunction, InputRng>(
+                        f.val, std::forward(r));
+        }
+#endif
 
     } // 'range_detail'
 
@@ -84,6 +106,7 @@ namespace boost
                       range_detail::forwarder<range_detail::transform_holder>();
         }
 
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
         template<class UnaryFunction, class InputRange>
         inline transformed_range<UnaryFunction, InputRange>
         transform(InputRange& rng, UnaryFunction fn)
@@ -97,6 +120,16 @@ namespace boost
         {
             return transformed_range<UnaryFunction, const InputRange>(fn, rng);
         }
+#else
+    template<typename UnaryFunction, typename InputRange>
+    inline transformed_range<UnaryFunction, InputRange>
+    transform(InputRange&& rng, UnaryFunction&& fn)
+    {
+        return transformed_range<UnaryFunction, InputRange>(
+                    std::forward(fn), std::forward(rng));
+    }
+
+#endif
     } // 'adaptors'
 
 }

test/adaptor_test/transformed.cpp

@@ -14,6 +14,7 @@
 #include <boost/test/unit_test.hpp>
 
 #include <boost/assign.hpp>
+#include <boost/bind.hpp>
 #include <boost/range/algorithm_ext.hpp>
 
 #include <algorithm>
@@ -92,6 +93,29 @@ namespace boost
             transformed_test_impl< std::set< int > >();
             transformed_test_impl< std::multiset< int > >();
         }
+
+        struct foo_bind
+        {
+            int foo() const { return 7; }
+        };
+
+        void transformed_bind()
+        {
+            using namespace boost::adaptors;
+
+            std::vector<foo_bind> input(5);
+            std::vector<int> output;
+            boost::range::push_back(
+                    output,
+                    input | transformed(boost::bind(&foo_bind::foo, _1)));
+
+            BOOST_CHECK_EQUAL(output.size(), input.size());
+
+            std::vector<int> reference_output(5, 7);
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                        output.begin(), output.end(),
+                        reference_output.begin(), reference_output.end());
+        }
     }
 }
 
@@ -102,6 +126,7 @@ init_unit_test_suite(int argc, char* argv[])
         = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.transformed" );
 
     test->add(BOOST_TEST_CASE(&boost::transformed_test));
+    test->add(BOOST_TEST_CASE(&boost::transformed_bind));
 
     return test;
 }