Revert "push_back: added support for not-copyable but moveable value-types li…"

Include boost/next_prior.hpp where needed

.travis.yml

@@ -0,0 +1,131 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc-5 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc-5 CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc-6 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc-6 CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc-7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc-7 CXXSTD=14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=03,11
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/range
+  - python tools/boostdep/depinst/depinst.py range
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - ./b2 -j 3 libs/range/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

doc/reference/ranges/irange.qbk

@@ -10,7 +10,11 @@
 ``
 template<class Integer>
 iterator_range< range_detail::integer_iterator<Integer> >
-irange(Integer first, Integer  last);
+irange(Integer last);
+
+template<class Integer>
+iterator_range< range_detail::integer_iterator<Integer> >
+irange(Integer first, Integer last);
 
 template<class Integer, class StepSize>
 iterator_range< range_detail::integer_iterator_with_step<Integer, StepSize> >
@@ -37,4 +41,3 @@ Defined in the header file `boost/range/irange.hpp`
 Constant. Since this function generates a new range the most significant performance cost is incurred through the iteration of the generated range.
 
 [endsect]
-

include/boost/range/adaptor/sliced.hpp

@@ -15,6 +15,7 @@
 #include <boost/range/size_type.hpp>
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/concepts.hpp>
+#include <boost/next_prior.hpp>
 
 namespace boost
 {

include/boost/range/algorithm_ext/push_back.hpp

@@ -20,37 +20,9 @@
 
 namespace boost
 {
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-    namespace range_detail
+    namespace range
     {
 
-template < class Container, class Range >
-inline Container& push_back_impl( Container& on, Range&& from, std::false_type)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Range> ));
-    BOOST_ASSERT_MSG(!range_detail::is_same_object(on, from),
-        "cannot move from a container to itself");
-    on.insert( on.end(),
-               std::make_move_iterator(boost::begin(from)),
-               std::make_move_iterator(boost::end(from)));
-    return on;
-}
-
-template < class Container, class Range >
-inline Container& push_back_impl( Container& on, const Range& from, std::true_type)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const Range> ));
-    BOOST_ASSERT_MSG(!range_detail::is_same_object(on, from),
-        "cannot copy from a container to itself");
-    on.insert( on.end(), boost::begin(from), boost::end(from));
-    return on;
-}
-
-    } //namespace range_detail
-#endif
-
-    namespace range {
-#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 template< class Container, class Range >
 inline Container& push_back( Container& on, const Range& from )
 {
@@ -62,19 +34,6 @@ inline Container& push_back( Container& on, const Range& from )
     return on;
 }
 
-#else
-
-template< class Container, class Range >
-inline Container& push_back( Container& on, Range&& from )
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Container> ));
-    range_detail::push_back_impl(on,
-                                 std::forward<Range>(from),
-                                 std::is_lvalue_reference<Range>() );
-    return on;
-}
-
-#endif
     } // namespace range
     using range::push_back;
 } // namespace boost

include/boost/range/detail/microsoft.hpp

@@ -58,6 +58,7 @@
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/utility/addressof.hpp>
 #include <boost/utility/enable_if.hpp> // disable_if
+#include <boost/next_prior.hpp>
 
 #if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
     #include <boost/range/mutable_iterator.hpp>

include/boost/range/detail/range_return.hpp

@@ -12,6 +12,7 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/iterator_range.hpp>
+#include <boost/next_prior.hpp>
 
 namespace boost
 {

include/boost/range/irange.hpp

@@ -203,22 +203,6 @@ namespace boost
         }
     };
 
-    template<typename Integer>
-    integer_range<Integer>
-    irange(int last)
-    {
-        BOOST_ASSERT( 0 <= last );
-        return integer_range<Integer>(0, last);
-    }
-
-    template<typename Integer>
-    integer_range<Integer>
-    irange(int first, int last)
-    {
-        BOOST_ASSERT( first <= last );
-        return integer_range<Integer>(first, last);
-    }
-
     template<typename Integer>
     integer_range<Integer>
     irange(Integer first, Integer last)
@@ -233,7 +217,7 @@ namespace boost
     {
         BOOST_ASSERT( step_size != 0 );
         BOOST_ASSERT( (step_size > 0) ? (last >= first) : (last <= first) );
-        
+
         typedef typename range_detail::integer_iterator_with_step<Integer> iterator_t;
 
         const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(step_size >= 0 ? step_size : -step_size);
@@ -241,12 +225,19 @@ namespace boost
         const Integer f = step_size >= 0 ? first : last;
         const std::ptrdiff_t num_steps = (l - f) / sz + ((l - f) % sz ? 1 : 0);
         BOOST_ASSERT(num_steps >= 0);
-       
+
         return strided_integer_range<Integer>(
             iterator_t(first, 0, step_size),
             iterator_t(first, num_steps, step_size));
     }
 
+    template<typename Integer>
+    integer_range<Integer>
+    irange(Integer last)
+    {
+        return integer_range<Integer>(static_cast<Integer>(0), last);
+    }
+
 } // namespace boost
 
 #endif // include guard

include/boost/range/iterator_range_core.hpp

@@ -42,6 +42,7 @@
 #include <boost/range/algorithm/equal.hpp>
 #include <boost/range/detail/safe_bool.hpp>
 #include <boost/utility/enable_if.hpp>
+#include <boost/next_prior.hpp>
 #include <iterator>
 #include <algorithm>
 #include <cstddef>

test/Jamfile.v2

@@ -221,3 +221,5 @@ test-suite range :
     [ range-test value_type ]
     ;
 
+# `quick` target (for CI)
+alias quick : std_container ;

test/algorithm_ext_test/push_back.cpp

@@ -19,7 +19,6 @@
 #include <list>
 #include <vector>
 
-
 namespace
 {
     template< class Container >
@@ -59,76 +58,6 @@ namespace
         test_push_back_impl< std::vector<std::size_t> >();
         test_push_back_impl< std::list<std::size_t> >();
     }
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-    // test type which is not copyable by moveable.
-    class noncopyable_int : boost::noncopyable {
-      private:
-        int i;
-      public:
-        noncopyable_int(int x) : i(x) {}
-        noncopyable_int(const noncopyable_int&) = delete;
-        noncopyable_int& operator=(const noncopyable_int&) = delete;
-        noncopyable_int(noncopyable_int&& o) : i(o.i) {}
-        noncopyable_int& operator=(noncopyable_int&& o) { return o; }
-        bool operator!=(const noncopyable_int &rhs) { return i != rhs.i; }
-        friend std::ostream &operator<<(std::ostream &os, const noncopyable_int& x);
-    };
-
-    std::ostream & operator<<(std::ostream &os, const noncopyable_int& x)
-    {
-       return os << x.i;
-    }
-
-    template< class Container >
-    void test_push_back_move_impl(std::size_t n)
-    {
-        Container test;
-        Container reference;
-        for (std::size_t i = 0; i < n; ++i)
-            reference.push_back(noncopyable_int(i));
-
-        {
-            Container to_push_back;
-            for (std::size_t i = 0; i < n; ++i)
-                to_push_back.push_back(noncopyable_int(i));
-
-            boost::push_back(test, std::move(to_push_back));
-
-            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                test.begin(), test.end() );
-        }
-        // Do it again to push onto non-empty container
-        for (std::size_t i = 0; i < n; ++i)
-            reference.push_back(noncopyable_int(i));
-
-        {
-            Container to_push_back;
-            for (std::size_t i = 0; i < n; ++i)
-                to_push_back.push_back(noncopyable_int(i));
-
-            boost::push_back(test, std::move(to_push_back));
-
-            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                test.begin(), test.end() );
-        }
-    }
-
-    template< class Container >
-    void test_push_back_move_impl()
-    {
-        test_push_back_move_impl< Container >(0);
-        test_push_back_move_impl< Container >(1);
-        test_push_back_move_impl< Container >(2);
-        test_push_back_move_impl< Container >(100);
-    }
-
-    void test_push_back_move()
-    {
-        test_push_back_move_impl< std::vector<noncopyable_int> >();
-        test_push_back_move_impl< std::list<noncopyable_int> >();
-    }
-#endif
 }
 
 boost::unit_test::test_suite*
@@ -138,9 +67,6 @@ init_unit_test_suite(int argc, char* argv[])
         = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.push_back" );
 
     test->add( BOOST_TEST_CASE( &test_push_back ) );
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-    test->add( BOOST_TEST_CASE( &test_push_back_move ) );
-#endif
 
     return test;
 }

test/irange.cpp

@@ -18,6 +18,23 @@
 
 namespace boost
 {
+    // Test an integer range with a step size of 1.
+    template<typename Integer>
+    void test_irange_impl(Integer last)
+    {
+        std::vector<Integer> reference;
+        for (Integer i = static_cast<Integer>(0); i < last; ++i)
+        {
+            reference.push_back(i);
+        }
+
+        std::vector<Integer> test;
+        boost::push_back(test, boost::irange(last));
+
+        BOOST_CHECK_EQUAL_COLLECTIONS( test.begin(), test.end(),
+                                       reference.begin(), reference.end() );
+    }
+
     // Test an integer range with a step size of 1.
     template<typename Integer>
     void test_irange_impl(Integer first, Integer last)
@@ -34,36 +51,52 @@ namespace boost
         BOOST_CHECK_EQUAL_COLLECTIONS( test.begin(), test.end(),
                                        reference.begin(), reference.end() );
     }
-    
+
     // Test an integer range with a runtime specified step size.
     template<typename Integer, typename IntegerInput>
     void test_irange_impl(IntegerInput first, IntegerInput last, int step)
     {
         BOOST_ASSERT( step != 0 );
-        
+
         // Skip tests that have negative values if the type is
         // unsigned
         if ((static_cast<IntegerInput>(static_cast<Integer>(first)) != first)
         ||  (static_cast<IntegerInput>(static_cast<Integer>(last)) != last))
             return;
-        
+
         std::vector<Integer> reference;
 
         const std::ptrdiff_t first_p = static_cast<std::ptrdiff_t>(first);
         const std::ptrdiff_t last_p = static_cast<std::ptrdiff_t>(last);
         const std::ptrdiff_t step_p = static_cast<std::ptrdiff_t>(step);
-        for (std::ptrdiff_t current_value = first_p; 
+        for (std::ptrdiff_t current_value = first_p;
              step_p >= 0 ? current_value < last_p : current_value > last_p;
              current_value += step_p)
             reference.push_back(current_value);
 
         std::vector<Integer> test;
         boost::push_back(test, boost::irange(first, last, step));
-        
+
         BOOST_CHECK_EQUAL_COLLECTIONS( test.begin(), test.end(),
                                        reference.begin(), reference.end() );
     }
 
+    // Test driver function that for an integer range [first, last)
+    // drives the test implementation through various integer
+    // types.
+    void test_irange(int last)
+    {
+        test_irange_impl<signed char>(last);
+        test_irange_impl<unsigned char>(last);
+        test_irange_impl<signed short>(last);
+        test_irange_impl<unsigned short>(last);
+        test_irange_impl<signed int>(last);
+        test_irange_impl<unsigned int>(last);
+        test_irange_impl<signed long>(last);
+        test_irange_impl<unsigned long>(last);
+    }
+
+
     // Test driver function that for an integer range [first, last)
     // drives the test implementation through various integer
     // types.
@@ -102,6 +135,11 @@ namespace boost
     // number of implementation branches.
     void irange_unit_test()
     {
+        // Test the single-step version of irange(last)
+        test_irange(0);
+        test_irange(1);
+        test_irange(10);
+
         // Test the single-step version of irange(first, last)
         test_irange(0, 0);
         test_irange(0, 1);
@@ -124,14 +162,14 @@ namespace boost
         test_irange(9, -9, -2);
         test_irange(10, 20, 5);
         test_irange(20, 10, -5);
-        
+
         test_irange(0, 0, 3);
         test_irange(0, 1, 3);
         test_irange(0, 2, 3);
         test_irange(0, 3, 3);
         test_irange(0, 4, 3);
         test_irange(0, 10, 3);
-        
+
         test_irange(0, 0, -3);
         test_irange(0, -1, -3);
         test_irange(0, -2, -3);