comparison DEPENDENCIES/generic/include/boost/range/adaptor/indirected.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 
 #ifndef BOOST_RANGE_ADAPTOR_INDIRECTED_HPP
 #define BOOST_RANGE_ADAPTOR_INDIRECTED_HPP
 
 #include <boost/range/iterator_range.hpp>
+#include <boost/range/concepts.hpp>
 #include <boost/iterator/indirect_iterator.hpp>
 
 namespace boost
 {
     namespace range_detail

             { }
         };
 
         struct indirect_forwarder {};
 
-        template< class InputRng >
-        inline indirected_range<InputRng>
-        operator|( InputRng& r, indirect_forwarder )
+        template< class SinglePassRange >
+        inline indirected_range<SinglePassRange>
+        operator|( SinglePassRange& r, indirect_forwarder )
         {
-            return indirected_range<InputRng>( r );
+            BOOST_RANGE_CONCEPT_ASSERT((
+                SinglePassRangeConcept<SinglePassRange>));
+
+            return indirected_range<SinglePassRange>( r );
         }
 
-        template< class InputRng >
-        inline indirected_range<const InputRng>
-        operator|( const InputRng& r, indirect_forwarder )
+        template< class SinglePassRange >
+        inline indirected_range<const SinglePassRange>
+        operator|( const SinglePassRange& r, indirect_forwarder )
         {
-            return indirected_range<const InputRng>( r );
+            BOOST_RANGE_CONCEPT_ASSERT((
+                SinglePassRangeConcept<const SinglePassRange>));
+
+            return indirected_range<const SinglePassRange>( r );
         }
 
     } // 'range_detail'
 
     using range_detail::indirected_range;

         {
             const range_detail::indirect_forwarder indirected =
                                             range_detail::indirect_forwarder();
         }
 
-        template<class InputRange>
-        inline indirected_range<InputRange>
-        indirect(InputRange& rng)
+        template<class SinglePassRange>
+        inline indirected_range<SinglePassRange>
+        indirect(SinglePassRange& rng)
         {
-            return indirected_range<InputRange>(rng);
+            BOOST_RANGE_CONCEPT_ASSERT((
+                SinglePassRangeConcept<SinglePassRange>));
+            return indirected_range<SinglePassRange>(rng);
         }
 
-        template<class InputRange>
-        inline indirected_range<const InputRange>
-        indirect(const InputRange& rng)
+        template<class SinglePassRange>
+        inline indirected_range<const SinglePassRange>
+        indirect(const SinglePassRange& rng)
         {
-            return indirected_range<const InputRange>(rng);
+            BOOST_RANGE_CONCEPT_ASSERT((
+                SinglePassRangeConcept<const SinglePassRange>));
+
+            return indirected_range<const SinglePassRange>(rng);
         }
     } // 'adaptors'
 
 }