From b4f00e3c18c6b101a1d23982f67942b647da3b04 Mon Sep 17 00:00:00 2001 From: Nathan Ridge Date: Tue, 20 Aug 2013 06:06:12 +0000 Subject: [PATCH 01/60] [range] Fixed a bug in join_iterator where joining a const range and a non-const range led to a compiler error (refs #8483). [SVN r85400] --- include/boost/range/detail/join_iterator.hpp | 8 ++++++-- test/join.cpp | 13 +++++++++++++ 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/include/boost/range/detail/join_iterator.hpp b/include/boost/range/detail/join_iterator.hpp index bbdeec7..70ecf65 100644 --- a/include/boost/range/detail/join_iterator.hpp +++ b/include/boost/range/detail/join_iterator.hpp @@ -143,8 +143,12 @@ template::type >::type >::value, - typename add_const< - typename iterator_reference::type + typename add_reference< + typename add_const< + typename remove_reference< + typename iterator_reference::type + >::type + >::type >::type, typename iterator_reference::type >::type diff --git a/test/join.cpp b/test/join.cpp index 290e651..b30d060 100644 --- a/test/join.cpp +++ b/test/join.cpp @@ -257,6 +257,18 @@ namespace boost test_join_impl< std::vector, std::deque >(); test_join_impl< std::deque, std::vector >(); } + + void test_join_iterator_reference_type_constness_ticket8483() + { + // Just test that this compiles. + // Before the fix for bug 8483, the reference type of the joined + // range's iterator was incorrect ('int&' instead of 'const int&'), + // causing compiler errors. + const std::vector v1; + std::vector v2; + std::vector joined; + boost::push_back(joined, join(v1, v2)); + } } } @@ -268,6 +280,7 @@ init_unit_test_suite(int argc, char* argv[]) = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.joined" ); test->add( BOOST_TEST_CASE( &boost::join_test ) ); + test->add( BOOST_TEST_CASE( &boost::test_join_iterator_reference_type_constness_ticket8483 ) ); return test; } From 2480b52f5b511708f4f3450dcd7f071e185d8fca Mon Sep 17 00:00:00 2001 From: Tim Blechmann Date: Fri, 6 Sep 2013 08:51:00 +0000 Subject: [PATCH 02/60] range: silence some warnings [SVN r85584] --- include/boost/range/algorithm/unique.hpp | 2 +- include/boost/range/detail/range_return.hpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) mode change 100755 => 100644 include/boost/range/algorithm/unique.hpp mode change 100755 => 100644 include/boost/range/detail/range_return.hpp diff --git a/include/boost/range/algorithm/unique.hpp b/include/boost/range/algorithm/unique.hpp old mode 100755 new mode 100644 index be6eaf9..9901c24 --- a/include/boost/range/algorithm/unique.hpp +++ b/include/boost/range/algorithm/unique.hpp @@ -86,7 +86,7 @@ unique( const ForwardRange& rng ) /// \overload template< class ForwardRange, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return::type -unique( ForwardRange& rng, BinaryPredicate pred ) +unique( ForwardRange& rng, BinaryPredicate ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); return ::boost::range::unique(rng); diff --git a/include/boost/range/detail/range_return.hpp b/include/boost/range/detail/range_return.hpp old mode 100755 new mode 100644 index 52a6073..773a72a --- a/include/boost/range/detail/range_return.hpp +++ b/include/boost/range/detail/range_return.hpp @@ -168,7 +168,7 @@ namespace boost typedef boost::iterator_range< BOOST_DEDUCED_TYPENAME range_iterator::type > type; - static type pack(BOOST_DEDUCED_TYPENAME range_iterator::type found, + static type pack(BOOST_DEDUCED_TYPENAME range_iterator::type, SinglePassRange& rng) { return type(boost::begin(rng), boost::end(rng)); From a59819fc6e0c85eea7154d3ab4073552e717ec3d Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sun, 15 Sep 2013 18:05:49 +0000 Subject: [PATCH 03/60] [boost][range] - fix for ticket 8341 - has_range_iterator [SVN r85682] --- include/boost/range/has_range_iterator.hpp | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/include/boost/range/has_range_iterator.hpp b/include/boost/range/has_range_iterator.hpp index 8046eb4..3c7b083 100644 --- a/include/boost/range/has_range_iterator.hpp +++ b/include/boost/range/has_range_iterator.hpp @@ -7,10 +7,14 @@ // // For more information, see http://www.boost.org/libs/range/ // +// Acknowledgments: +// Ticket #8341: Arno Schoedl - improved handling of has_range_iterator upon +// use-cases where T was const. #ifndef BOOST_RANGE_HAS_ITERATOR_HPP_INCLUDED #define BOOST_RANGE_HAS_ITERATOR_HPP_INCLUDED #include +#include #include #include #include @@ -28,7 +32,16 @@ namespace boost }; template - struct has_range_iterator_impl > >::type> + struct has_range_iterator_impl< + T, + BOOST_DEDUCED_TYPENAME enable_if< + BOOST_DEDUCED_TYPENAME mpl::eval_if, + has_type::type> >, + has_type > + >::type + >::type + > : boost::mpl::true_ { }; @@ -40,7 +53,12 @@ namespace boost }; template - struct has_range_const_iterator_impl > >::type> + struct has_range_const_iterator_impl< + T, + BOOST_DEDUCED_TYPENAME enable_if< + has_type > + >::type + > : boost::mpl::true_ { }; From 90ce7f3703fca85cd33fa36d5e6e8933b41dd63a Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sun, 15 Sep 2013 19:44:36 +0000 Subject: [PATCH 04/60] [boost][range] - fix for ticket 6888 - unique predicate overloads [SVN r85686] --- include/boost/range/algorithm/unique.hpp | 6 +- include/boost/range/config.hpp | 6 ++ test/adaptor_test/strided.cpp | 10 +- test/algorithm.cpp | 7 +- test/algorithm_test/unique.cpp | 94 +++++++++++++++++-- test/compile_fail/iterator_range1.cpp | 1 + .../range_overload_test_driver.hpp | 74 +++++++++++++++ 7 files changed, 183 insertions(+), 15 deletions(-) mode change 100755 => 100644 include/boost/range/config.hpp create mode 100644 test/test_driver/range_overload_test_driver.hpp diff --git a/include/boost/range/algorithm/unique.hpp b/include/boost/range/algorithm/unique.hpp index 9901c24..8017a83 100644 --- a/include/boost/range/algorithm/unique.hpp +++ b/include/boost/range/algorithm/unique.hpp @@ -86,14 +86,14 @@ unique( const ForwardRange& rng ) /// \overload template< class ForwardRange, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return::type -unique( ForwardRange& rng, BinaryPredicate ) +unique( ForwardRange& rng, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); - return ::boost::range::unique(rng); + return ::boost::range::unique(rng, pred); } /// \overload template< class ForwardRange, class BinaryPredicate > -inline BOOST_DEDUCED_TYPENAME range_iterator::type +inline BOOST_DEDUCED_TYPENAME range_return::type unique( const ForwardRange& rng, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); diff --git a/include/boost/range/config.hpp b/include/boost/range/config.hpp old mode 100755 new mode 100644 index 4e7fb24..cf9e204 --- a/include/boost/range/config.hpp +++ b/include/boost/range/config.hpp @@ -48,6 +48,12 @@ #define BOOST_RANGE_ARRAY_REF() (&boost_range_array) #endif +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) +# define BOOST_RANGE_UNUSED __attribute__((unused)) +#else +# define BOOST_RANGE_UNUSED +#endif + #endif diff --git a/test/adaptor_test/strided.cpp b/test/adaptor_test/strided.cpp index aa80068..b49cfc6 100644 --- a/test/adaptor_test/strided.cpp +++ b/test/adaptor_test/strided.cpp @@ -13,6 +13,7 @@ // #include +#include #include #include @@ -42,9 +43,12 @@ namespace boost Container reference; { - typedef BOOST_DEDUCED_TYPENAME Container::const_iterator iterator_t; - typedef BOOST_DEDUCED_TYPENAME Container::difference_type diff_t; - typedef BOOST_DEDUCED_TYPENAME Container::size_type size_type; + typedef BOOST_DEDUCED_TYPENAME Container::const_iterator + iterator_t BOOST_RANGE_UNUSED; + typedef BOOST_DEDUCED_TYPENAME Container::difference_type + diff_t BOOST_RANGE_UNUSED; + typedef BOOST_DEDUCED_TYPENAME Container::size_type + size_type BOOST_RANGE_UNUSED; iterator_t it = c.begin(); iterator_t last = c.end(); diff --git a/test/algorithm.cpp b/test/algorithm.cpp index 1c0dbc3..2160eaf 100644 --- a/test/algorithm.cpp +++ b/test/algorithm.cpp @@ -35,6 +35,7 @@ #endif #include +#include #include #include #include @@ -107,9 +108,11 @@ void test_random_algorithms(Rng & rng, std::random_access_iterator_tag) { typedef BOOST_DEDUCED_TYPENAME boost::range_iterator::type iterator; typedef BOOST_DEDUCED_TYPENAME boost::range_value::type value_type; - typedef BOOST_DEDUCED_TYPENAME boost::range_size::type size_type; + typedef BOOST_DEDUCED_TYPENAME boost::range_size::type size_type BOOST_RANGE_UNUSED; typedef BOOST_DEDUCED_TYPENAME boost::iterator_category::type iterator_category; + + // just make sure these compile (for now) if(0) { @@ -328,6 +331,8 @@ void test_algorithms(Rng & rng) o = boost::adjacent_difference( rng, boost::begin(out) ); o = boost::adjacent_difference( rng, boost::begin(out), null_op2() ); + + boost::ignore_unused_variable_warning(b); } diff --git a/test/algorithm_test/unique.cpp b/test/algorithm_test/unique.cpp index 880c131..d8eb784 100644 --- a/test/algorithm_test/unique.cpp +++ b/test/algorithm_test/unique.cpp @@ -9,13 +9,15 @@ // For more information, see http://www.boost.org/libs/range/ // #include +#include #include #include #include #include -#include "../test_driver/range_return_test_driver.hpp" +#include +#include "../test_driver/range_overload_test_driver.hpp" #include #include #include @@ -60,6 +62,36 @@ namespace boost_range_test_algorithm_unique } }; + template + struct test_range_overload + { + BOOST_STATIC_CONSTANT( + ::boost::range_return_value, + result_type = ::boost::return_begin_found); + + template + BOOST_DEDUCED_TYPENAME boost::range_return< + Container, result_type + >::type + operator()(Policy& policy, Container& cont) + { + typedef BOOST_DEDUCED_TYPENAME boost::range_return< + Container,result_type>::type result_t; + + Container cont2(cont); + + result_t result = boost::unique(cont); + + boost::unique(boost::make_iterator_range(cont2)); + + BOOST_CHECK_EQUAL_COLLECTIONS( + cont.begin(), cont.end(), + cont2.begin(), cont2.end()); + + return result; + } + }; + template< class Container > BOOST_DEDUCED_TYPENAME boost::range_iterator::type reference(Container& cont) @@ -67,7 +99,7 @@ namespace boost_range_test_algorithm_unique return std::unique(cont.begin(), cont.end()); } }; - + // test the 'unique' algorithm with a predicate template class unique_pred_test_policy @@ -105,6 +137,34 @@ namespace boost_range_test_algorithm_unique return result; } }; + + template + struct test_range_overload + { + BOOST_STATIC_CONSTANT( + ::boost::range_return_value, + result_type = ::boost::return_begin_found); + + template + BOOST_DEDUCED_TYPENAME boost::range_return::type + operator()(Policy& policy, Container& cont) + { + typedef BOOST_DEDUCED_TYPENAME boost::range_return< + Container,result_type>::type result_t; + + Container cont2(cont); + + result_t result = boost::unique(cont, policy.pred()); + + boost::unique(boost::make_iterator_range(cont2), policy.pred()); + + BOOST_CHECK_EQUAL_COLLECTIONS( + cont.begin(), cont.end(), + cont2.begin(), cont2.end()); + + return result; + } + }; template< class Container > BOOST_DEDUCED_TYPENAME boost::range_iterator::type @@ -121,7 +181,7 @@ namespace boost_range_test_algorithm_unique typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t; - boost::range_test::range_return_test_driver test_driver; + boost::range_test::range_overload_test_driver test_driver; Container cont; @@ -145,6 +205,19 @@ namespace boost_range_test_algorithm_unique test_driver(cont, policy); } + + template + struct equal_div_2 + { + typedef bool result_type; + typedef const T& first_argument_type; + typedef const T& second_argument_type; + + bool operator()(const T& left, const T& right) const + { + return left / 2 == right / 2; + } + }; template void test_unique_impl() @@ -152,17 +225,22 @@ namespace boost_range_test_algorithm_unique test_unique_impl( unique_test_policy(), std::less() - ); + ); test_unique_impl( - unique_pred_test_policy >(), + unique_pred_test_policy >(), std::less() - ); + ); test_unique_impl( - unique_pred_test_policy >(), + unique_pred_test_policy >(), std::greater() - ); + ); + + test_unique_impl( + unique_pred_test_policy >(), + std::less() + ); } void test_unique() diff --git a/test/compile_fail/iterator_range1.cpp b/test/compile_fail/iterator_range1.cpp index eed4ea9..2e5eec3 100644 --- a/test/compile_fail/iterator_range1.cpp +++ b/test/compile_fail/iterator_range1.cpp @@ -16,6 +16,7 @@ namespace iterator_range_test_detail { double source[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 }; boost::iterator_range rng = boost::make_iterator_range(source); + boost::ignore_unused_variable_warning(rng); } } diff --git a/test/test_driver/range_overload_test_driver.hpp b/test/test_driver/range_overload_test_driver.hpp new file mode 100644 index 0000000..e4b2ce7 --- /dev/null +++ b/test/test_driver/range_overload_test_driver.hpp @@ -0,0 +1,74 @@ + // Copyright Neil Groves 2013. Use, modification and + // distribution is subject to the Boost Software License, Version + // 1.0. (See accompanying file LICENSE_1_0.txt or copy at + // http://www.boost.org/LICENSE_1_0.txt) + // + // + // For more information, see http://www.boost.org/libs/range/ + // + // Acknowledgments: + // Implemented by Andy in response to Ticket 6888 - unique fix + // + #ifndef BOOST_RANGE_TEST_TEST_DRIVER_RANGE_OVERLOAD_TEST_DRIVER_HPP_INCLUDED + #define BOOST_RANGE_TEST_TEST_DRIVER_RANGE_OVERLOAD_TEST_DRIVER_HPP_INCLUDED + + #include "range_return_test_driver.hpp" + #include + #include + #include + + namespace boost + { + namespace range_test + { + + // A test driver to exercise a test through range_return_test_driver + // plus the overload that determines the return_type by overload + // + // The test driver also contains the code required to check the + // return value correctness. + // + // The TestPolicy needs to implement all those required by + // range_return_test_driver, and additionally + // + // - perform the boost range version of the algorithm that determines + // the return_type by overload + class range_overload_test_driver : range_return_test_driver + { + public: + template< class Container, + class TestPolicy > + void operator()(Container& cont, TestPolicy policy) + { + range_return_test_driver::operator()(cont, policy); + test_range_overload()(cont, policy); + } + + private: + template< class Container, class TestPolicy > + struct test_range_overload + { + void operator()(Container& cont, TestPolicy policy) + { + typedef BOOST_DEDUCED_TYPENAME range_iterator::type iterator_t; + typedef BOOST_DEDUCED_TYPENAME TestPolicy::template test_range_overload test_range_overload_t; + const range_return_value result_type = test_range_overload_t::result_type; + typedef BOOST_DEDUCED_TYPENAME range_return::type range_return_t; + + Container reference(cont); + Container test_cont(cont); + + test_range_overload_t test_range_overload_fn; + range_return_t range_result = test_range_overload_fn(policy, test_cont); + + iterator_t reference_it = policy.reference(reference); + + check_results::test(test_cont, reference, + range_result, reference_it); + } + }; + }; + } + } + + #endif // include guard \ No newline at end of file From f662a07bcc303ad5f56b37a2141be60f50f38d98 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sun, 15 Sep 2013 21:54:32 +0000 Subject: [PATCH 05/60] [boost][range] Ticket 8702 - size_type detection [SVN r85690] --- include/boost/range/size_type.hpp | 13 ++- test/extension_size.cpp | 143 ++++++++++++++++++++++++++++-- 2 files changed, 147 insertions(+), 9 deletions(-) diff --git a/include/boost/range/size_type.hpp b/include/boost/range/size_type.hpp index c6fb54b..dab2f0d 100644 --- a/include/boost/range/size_type.hpp +++ b/include/boost/range/size_type.hpp @@ -17,6 +17,7 @@ #include #include +#include #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #include #else @@ -45,8 +46,8 @@ namespace boost template static yes_type test(BOOST_DEDUCED_TYPENAME C::size_type x); - template - static no_type test(Arg x); + template + static no_type test(...); public: static const bool value = sizeof(test(0)) == sizeof(yes_type); @@ -74,12 +75,16 @@ namespace boost template< class T > struct range_size : detail::range_size - { }; + { + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); + }; template< class T > struct range_size : detail::range_size - { }; + { + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); + }; } // namespace boost diff --git a/test/extension_size.cpp b/test/extension_size.cpp index 6c7157f..0df8f22 100644 --- a/test/extension_size.cpp +++ b/test/extension_size.cpp @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -27,6 +28,13 @@ namespace boost_range_extension_size_test class FooWithoutSize { typedef std::list impl_t; + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::range_size >::type, + std::list::size_type + >::value)); + typedef impl_t::const_iterator const_iterator; typedef impl_t::iterator iterator; @@ -39,12 +47,117 @@ namespace boost_range_extension_size_test private: impl_t m_impl; }; - - inline boost::range_size >::type - range_calculate_size(const FooWithoutSize& rng) + + template + class FooWithSize { - return 2u; - } + public: + typedef SizeType size_type; + typedef boost::uint8_t* iterator; + typedef const boost::uint8_t* const_iterator; + + const_iterator begin() const; + iterator begin(); + const_iterator end() const; + iterator end(); + }; + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::uint8_t, + boost::range_size >::type + >::value + )); + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::uint16_t, + boost::range_size >::type + >::value + )); + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::uint32_t, + boost::range_size >::type + >::value + )); + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::uint64_t, + boost::range_size >::type + >::value + )); + + class UdtSizeType + { + public: + typedef boost::uint16_t value_type; + + UdtSizeType() : value_(0) { } + UdtSizeType(value_type value) : value_(value) { } + + operator value_type() const { return value_; } + + private: + value_type value_; + }; + + BOOST_STATIC_ASSERT(( + boost::is_same< + UdtSizeType, + boost::range_size >::type + >::value + )); + + class Foo2WithoutSize + { + public: + struct const_iterator + { + typedef std::forward_iterator_tag iterator_category; + typedef boost::int8_t difference_type; + typedef boost::int16_t value_type; + typedef value_type* pointer; + typedef value_type& reference; + + reference operator*() const; + pointer operator->() const; + const_iterator& operator++(); + const_iterator operator++(int); + bool operator==(const const_iterator&) const; + bool operator!=(const const_iterator&) const; + }; + + struct iterator : const_iterator + { + typedef const value_type* pointer; + typedef const value_type& reference; + + reference operator*() const; + pointer operator->() const; + + iterator& operator++(); + iterator operator++(int); + + bool operator==(const iterator&) const; + bool operator!=(const iterator&) const; + }; + + const_iterator begin() const; + iterator begin(); + const_iterator end() const; + iterator end(); + }; + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::uint8_t, + boost::range_size< + ::boost_range_extension_size_test::Foo2WithoutSize>::type + >::value + )); } namespace boost @@ -60,6 +173,26 @@ namespace boost }; } +namespace boost_range_extension_size_test +{ + inline boost::range_size::type + range_calculate_size(const FooWithoutSize& rng) + { + return 2u; + } +} + +BOOST_STATIC_ASSERT(( + boost::is_same< + typename boost::make_unsigned::type, + typename boost::range_size< + boost_range_extension_size_test::FooWithoutSize>::type + >::value +)); + +typedef boost::make_unsigned::type t1; +typedef boost::range_size::type t1; + namespace { From 426e0c39a8d52d57ea3e73abf981730fd5f12caa Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sun, 15 Sep 2013 22:15:12 +0000 Subject: [PATCH 06/60] [boost][range] - changed join_iterator reference type handling to address several user observations and failing clang builds. [SVN r85691] --- include/boost/range/detail/join_iterator.hpp | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/include/boost/range/detail/join_iterator.hpp b/include/boost/range/detail/join_iterator.hpp index 70ecf65..d025c81 100644 --- a/include/boost/range/detail/join_iterator.hpp +++ b/include/boost/range/detail/join_iterator.hpp @@ -23,6 +23,10 @@ #include #include #include +#include +#include +#include +#include #include namespace boost @@ -71,7 +75,9 @@ public: Reference dereference(unsigned int selected) const { - return selected ? *m_it2 : *m_it1; + if (selected) + return *m_it2; + return *m_it1; } bool equal(const join_iterator_union& other, unsigned int selected) const @@ -143,12 +149,8 @@ template::type >::type >::value, - typename add_reference< - typename add_const< - typename remove_reference< - typename iterator_reference::type - >::type - >::type + typename add_const< + typename iterator_reference::type >::type, typename iterator_reference::type >::type From 0addcfadeb7cf357384d234bac0e96819187b4c8 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sun, 15 Sep 2013 22:15:46 +0000 Subject: [PATCH 07/60] [boost][range] - changed join_iterator reference type handling to address several user observations and failing clang builds. [SVN r85692] --- test/join.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/join.cpp b/test/join.cpp index b30d060..cff3f35 100644 --- a/test/join.cpp +++ b/test/join.cpp @@ -135,7 +135,11 @@ namespace boost { Collection1 c1(rng1); Collection2 c2(rng2); - typedef typename boost::range_value::type value_t; + + typedef BOOST_DEDUCED_TYPENAME boost::range_value< + Collection1 + >::type value_t BOOST_RANGE_UNUSED; + fill_with_ints(boost::join(c1,c2)); // Ensure that the size of the written range has not been From 2285f909f61b4d43b9267bdcac30b2f853e0a0a3 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 16 Sep 2013 10:10:12 +0000 Subject: [PATCH 08/60] [boost][range] correct lifetime defect in the tokenized range adapter [SVN r85697] --- include/boost/range/adaptor/tokenized.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) mode change 100755 => 100644 include/boost/range/adaptor/tokenized.hpp diff --git a/include/boost/range/adaptor/tokenized.hpp b/include/boost/range/adaptor/tokenized.hpp old mode 100755 new mode 100644 index 8a7402a..f0aa12e --- a/include/boost/range/adaptor/tokenized.hpp +++ b/include/boost/range/adaptor/tokenized.hpp @@ -52,9 +52,9 @@ namespace boost template< class T, class U, class V > struct regex_holder { - const T& re; - const U& sub; - V f; + T re; + U sub; + V f; regex_holder( const T& rex, const U& subm, V flag ) : re(rex), sub(subm), f(flag) From 30e6df5a15bb7db03fdeeb76b59dc3828341bbea Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 16 Sep 2013 11:21:36 +0000 Subject: [PATCH 09/60] [boost][range] - removed warnings found building with clang 3.2. [SVN r85698] --- include/boost/range/size_type.hpp | 4 ++-- test/adaptor_test/strided.cpp | 1 + test/algorithm_test/copy.cpp | 2 +- test/algorithm_test/stable_partition.cpp | 2 ++ test/algorithm_test/transform.cpp | 4 ++++ test/compat2.cpp | 2 ++ test/extension_size.cpp | 4 ++-- 7 files changed, 14 insertions(+), 5 deletions(-) diff --git a/include/boost/range/size_type.hpp b/include/boost/range/size_type.hpp index dab2f0d..800ec15 100644 --- a/include/boost/range/size_type.hpp +++ b/include/boost/range/size_type.hpp @@ -76,14 +76,14 @@ namespace boost struct range_size : detail::range_size { - BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)) }; template< class T > struct range_size : detail::range_size { - BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)) }; } // namespace boost diff --git a/test/adaptor_test/strided.cpp b/test/adaptor_test/strided.cpp index b49cfc6..290cd4b 100644 --- a/test/adaptor_test/strided.cpp +++ b/test/adaptor_test/strided.cpp @@ -132,6 +132,7 @@ namespace boost typedef boost::strided_range strided_range_t; strided_range_t rng( boost::adaptors::stride(c, 0) ); + boost::ignore_unused_variable_warning(rng); typedef BOOST_DEDUCED_TYPENAME boost::range_iterator::type iter_t; iter_t first(boost::begin(c), boost::begin(c), boost::end(c), 0); diff --git a/test/algorithm_test/copy.cpp b/test/algorithm_test/copy.cpp index 47f4172..4b9fcc2 100644 --- a/test/algorithm_test/copy.cpp +++ b/test/algorithm_test/copy.cpp @@ -43,7 +43,7 @@ namespace boost source.begin(), source.end() ); - it == boost::copy(boost::make_iterator_range(source), target.begin()); + it = boost::copy(boost::make_iterator_range(source), target.begin()); BOOST_CHECK( it == target.end() ); diff --git a/test/algorithm_test/stable_partition.cpp b/test/algorithm_test/stable_partition.cpp index 3bf20e2..b39161f 100644 --- a/test/algorithm_test/stable_partition.cpp +++ b/test/algorithm_test/stable_partition.cpp @@ -71,6 +71,8 @@ namespace boost_range_test_algorithm_stable_partition result_t result2 = boost::stable_partition( boost::make_iterator_range(cont2), policy.pred()); + + boost::ignore_unused_variable_warning(result2); BOOST_CHECK_EQUAL_COLLECTIONS( cont2.begin(), cont2.end(), cont.begin(), cont.end() ); diff --git a/test/algorithm_test/transform.cpp b/test/algorithm_test/transform.cpp index 3e37180..11ac5f0 100644 --- a/test/algorithm_test/transform.cpp +++ b/test/algorithm_test/transform.cpp @@ -41,6 +41,8 @@ namespace boost iterator_t reference_it = std::transform(cont.begin(), cont.end(), reference.begin(), fn); + + boost::ignore_unused_variable_warning(reference_it); iterator_t test_it = boost::transform(cont, target.begin(), fn); @@ -101,6 +103,8 @@ namespace boost iterator_t reference_it = std::transform(cont1.begin(), cont1.end(), cont2.begin(), reference.begin(), fn); + + boost::ignore_unused_variable_warning(reference_it); iterator_t test_it = boost::transform(cont1, cont2, target.begin(), fn); diff --git a/test/compat2.cpp b/test/compat2.cpp index 2874c04..feaa047 100644 --- a/test/compat2.cpp +++ b/test/compat2.cpp @@ -10,6 +10,7 @@ #include #include +#include #include enum Container {}; @@ -51,6 +52,7 @@ void compat1() { std::vector v; iterator_of< std::vector >::type i = v.begin(); + boost::ignore_unused_variable_warning(i); } #include diff --git a/test/extension_size.cpp b/test/extension_size.cpp index 0df8f22..202f465 100644 --- a/test/extension_size.cpp +++ b/test/extension_size.cpp @@ -184,8 +184,8 @@ namespace boost_range_extension_size_test BOOST_STATIC_ASSERT(( boost::is_same< - typename boost::make_unsigned::type, - typename boost::range_size< + boost::make_unsigned::type, + boost::range_size< boost_range_extension_size_test::FooWithoutSize>::type >::value )); From cca97390221a157bca482fb4153de906fad6eb95 Mon Sep 17 00:00:00 2001 From: Andrey Semashev Date: Mon, 16 Sep 2013 17:13:20 +0000 Subject: [PATCH 10/60] Fixed compilation with gcc 4.7. [SVN r85707] --- include/boost/range/size_type.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/boost/range/size_type.hpp b/include/boost/range/size_type.hpp index 800ec15..dab2f0d 100644 --- a/include/boost/range/size_type.hpp +++ b/include/boost/range/size_type.hpp @@ -76,14 +76,14 @@ namespace boost struct range_size : detail::range_size { - BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)) + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); }; template< class T > struct range_size : detail::range_size { - BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)) + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); }; } // namespace boost From 34cea300e5711482f9651f2aad5d997670bc52e9 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 16 Sep 2013 23:23:38 +0000 Subject: [PATCH 11/60] [boost][range] - fix a very odd compilation problem in range_size that only occurs on clang 4.2 on the Mac (clang 4.2 on linux is fine) [SVN r85717] --- include/boost/range/size_type.hpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/include/boost/range/size_type.hpp b/include/boost/range/size_type.hpp index dab2f0d..cc99ef3 100644 --- a/include/boost/range/size_type.hpp +++ b/include/boost/range/size_type.hpp @@ -76,14 +76,22 @@ namespace boost struct range_size : detail::range_size { +// Very strange things happen on some compilers that have the range concept +// asserts disabled. This preprocessor condition is clearly redundant on a +// working compiler but is vital for at least some compilers such as clang 4.2 +// but only on the Mac! +#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1 BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); +#endif }; template< class T > struct range_size : detail::range_size { +#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1 BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept)); +#endif }; } // namespace boost From 8af782611e1db48d5d34baa0f40aa24f883ea1b5 Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Wed, 25 Sep 2013 21:12:40 +0000 Subject: [PATCH 12/60] Range: Remove ATL specific define for old MSVC. [SVN r85912] --- include/boost/range/atl.hpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/include/boost/range/atl.hpp b/include/boost/range/atl.hpp index ab492d9..e6500e5 100644 --- a/include/boost/range/atl.hpp +++ b/include/boost/range/atl.hpp @@ -35,15 +35,6 @@ #endif -#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING) - #if (_MSC_VER < 1310) // from , but dubious - #define BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING - #endif -#endif - - - - // forward declarations // From 650b75d2d7d20e5e5abce5492d802d5199973b3c Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Wed, 25 Sep 2013 21:13:39 +0000 Subject: [PATCH 13/60] Range: Remove obsolete MSVC version checks. [SVN r85915] --- include/boost/range.hpp | 10 -- include/boost/range/config.hpp | 8 +- include/boost/range/detail/begin.hpp | 11 -- include/boost/range/detail/end.hpp | 21 +-- include/boost/range/detail/size.hpp | 23 +-- include/boost/range/detail/vc6/end.hpp | 170 -------------------- include/boost/range/detail/vc6/size.hpp | 166 ------------------- include/boost/range/iterator_range_core.hpp | 2 - 8 files changed, 9 insertions(+), 402 deletions(-) mode change 100755 => 100644 include/boost/range/detail/size.hpp delete mode 100755 include/boost/range/detail/vc6/end.hpp delete mode 100755 include/boost/range/detail/vc6/size.hpp diff --git a/include/boost/range.hpp b/include/boost/range.hpp index 535edaf..2aeb393 100644 --- a/include/boost/range.hpp +++ b/include/boost/range.hpp @@ -15,19 +15,9 @@ # pragma once #endif -#if defined(_MSC_VER) && (_MSC_VER == 1300) - -#include -#include -#include - -#else - #include #include #include #include -#endif // _MSC_VER == 1300 - #endif diff --git a/include/boost/range/config.hpp b/include/boost/range/config.hpp index cf9e204..fc2693e 100644 --- a/include/boost/range/config.hpp +++ b/include/boost/range/config.hpp @@ -26,18 +26,14 @@ #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) # define BOOST_RANGE_DEDUCED_TYPENAME typename #else -# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS) -# define BOOST_RANGE_DEDUCED_TYPENAME typename -# else -# define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME -# endif +#define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME #endif #ifdef BOOST_RANGE_NO_ARRAY_SUPPORT #error "macro already defined!" #endif -#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) +#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) #define BOOST_RANGE_NO_ARRAY_SUPPORT 1 #endif diff --git a/include/boost/range/detail/begin.hpp b/include/boost/range/detail/begin.hpp index f3da732..1d9390f 100644 --- a/include/boost/range/detail/begin.hpp +++ b/include/boost/range/detail/begin.hpp @@ -15,9 +15,6 @@ #include #include #include -#if BOOST_WORKAROUND(BOOST_MSVC, < 1310) -# include -#endif namespace boost { @@ -62,19 +59,11 @@ namespace boost template<> struct range_begin { - #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) - template< typename T, std::size_t sz > - static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] ) - { - return boost_range_array; - } - #else template static BOOST_RANGE_DEDUCED_TYPENAME range_value::type* fun(T& t) { return t; } - #endif }; } // namespace 'range_detail' diff --git a/include/boost/range/detail/end.hpp b/include/boost/range/detail/end.hpp index 8b5f35d..f2f7178 100644 --- a/include/boost/range/detail/end.hpp +++ b/include/boost/range/detail/end.hpp @@ -14,15 +14,9 @@ #include // BOOST_MSVC #include -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -# include -#else -# include -# include -# include -# if BOOST_WORKAROUND(BOOST_MSVC, < 1310) -# include -# endif +#include +#include +#include namespace boost { @@ -68,19 +62,11 @@ namespace boost template<> struct range_end { - #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) - template< typename T, std::size_t sz > - static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] ) - { - return boost::range_detail::array_end( boost_range_array ); - } - #else template static BOOST_RANGE_DEDUCED_TYPENAME remove_extent::type* fun(T& t) { return t + remove_extent::size; } - #endif }; } // namespace 'range_detail' @@ -97,5 +83,4 @@ namespace boost } // namespace 'boost' -# endif // VC6 #endif diff --git a/include/boost/range/detail/size.hpp b/include/boost/range/detail/size.hpp old mode 100755 new mode 100644 index fe52ba0..eec134c --- a/include/boost/range/detail/size.hpp +++ b/include/boost/range/detail/size.hpp @@ -14,16 +14,10 @@ #include // BOOST_MSVC #include -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -# include -#else -# include -# include -# include -# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) -# include -# endif -# include +#include +#include +#include +#include namespace boost { @@ -68,19 +62,11 @@ namespace boost template<> struct range_size_ { - #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - template< typename T, std::size_t sz > - static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] ) - { - return sz; - } - #else template static std::size_t fun(T& t) { return remove_extent::size; } - #endif }; template<> @@ -155,5 +141,4 @@ namespace boost } // namespace 'boost' -# endif #endif diff --git a/include/boost/range/detail/vc6/end.hpp b/include/boost/range/detail/vc6/end.hpp deleted file mode 100755 index 4f76af5..0000000 --- a/include/boost/range/detail/vc6/end.hpp +++ /dev/null @@ -1,170 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 2003-2004. Use, modification and -// distribution is subject to the Boost Software License, Version -// 1.0. (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// For more information, see http://www.boost.org/libs/range/ -// - -#ifndef BOOST_RANGE_DETAIL_VC6_END_HPP -#define BOOST_RANGE_DETAIL_VC6_END_HPP - -#include -#include -#include -#include -#include - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_end; - - ////////////////////////////////////////////////////////////////////// - // default - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end - { - template< typename C > - struct inner { - static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator::type - fun( C& c ) - { - return c.end(); - }; - }; - }; - - ////////////////////////////////////////////////////////////////////// - // pair - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end - { - template< typename P > - struct inner { - static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator

::type - fun( const P& p ) - { - return p.second; - } - }; - }; - - ////////////////////////////////////////////////////////////////////// - // array - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end - { - template< typename T > - struct inner { - static BOOST_DEDUCED_TYPENAME remove_extent::type* - fun(T& t) - { - return t + remove_extent::size; - } - }; - }; - - - template<> - struct range_end - { - template< typename T > - struct inner { - static BOOST_DEDUCED_TYPENAME remove_extent::type* - fun(T& t) - { - return t + remove_extent::size; - } - }; - }; - - template<> - struct range_end - { - template< typename T > - struct inner { - static BOOST_DEDUCED_TYPENAME remove_extent::type* - fun(T& t) - { - return t + remove_extent::size; - } - }; - }; - - ////////////////////////////////////////////////////////////////////// - // string - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end - { - template< typename T > - struct inner { - static char* fun( char* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - template<> - struct range_end - { - template< typename T > - struct inner { - static const char* fun( const char* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - template<> - struct range_end - { - template< typename T > - struct inner { - static wchar_t* fun( wchar_t* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - - template<> - struct range_end - { - template< typename T > - struct inner { - static const wchar_t* fun( const wchar_t* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - } // namespace 'range_detail' - - template< typename C > - inline BOOST_DEDUCED_TYPENAME range_result_iterator::type - end( C& c ) - { - return range_detail::range_end::type>::inner::fun( c ); - } - -} // namespace 'boost' - - -#endif diff --git a/include/boost/range/detail/vc6/size.hpp b/include/boost/range/detail/vc6/size.hpp deleted file mode 100755 index 39f559f..0000000 --- a/include/boost/range/detail/vc6/size.hpp +++ /dev/null @@ -1,166 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 2003-2004. Use, modification and -// distribution is subject to the Boost Software License, Version -// 1.0. (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// For more information, see http://www.boost.org/libs/range/ -// - - -#ifndef BOOST_RANGE_DETAIL_VC6_SIZE_HPP -#define BOOST_RANGE_DETAIL_VC6_SIZE_HPP - -#include -#include -#include -#include -#include - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_size_; - - ////////////////////////////////////////////////////////////////////// - // default - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - template< typename C > - struct inner { - static BOOST_RANGE_DEDUCED_TYPENAME C::size_type fun( const C& c ) - { - return c.size(); - }; - }; - }; - - ////////////////////////////////////////////////////////////////////// - // pair - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - template< typename P > - struct inner { - static BOOST_RANGE_DEDUCED_TYPENAME range_size

::type - fun( const P& p ) - { - return std::distance( p.first, p.second ); - } - }; - }; - - ////////////////////////////////////////////////////////////////////// - // array - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - template - struct inner { - static std::size_t fun(T& t) - { - return remove_extent::size; - } - }; - }; - - template<> - struct range_size_ - { - template - struct inner { - static std::size_t fun(T& t) - { - return sizeof(T) / sizeof(T[0]); - } - }; - }; - - template<> - struct range_size_ - { - template - struct inner { - static std::size_t fun(T& t) - { - return sizeof(T) / sizeof(T[0]); - } - }; - }; - - ////////////////////////////////////////////////////////////////////// - // string - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - template - struct inner { - static std::size_t fun( const char* s ) - { - return boost::range_detail::str_size( s ); - } - }; - }; - - template<> - struct range_size_ - { - template - struct inner { - static std::size_t fun( const char* s ) - { - return boost::range_detail::str_size( s ); - } - }; - }; - - template<> - struct range_size_ - { - template - struct inner { - static std::size_t fun( const wchar_t* s ) - { - return boost::range_detail::str_size( s ); - } - }; - }; - - template<> - struct range_size_ - { - template - struct inner { - static std::size_t fun( const wchar_t* s ) - { - return boost::range_detail::str_size( s ); - } - }; - }; - - } // namespace 'range_detail' - - - template< typename C > - BOOST_RANGE_DEDUCED_TYPENAME range_size::type - size( const C& c ) - { - return range_detail::range_size_::type>::inner::fun( c ); - } - -} // namespace 'boost' - - -#endif diff --git a/include/boost/range/iterator_range_core.hpp b/include/boost/range/iterator_range_core.hpp index 6e68992..f985641 100644 --- a/include/boost/range/iterator_range_core.hpp +++ b/include/boost/range/iterator_range_core.hpp @@ -207,14 +207,12 @@ namespace boost m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ) {} - #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) this_type& operator=( const this_type& r ) { m_Begin = r.begin(); m_End = r.end(); return *this; } - #endif template< class Iterator > iterator_range& operator=( const iterator_range& r ) From 4f34d9515698088ab78b0f845ac684150f5fa843 Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Thu, 26 Sep 2013 13:02:51 +0000 Subject: [PATCH 14/60] Remove obsolete MSVC check from pragma guard git grep -h -B1 "^#\s*pragma once" | grep -v pragma | sort | uniq is now clean. [SVN r85952] --- include/boost/range.hpp | 2 +- include/boost/range/algorithm.hpp | 2 +- include/boost/range/as_array.hpp | 2 +- include/boost/range/as_literal.hpp | 2 +- include/boost/range/begin.hpp | 2 +- include/boost/range/category.hpp | 2 +- include/boost/range/config.hpp | 2 +- include/boost/range/const_iterator.hpp | 2 +- include/boost/range/const_reverse_iterator.hpp | 2 +- include/boost/range/detail/as_literal.hpp | 2 +- include/boost/range/detail/common.hpp | 2 +- include/boost/range/detail/extract_optional_type.hpp | 2 +- include/boost/range/detail/sizer.hpp | 2 +- include/boost/range/difference_type.hpp | 2 +- include/boost/range/distance.hpp | 2 +- include/boost/range/empty.hpp | 2 +- include/boost/range/end.hpp | 2 +- include/boost/range/functions.hpp | 2 +- include/boost/range/iterator.hpp | 2 +- include/boost/range/metafunctions.hpp | 2 +- include/boost/range/mutable_iterator.hpp | 2 +- include/boost/range/numeric.hpp | 2 +- include/boost/range/pointer.hpp | 2 +- include/boost/range/rbegin.hpp | 2 +- include/boost/range/reference.hpp | 2 +- include/boost/range/rend.hpp | 2 +- include/boost/range/result_iterator.hpp | 2 +- include/boost/range/reverse_iterator.hpp | 2 +- include/boost/range/reverse_result_iterator.hpp | 2 +- include/boost/range/size.hpp | 2 +- include/boost/range/size_type.hpp | 2 +- include/boost/range/value_type.hpp | 2 +- 32 files changed, 32 insertions(+), 32 deletions(-) mode change 100755 => 100644 include/boost/range/algorithm.hpp mode change 100755 => 100644 include/boost/range/as_array.hpp mode change 100755 => 100644 include/boost/range/category.hpp mode change 100755 => 100644 include/boost/range/const_reverse_iterator.hpp mode change 100755 => 100644 include/boost/range/detail/common.hpp mode change 100755 => 100644 include/boost/range/detail/sizer.hpp mode change 100755 => 100644 include/boost/range/difference_type.hpp mode change 100755 => 100644 include/boost/range/distance.hpp mode change 100755 => 100644 include/boost/range/functions.hpp mode change 100755 => 100644 include/boost/range/iterator.hpp mode change 100755 => 100644 include/boost/range/pointer.hpp mode change 100755 => 100644 include/boost/range/rbegin.hpp mode change 100755 => 100644 include/boost/range/reference.hpp mode change 100755 => 100644 include/boost/range/rend.hpp mode change 100755 => 100644 include/boost/range/result_iterator.hpp mode change 100755 => 100644 include/boost/range/reverse_iterator.hpp mode change 100755 => 100644 include/boost/range/reverse_result_iterator.hpp mode change 100755 => 100644 include/boost/range/value_type.hpp diff --git a/include/boost/range.hpp b/include/boost/range.hpp index 2aeb393..179ae22 100644 --- a/include/boost/range.hpp +++ b/include/boost/range.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_HPP_27_07_04 #define BOOST_RANGE_HPP_27_07_04 -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/algorithm.hpp b/include/boost/range/algorithm.hpp old mode 100755 new mode 100644 index b7d8dd7..30dc583 --- a/include/boost/range/algorithm.hpp +++ b/include/boost/range/algorithm.hpp @@ -19,7 +19,7 @@ // were originally written by Vladimir Prus' // code from Boost Wiki -#if defined(_MSC_VER) && _MSC_VER >= 1000 +#if defined(_MSC_VER) #pragma once #endif diff --git a/include/boost/range/as_array.hpp b/include/boost/range/as_array.hpp old mode 100755 new mode 100644 index 0723e60..69a1580 --- a/include/boost/range/as_array.hpp +++ b/include/boost/range/as_array.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_AS_ARRAY_HPP #define BOOST_RANGE_AS_ARRAY_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/as_literal.hpp b/include/boost/range/as_literal.hpp index 9ea144d..1c16e4a 100644 --- a/include/boost/range/as_literal.hpp +++ b/include/boost/range/as_literal.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_AS_LITERAL_HPP #define BOOST_RANGE_AS_LITERAL_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/begin.hpp b/include/boost/range/begin.hpp index c668488..980857f 100644 --- a/include/boost/range/begin.hpp +++ b/include/boost/range/begin.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_BEGIN_HPP #define BOOST_RANGE_BEGIN_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/category.hpp b/include/boost/range/category.hpp old mode 100755 new mode 100644 index 1574605..f5431ad --- a/include/boost/range/category.hpp +++ b/include/boost/range/category.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_CATEGORY_HPP #define BOOST_RANGE_CATEGORY_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/config.hpp b/include/boost/range/config.hpp index fc2693e..7600a5f 100644 --- a/include/boost/range/config.hpp +++ b/include/boost/range/config.hpp @@ -13,7 +13,7 @@ #include -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/const_iterator.hpp b/include/boost/range/const_iterator.hpp index 875320f..6b49ea0 100644 --- a/include/boost/range/const_iterator.hpp +++ b/include/boost/range/const_iterator.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_CONST_ITERATOR_HPP #define BOOST_RANGE_CONST_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/const_reverse_iterator.hpp b/include/boost/range/const_reverse_iterator.hpp old mode 100755 new mode 100644 index 215bcc7..a1f49b7 --- a/include/boost/range/const_reverse_iterator.hpp +++ b/include/boost/range/const_reverse_iterator.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP #define BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/detail/as_literal.hpp b/include/boost/range/detail/as_literal.hpp index 0bd9a15..8b219ea 100644 --- a/include/boost/range/detail/as_literal.hpp +++ b/include/boost/range/detail/as_literal.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP #define BOOST_RANGE_DETAIL_AS_LITERAL_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/detail/common.hpp b/include/boost/range/detail/common.hpp old mode 100755 new mode 100644 index f7539f5..b0ad535 --- a/include/boost/range/detail/common.hpp +++ b/include/boost/range/detail/common.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_DETAIL_COMMON_HPP #define BOOST_RANGE_DETAIL_COMMON_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/detail/extract_optional_type.hpp b/include/boost/range/detail/extract_optional_type.hpp index 4a7f71a..aa4dd80 100644 --- a/include/boost/range/detail/extract_optional_type.hpp +++ b/include/boost/range/detail/extract_optional_type.hpp @@ -10,7 +10,7 @@ #ifndef BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED #define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/detail/sizer.hpp b/include/boost/range/detail/sizer.hpp old mode 100755 new mode 100644 index b4c1c91..cd6679c --- a/include/boost/range/detail/sizer.hpp +++ b/include/boost/range/detail/sizer.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_DETAIL_SIZER_HPP #define BOOST_RANGE_DETAIL_SIZER_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/difference_type.hpp b/include/boost/range/difference_type.hpp old mode 100755 new mode 100644 index 164288f..4578002 --- a/include/boost/range/difference_type.hpp +++ b/include/boost/range/difference_type.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_DIFFERENCE_TYPE_HPP #define BOOST_RANGE_DIFFERENCE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/distance.hpp b/include/boost/range/distance.hpp old mode 100755 new mode 100644 index 42a106d..075f2d1 --- a/include/boost/range/distance.hpp +++ b/include/boost/range/distance.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_DISTANCE_HPP #define BOOST_RANGE_DISTANCE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/empty.hpp b/include/boost/range/empty.hpp index 36e58d7..d57a30e 100644 --- a/include/boost/range/empty.hpp +++ b/include/boost/range/empty.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_EMPTY_HPP #define BOOST_RANGE_EMPTY_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/end.hpp b/include/boost/range/end.hpp index d5e6526..b3fc709 100644 --- a/include/boost/range/end.hpp +++ b/include/boost/range/end.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_END_HPP #define BOOST_RANGE_END_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/functions.hpp b/include/boost/range/functions.hpp old mode 100755 new mode 100644 index b8b8608..43c54b1 --- a/include/boost/range/functions.hpp +++ b/include/boost/range/functions.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_FUNCTIONS_HPP #define BOOST_RANGE_FUNCTIONS_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/iterator.hpp b/include/boost/range/iterator.hpp old mode 100755 new mode 100644 index 21798c5..40c4914 --- a/include/boost/range/iterator.hpp +++ b/include/boost/range/iterator.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_ITERATOR_HPP #define BOOST_RANGE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/metafunctions.hpp b/include/boost/range/metafunctions.hpp index 469d9ae..9dc59d0 100644 --- a/include/boost/range/metafunctions.hpp +++ b/include/boost/range/metafunctions.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_METAFUNCTIONS_HPP #define BOOST_RANGE_METAFUNCTIONS_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/mutable_iterator.hpp b/include/boost/range/mutable_iterator.hpp index 7beca66..ffa2e66 100644 --- a/include/boost/range/mutable_iterator.hpp +++ b/include/boost/range/mutable_iterator.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP #define BOOST_RANGE_MUTABLE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/numeric.hpp b/include/boost/range/numeric.hpp index bfd1049..c70069f 100644 --- a/include/boost/range/numeric.hpp +++ b/include/boost/range/numeric.hpp @@ -19,7 +19,7 @@ // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#if defined(_MSC_VER) && _MSC_VER >= 1000 +#if defined(_MSC_VER) #pragma once #endif diff --git a/include/boost/range/pointer.hpp b/include/boost/range/pointer.hpp old mode 100755 new mode 100644 index e7431ff..c3ed503 --- a/include/boost/range/pointer.hpp +++ b/include/boost/range/pointer.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_POINTER_TYPE_HPP #define BOOST_RANGE_POINTER_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/rbegin.hpp b/include/boost/range/rbegin.hpp old mode 100755 new mode 100644 index 78e5f61..6d66de9 --- a/include/boost/range/rbegin.hpp +++ b/include/boost/range/rbegin.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_RBEGIN_HPP #define BOOST_RANGE_RBEGIN_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/reference.hpp b/include/boost/range/reference.hpp old mode 100755 new mode 100644 index d308e43..c664c38 --- a/include/boost/range/reference.hpp +++ b/include/boost/range/reference.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_REFERENCE_TYPE_HPP #define BOOST_RANGE_REFERENCE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/rend.hpp b/include/boost/range/rend.hpp old mode 100755 new mode 100644 index fd79aa2..ef70407 --- a/include/boost/range/rend.hpp +++ b/include/boost/range/rend.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_REND_HPP #define BOOST_RANGE_REND_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/result_iterator.hpp b/include/boost/range/result_iterator.hpp old mode 100755 new mode 100644 index ba09c5f..54e343d --- a/include/boost/range/result_iterator.hpp +++ b/include/boost/range/result_iterator.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_RESULT_ITERATOR_HPP #define BOOST_RANGE_RESULT_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/reverse_iterator.hpp b/include/boost/range/reverse_iterator.hpp old mode 100755 new mode 100644 index f8e9221..2569b17 --- a/include/boost/range/reverse_iterator.hpp +++ b/include/boost/range/reverse_iterator.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP #define BOOST_RANGE_REVERSE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/reverse_result_iterator.hpp b/include/boost/range/reverse_result_iterator.hpp old mode 100755 new mode 100644 index 62bf135..d375cfd --- a/include/boost/range/reverse_result_iterator.hpp +++ b/include/boost/range/reverse_result_iterator.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_REVERSE_RESULT_ITERATOR_HPP #define BOOST_RANGE_REVERSE_RESULT_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/size.hpp b/include/boost/range/size.hpp index 6ae74d1..9b63aff 100644 --- a/include/boost/range/size.hpp +++ b/include/boost/range/size.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_SIZE_HPP #define BOOST_RANGE_SIZE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/size_type.hpp b/include/boost/range/size_type.hpp index cc99ef3..1be647d 100644 --- a/include/boost/range/size_type.hpp +++ b/include/boost/range/size_type.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_SIZE_TYPE_HPP #define BOOST_RANGE_SIZE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/include/boost/range/value_type.hpp b/include/boost/range/value_type.hpp old mode 100755 new mode 100644 index 95c7580..4a67d05 --- a/include/boost/range/value_type.hpp +++ b/include/boost/range/value_type.hpp @@ -11,7 +11,7 @@ #ifndef BOOST_RANGE_VALUE_TYPE_HPP #define BOOST_RANGE_VALUE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif From 1e6ba3c885f1bee969b8d254250996b676112f95 Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Tue, 1 Oct 2013 08:41:42 +0000 Subject: [PATCH 15/60] Range: Remove obsolete GCC version checks. [SVN r86102] --- include/boost/range/begin.hpp | 16 ++++------------ include/boost/range/end.hpp | 16 ++++------------ 2 files changed, 8 insertions(+), 24 deletions(-) diff --git a/include/boost/range/begin.hpp b/include/boost/range/begin.hpp index 980857f..ba5a73b 100644 --- a/include/boost/range/begin.hpp +++ b/include/boost/range/begin.hpp @@ -26,9 +26,7 @@ namespace boost { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) namespace range_detail { #endif @@ -85,9 +83,7 @@ namespace range_detail } -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) } // namespace 'range_detail' #endif @@ -100,9 +96,7 @@ namespace range_adl_barrier template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_begin( r ); @@ -111,9 +105,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( T& r ) template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( const T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_begin( r ); diff --git a/include/boost/range/end.hpp b/include/boost/range/end.hpp index b3fc709..f2a3337 100644 --- a/include/boost/range/end.hpp +++ b/include/boost/range/end.hpp @@ -28,9 +28,7 @@ namespace boost { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) namespace range_detail { #endif @@ -82,9 +80,7 @@ namespace range_detail return range_detail::array_end( a ); } -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) } // namespace 'range_detail' #endif @@ -94,9 +90,7 @@ namespace range_adl_barrier template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator::type end( T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_end( r ); @@ -105,9 +99,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator::type end( T& r ) template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator::type end( const T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_end( r ); From c55650216f4f512309062a2f96bf01b3ca409078 Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Fri, 11 Oct 2013 23:11:35 +0000 Subject: [PATCH 16/60] Remove obsolete files. [SVN r86242] --- include/boost/range/const_iterator.hpp | 4 - include/boost/range/detail/const_iterator.hpp | 71 --------- include/boost/range/detail/iterator.hpp | 78 ---------- include/boost/range/detail/size.hpp | 144 ------------------ include/boost/range/mutable_iterator.hpp | 4 - 5 files changed, 301 deletions(-) delete mode 100755 include/boost/range/detail/const_iterator.hpp delete mode 100755 include/boost/range/detail/iterator.hpp delete mode 100644 include/boost/range/detail/size.hpp diff --git a/include/boost/range/const_iterator.hpp b/include/boost/range/const_iterator.hpp index 6b49ea0..5512939 100644 --- a/include/boost/range/const_iterator.hpp +++ b/include/boost/range/const_iterator.hpp @@ -17,9 +17,6 @@ #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include -#else #include #include @@ -62,6 +59,5 @@ namespace boost } // namespace boost -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif diff --git a/include/boost/range/detail/const_iterator.hpp b/include/boost/range/detail/const_iterator.hpp deleted file mode 100755 index e5cb34a..0000000 --- a/include/boost/range/detail/const_iterator.hpp +++ /dev/null @@ -1,71 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 2003-2004. Use, modification and -// distribution is subject to the Boost Software License, Version -// 1.0. (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// For more information, see http://www.boost.org/libs/range/ -// - -#ifndef BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP -#define BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP - -#include -#include - -////////////////////////////////////////////////////////////////////////////// -// missing partial specialization workaround. -////////////////////////////////////////////////////////////////////////////// - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_const_iterator_; - - template<> - struct range_const_iterator_ - { - template< typename C > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type; - }; - }; - - template<> - struct range_const_iterator_ - { - template< typename P > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type; - }; - }; - - - template<> - struct range_const_iterator_ - { - template< typename T > - struct pts - { - typedef const BOOST_RANGE_DEDUCED_TYPENAME - remove_extent::type* type; - }; - }; - } - - template< typename C > - class range_const_iterator - { - typedef BOOST_DEDUCED_TYPENAME range_detail::range::type c_type; - public: - typedef BOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_::BOOST_NESTED_TEMPLATE pts::type type; - }; - -} - -#endif diff --git a/include/boost/range/detail/iterator.hpp b/include/boost/range/detail/iterator.hpp deleted file mode 100755 index 58346d4..0000000 --- a/include/boost/range/detail/iterator.hpp +++ /dev/null @@ -1,78 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 2003-2004. Use, modification and -// distribution is subject to the Boost Software License, Version -// 1.0. (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// For more information, see http://www.boost.org/libs/range/ -// - -#ifndef BOOST_RANGE_DETAIL_ITERATOR_HPP -#define BOOST_RANGE_DETAIL_ITERATOR_HPP - -#include -#include - -#include - -////////////////////////////////////////////////////////////////////////////// -// missing partial specialization workaround. -////////////////////////////////////////////////////////////////////////////// - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_iterator_ { - template< typename C > - struct pts - { - typedef int type; - }; - }; - - template<> - struct range_iterator_ - { - template< typename C > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME C::iterator type; - }; - }; - - template<> - struct range_iterator_ - { - template< typename P > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type; - }; - }; - - template<> - struct range_iterator_ - { - template< typename T > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME - remove_extent::type* type; - }; - }; - - } - - template< typename C > - class range_mutable_iterator - { - typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range::type c_type; - public: - typedef typename range_detail::range_iterator_::BOOST_NESTED_TEMPLATE pts::type type; - }; -} - -#endif diff --git a/include/boost/range/detail/size.hpp b/include/boost/range/detail/size.hpp deleted file mode 100644 index eec134c..0000000 --- a/include/boost/range/detail/size.hpp +++ /dev/null @@ -1,144 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 2003-2004. Use, modification and -// distribution is subject to the Boost Software License, Version -// 1.0. (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// For more information, see http://www.boost.org/libs/range/ -// - - -#ifndef BOOST_RANGE_DETAIL_SIZE_HPP -#define BOOST_RANGE_DETAIL_SIZE_HPP - -#include // BOOST_MSVC -#include -#include -#include -#include -#include - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_size_; - - ////////////////////////////////////////////////////////////////////// - // default - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - template< typename C > - static BOOST_RANGE_DEDUCED_TYPENAME C::size_type fun( const C& c ) - { - return c.size(); - }; - }; - - ////////////////////////////////////////////////////////////////////// - // pair - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - template< typename P > - static BOOST_RANGE_DEDUCED_TYPENAME range_size

::type - fun( const P& p ) - { - return std::distance( p.first, p.second ); - } - }; - - ////////////////////////////////////////////////////////////////////// - // array - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - template - static std::size_t fun(T& t) - { - return remove_extent::size; - } - }; - - template<> - struct range_size_ - { - template< typename T, std::size_t sz > - static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] ) - { - return boost::range_detail::array_size( boost_range_array ); - } - }; - - template<> - struct range_size_ - { - template< typename T, std::size_t sz > - static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] ) - { - return boost::range_detail::array_size( boost_range_array ); - } - }; - - ////////////////////////////////////////////////////////////////////// - // string - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_size_ - { - static std::size_t fun( const char* s ) - { - return boost::range_detail::str_size( s ); - } - }; - - template<> - struct range_size_ - { - static std::size_t fun( const char* s ) - { - return boost::range_detail::str_size( s ); - } - }; - - template<> - struct range_size_ - { - static std::size_t fun( const wchar_t* s ) - { - return boost::range_detail::str_size( s ); - } - }; - - template<> - struct range_size_ - { - static std::size_t fun( const wchar_t* s ) - { - return boost::range_detail::str_size( s ); - } - }; - - } // namespace 'range_detail' - - - template< typename C > - BOOST_RANGE_DEDUCED_TYPENAME range_size::type - size( const C& c ) - { - return range_detail::range_size_< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range::type >::fun( c ); - } - -} // namespace 'boost' - -#endif diff --git a/include/boost/range/mutable_iterator.hpp b/include/boost/range/mutable_iterator.hpp index ffa2e66..f1bd1a1 100644 --- a/include/boost/range/mutable_iterator.hpp +++ b/include/boost/range/mutable_iterator.hpp @@ -17,9 +17,6 @@ #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include -#else #include #include @@ -62,6 +59,5 @@ namespace boost } // namespace boost -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif From b02c60e4682379bff0f7d8c01141f78c072fec7e Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Fri, 11 Oct 2013 23:17:48 +0000 Subject: [PATCH 17/60] Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifndef...#else...#endif blocks. [SVN r86245] --- .../range/detail/collection_traits_detail.hpp | 120 ------------------ 1 file changed, 120 deletions(-) diff --git a/include/boost/range/detail/collection_traits_detail.hpp b/include/boost/range/detail/collection_traits_detail.hpp index 93652b5..1f2b77c 100644 --- a/include/boost/range/detail/collection_traits_detail.hpp +++ b/include/boost/range/detail/collection_traits_detail.hpp @@ -185,7 +185,6 @@ namespace boost { // Array container traits --------------------------------------------------------------- -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // array traits ( partial specialization ) template< typename T > struct array_traits; @@ -204,125 +203,6 @@ namespace boost { BOOST_STATIC_CONSTANT( size_type, array_size = sz ); }; -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // array traits ( no partial specialization ) - /* - without partial specialization we are able to - provide support only for a limited number of - types. Currently the primitive numeric types - are supported - */ - template< typename T, typename BaseT > - struct array_traits_impl - { - typedef BaseT value_type; - typedef BaseT* iterator; - typedef const BaseT* const_iterator; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - - // size of the array - BOOST_STATIC_CONSTANT( size_type, array_size = sizeof(T)/sizeof(BaseT) ); - }; - - template< typename T, typename BaseT > - struct array_traits_impl_selector - { - typedef array_traits_impl type; - }; - - struct array_traits_void - { - typedef void type; - }; - - template< typename T, typename BaseT > - struct array_traits_cv_selector - { - typedef BOOST_STRING_TYPENAME - ::boost::mpl::eval_if< - ::boost::is_convertible, - array_traits_impl_selector, - ::boost::mpl::eval_if< - ::boost::is_convertible, - array_traits_impl_selector, - ::boost::mpl::eval_if< - ::boost::is_convertible, - array_traits_impl_selector, - array_traits_impl_selector - > - > - >::type type; - }; - - template< typename T > - struct array_traits_select - { - template< typename T1, typename T2 > - struct apply - { - typedef BOOST_STRING_TYPENAME - ::boost::mpl::eval_if< - ::boost::is_convertible, - array_traits_cv_selector, - ::boost::mpl::identity >::type type; - }; - }; - - template< typename T > - struct array_traits_selector - { - private: - // supported array base types -#ifndef BOOST_NO_INTRINSIC_WCHAR_T - typedef BOOST_STRING_TYPENAME - ::boost::mpl::vector10< - wchar_t, -#else // BOOST_NO_INTRINSIC_WCHAR_T - typedef BOOST_STRING_TYPENAME - ::boost::mpl::vector9< -#endif // BOOST_NO_INTRINSIC_WCHAR_T - char, - signed char, - unsigned char, - signed short, - unsigned short, - signed int, - unsigned int, - signed long, - unsigned long - >::type array_base_types; - - public: - typedef BOOST_STRING_TYPENAME - ::boost::mpl::fold< - array_base_types, - ::boost::algorithm::detail::array_traits_void, - ::boost::algorithm::detail::array_traits_select >::type type; - }; - - template< typename T > - struct array_traits - { - typedef BOOST_STRING_TYPENAME - array_traits_selector::type traits_type; - - typedef BOOST_STRING_TYPENAME - traits_type::value_type value_type; - typedef BOOST_STRING_TYPENAME - traits_type::iterator iterator; - typedef BOOST_STRING_TYPENAME - traits_type::const_iterator const_iterator; - typedef BOOST_STRING_TYPENAME - traits_type::size_type size_type; - typedef BOOST_STRING_TYPENAME - traits_type::difference_type difference_type; - - BOOST_STATIC_CONSTANT( size_type, array_size = traits_type::array_size ); - }; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // array length resolving /* From 5366172708f8604bcfaaf39eef531701a582642e Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Fri, 11 Oct 2013 23:19:17 +0000 Subject: [PATCH 18/60] Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifdef...#else...#endif blocks. [SVN r86246] --- include/boost/range/size_type.hpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/include/boost/range/size_type.hpp b/include/boost/range/size_type.hpp index 1be647d..ffdc3ac 100644 --- a/include/boost/range/size_type.hpp +++ b/include/boost/range/size_type.hpp @@ -18,9 +18,6 @@ #include #include #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include -#else #include #include @@ -96,7 +93,6 @@ namespace boost } // namespace boost -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif From e7185c29669adb6f74bdc7532ddcc7abf65b3ac5 Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Fri, 11 Oct 2013 23:22:36 +0000 Subject: [PATCH 19/60] Remove remaining occurances of BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION These evaded scripting. [SVN r86249] --- include/boost/range/iterator.hpp | 2 -- include/boost/range/value_type.hpp | 4 ---- 2 files changed, 6 deletions(-) diff --git a/include/boost/range/iterator.hpp b/include/boost/range/iterator.hpp index 40c4914..2966bdf 100644 --- a/include/boost/range/iterator.hpp +++ b/include/boost/range/iterator.hpp @@ -67,6 +67,4 @@ namespace boost } // namespace boost -//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - #endif diff --git a/include/boost/range/value_type.hpp b/include/boost/range/value_type.hpp index 4a67d05..5a3187e 100644 --- a/include/boost/range/value_type.hpp +++ b/include/boost/range/value_type.hpp @@ -18,10 +18,6 @@ #include #include -//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -//#include -//#else - #include namespace boost From 2735dcff1881a9f67c454d059c74e8a05abfa7a2 Mon Sep 17 00:00:00 2001 From: Michel Morin Date: Wed, 30 Oct 2013 12:51:24 +0000 Subject: [PATCH 20/60] Correct broken links to C++ standard papers. Refs #9212. [SVN r86524] --- doc/boost_range.qbk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/boost_range.qbk b/doc/boost_range.qbk index be09bc6..126ec62 100644 --- a/doc/boost_range.qbk +++ b/doc/boost_range.qbk @@ -171,7 +171,7 @@ [def __metafunctions__ [@boost:/libs/mpl/doc/refmanual/metafunction.html metafunctions]] [def __concept_check__ [@boost:/libs/concept_check/index.html Boost Concept Check library]] [def __boost_array__ [@boost:/libs/array/index.html boost::array]] -[def __the_forwarding_problem__ [@http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]] +[def __the_forwarding_problem__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]] [def __sgi_inner_product__ [@http://www.sgi.com/tech/stl/inner_product.html inner_product]] [def __sgi_partial_sum__ [@http://www.sgi.com/tech/stl/partial_sum.html partial_sum]] From b795de83108d094dc389dc5d6127b8751882c6bb Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Fri, 21 Feb 2014 17:44:16 +0000 Subject: [PATCH 21/60] extension_size.cpp include added to cstdint.hpp --- test/extension_size.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/test/extension_size.cpp b/test/extension_size.cpp index 202f465..b9cc1b2 100644 --- a/test/extension_size.cpp +++ b/test/extension_size.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include #include From 96054b0b48a2ad8f5eb27a402b7566032213713e Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Fri, 21 Feb 2014 17:50:28 +0000 Subject: [PATCH 22/60] unit test type_erased.cpp corrected mix of value types under test. --- test/adaptor_test/type_erased.cpp | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index fd3ee5f..60e6e39 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include @@ -30,12 +31,12 @@ namespace boost_range_adaptor_type_erased_test { } - MockType(int x) + MockType(boost::int32_t x) : m_x(x) { } - int get() const { return m_x; } + boost::int32_t get() const { return m_x; } inline bool operator==(const MockType& other) const { @@ -48,7 +49,15 @@ namespace boost_range_adaptor_type_erased_test } private: - int m_x; + boost::int32_t m_x; + }; + + class MockType2 : public MockType + { + public: + MockType2() {} + MockType2(boost::int32_t x) : MockType(x) { } + MockType2(const MockType& other) : MockType(other) { } }; inline std::ostream& operator<<(std::ostream& out, const MockType& obj) @@ -418,15 +427,12 @@ namespace boost_range_adaptor_type_erased_test template void test_type_erased_mix_values_driver() { - test_type_erased_mix_values_impl< Traversal, int, char, const int&, short, const int& >(); - test_type_erased_mix_values_impl< Traversal, int, int*, const int&, char, const int& >(); - test_type_erased_mix_values_impl< Traversal, MockType, char, const MockType&, short, const MockType& >(); - - // In fact value type should have no effect in the eligibility - // for conversion, hence we should be able to convert it - // completely backwards! - test_type_erased_mix_values_impl< Traversal, int, short, const int&, char, const int& >(); - test_type_erased_mix_values_impl< Traversal, int, char, const int&, int*, const int& >(); + test_type_erased_mix_values_impl< + Traversal, + MockType, + MockType2, const MockType&, + MockType, const MockType& + >(); } void test_type_erased_mix_values() From 7cd6631cae891cb42aba3b33e17398e34eef717a Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Fri, 21 Feb 2014 17:52:32 +0000 Subject: [PATCH 23/60] strided.cpp unit test has the deque test removed. --- test/adaptor_test/strided.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/adaptor_test/strided.cpp b/test/adaptor_test/strided.cpp index 290cd4b..ad9e9e4 100644 --- a/test/adaptor_test/strided.cpp +++ b/test/adaptor_test/strided.cpp @@ -11,6 +11,9 @@ // The strided_defect_Trac5014 test case is a modified version of a test case // contributed by Michel Morin as part of the trac ticket. // +// The deque test case has been removed due to erroneous standard library +// implementations causing test failures. +// #include #include @@ -21,7 +24,6 @@ #include #include -#include #include namespace boost @@ -160,7 +162,6 @@ namespace boost void strided_test() { strided_test_impl< std::vector >(); - strided_test_impl< std::deque >(); strided_test_impl< std::list >(); } From 8e7eeeb6d9e3d259b6f7c78062d502ba88c23f7f Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sat, 22 Feb 2014 16:14:55 +0000 Subject: [PATCH 24/60] ticket 5811 - unit test to confirm already fixed. --- test/Jamfile.v2 | 1 + test/ticket_5811_indirected_optional.cpp | 47 ++++++++++++++++++++++++ 2 files changed, 48 insertions(+) create mode 100644 test/ticket_5811_indirected_optional.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index bcaa772..1df869d 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -161,6 +161,7 @@ test-suite range : [ range-test ticket_5544_terminate_irange ] [ range-test ticket_5547 ] [ range-test ticket_5556_is_sorted_namespace ] + [ range-test ticket_5811_indirected_optional ] [ range-test ticket_6944 ] ; diff --git a/test/ticket_5811_indirected_optional.cpp b/test/ticket_5811_indirected_optional.cpp new file mode 100644 index 0000000..8b4033b --- /dev/null +++ b/test/ticket_5811_indirected_optional.cpp @@ -0,0 +1,47 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// +// For more information, see http://www.boost.org/libs/range/ +// +#include +#include + +#include +#include + +#include + +namespace boost +{ + namespace + { + void test_ticket_5811_indirected_optional() + { + std::vector > v; + std::vector r; + for (int i = 0; i < 10; ++i) + { + v.push_back(i); + r.push_back(i); + } + BOOST_CHECK_EQUAL_COLLECTIONS(r.begin(), r.end(), + v.begin(), v.end()); + } + } +} + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test + = BOOST_TEST_SUITE("RangeTestSuite.ticket_5811_indirected_optional"); + + test->add(BOOST_TEST_CASE(&boost::test_ticket_5811_indirected_optional)); + + return test; +} From 1d91272a551df2cd1776d6447c0e39a14f660c17 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sat, 22 Feb 2014 22:31:48 +0000 Subject: [PATCH 25/60] trac 6715 - iterator_range operators work automatically in derived. --- include/boost/range/iterator_range_core.hpp | 286 +++++++++---------- test/Jamfile.v2 | 1 + test/ticket_6715_iterator_range_equality.cpp | 44 +++ 3 files changed, 175 insertions(+), 156 deletions(-) create mode 100644 test/ticket_6715_iterator_range_equality.cpp diff --git a/include/boost/range/iterator_range_core.hpp b/include/boost/range/iterator_range_core.hpp index f985641..967a457 100644 --- a/include/boost/range/iterator_range_core.hpp +++ b/include/boost/range/iterator_range_core.hpp @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -77,7 +78,7 @@ namespace boost template< class Left, class Right > inline bool greater_than( const Left& l, const Right& r ) { - return less_than(r,l); + return iterator_range_detail::less_than(r,l); } template< class Left, class Right > @@ -102,6 +103,8 @@ namespace boost struct range_tag { }; struct const_range_tag { }; + + struct iterator_range_tag { }; } // iterator range template class -----------------------------------------// @@ -125,6 +128,7 @@ namespace boost */ template class iterator_range + : public iterator_range_detail::iterator_range_tag { typedef range_detail::safe_bool< IteratorT iterator_range::* > safe_bool_t; protected: // Used by sub_range @@ -268,46 +272,11 @@ namespace boost return empty(); } - bool equal( const iterator_range& r ) const + bool equal(const iterator_range& r) const { return m_Begin == r.m_Begin && m_End == r.m_End; } - -#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - bool operator==( const iterator_range& r ) const - { - return boost::equal( *this, r ); - } - - bool operator!=( const iterator_range& r ) const - { - return !operator==(r); - } - - bool operator<( const iterator_range& r ) const - { - return iterator_range_detail::less_than( *this, r ); - } - - bool operator>( const iterator_range& r ) const - { - return iterator_range_detail::greater_than( *this, r ); - } - - bool operator<=( const iterator_range& r ) const - { - return iterator_range_detail::less_or_equal_than( *this, r ); - } - - bool operator>=( const iterator_range& r ) const - { - return iterator_range_detail::greater_or_equal_than( *this, r ); - } - -#endif - public: // convenience reference front() const { @@ -383,138 +352,143 @@ namespace boost ///////////////////////////////////////////////////////////////////// // comparison operators ///////////////////////////////////////////////////////////////////// - - template< class IteratorT, class ForwardRange > - inline bool operator==( const ForwardRange& l, - const iterator_range& r ) + template + inline BOOST_DEDUCED_TYPENAME enable_if< + mpl::or_< + is_convertible< + const SinglePassRange1&, + const iterator_range_detail::iterator_range_tag& + >, + is_convertible< + const SinglePassRange2&, + const iterator_range_detail::iterator_range_tag& + > + >, + bool + >::type + operator==(const SinglePassRange1& l, const SinglePassRange2& r) { - return boost::equal( l, r ); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + return boost::equal(l, r); + } + + template + inline BOOST_DEDUCED_TYPENAME enable_if< + mpl::or_< + is_convertible< + const SinglePassRange1&, + const iterator_range_detail::iterator_range_tag& + >, + is_convertible< + const SinglePassRange2&, + const iterator_range_detail::iterator_range_tag& + > + >, + bool + >::type + operator!=(const SinglePassRange1& l, const SinglePassRange2& r) + { + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + return !boost::equal(l, r); } - template< class IteratorT, class ForwardRange > - inline bool operator!=( const ForwardRange& l, - const iterator_range& r ) + template + inline BOOST_DEDUCED_TYPENAME enable_if< + mpl::or_< + is_convertible< + const SinglePassRange1&, + const iterator_range_detail::iterator_range_tag& + >, + is_convertible< + const SinglePassRange2&, + const iterator_range_detail::iterator_range_tag& + > + >, + bool + >::type + operator<(const SinglePassRange1& l, const SinglePassRange2& r) { - return !boost::equal( l, r ); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + return iterator_range_detail::less_than(l, r); } - - template< class IteratorT, class ForwardRange > - inline bool operator<( const ForwardRange& l, - const iterator_range& r ) + + template + inline BOOST_DEDUCED_TYPENAME enable_if< + mpl::or_< + is_convertible< + const SinglePassRange1&, + const iterator_range_detail::iterator_range_tag& + >, + is_convertible< + const SinglePassRange2&, + const iterator_range_detail::iterator_range_tag& + > + >, + bool + >::type + operator<=(const SinglePassRange1& l, const SinglePassRange2& r) { - return iterator_range_detail::less_than( l, r ); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + return iterator_range_detail::less_or_equal_than(l, r); } - template< class IteratorT, class ForwardRange > - inline bool operator<=( const ForwardRange& l, - const iterator_range& r ) + template + inline BOOST_DEDUCED_TYPENAME enable_if< + mpl::or_< + is_convertible< + const SinglePassRange1&, + const iterator_range_detail::iterator_range_tag& + >, + is_convertible< + const SinglePassRange2&, + const iterator_range_detail::iterator_range_tag& + > + >, + bool + >::type + operator>(const SinglePassRange1& l, const SinglePassRange2& r) { - return iterator_range_detail::less_or_equal_than( l, r ); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + return iterator_range_detail::greater_than(l, r); } - template< class IteratorT, class ForwardRange > - inline bool operator>( const ForwardRange& l, - const iterator_range& r ) + template + inline BOOST_DEDUCED_TYPENAME enable_if< + mpl::or_< + is_convertible< + const SinglePassRange1&, + const iterator_range_detail::iterator_range_tag& + >, + is_convertible< + const SinglePassRange2&, + const iterator_range_detail::iterator_range_tag& + > + >, + bool + >::type + operator>=(const SinglePassRange1& l, const SinglePassRange2& r) { - return iterator_range_detail::greater_than( l, r ); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT(( + boost::SinglePassRangeConcept)); + return iterator_range_detail::greater_or_equal_than(l, r); } - - template< class IteratorT, class ForwardRange > - inline bool operator>=( const ForwardRange& l, - const iterator_range& r ) - { - return iterator_range_detail::greater_or_equal_than( l, r ); - } - -#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING -#else - template< class Iterator1T, class Iterator2T > - inline bool operator==( const iterator_range& l, - const iterator_range& r ) - { - return boost::equal( l, r ); - } - - template< class IteratorT, class ForwardRange > - inline bool operator==( const iterator_range& l, - const ForwardRange& r ) - { - return boost::equal( l, r ); - } - - - template< class Iterator1T, class Iterator2T > - inline bool operator!=( const iterator_range& l, - const iterator_range& r ) - { - return !boost::equal( l, r ); - } - - template< class IteratorT, class ForwardRange > - inline bool operator!=( const iterator_range& l, - const ForwardRange& r ) - { - return !boost::equal( l, r ); - } - - - template< class Iterator1T, class Iterator2T > - inline bool operator<( const iterator_range& l, - const iterator_range& r ) - { - return iterator_range_detail::less_than( l, r ); - } - - template< class IteratorT, class ForwardRange > - inline bool operator<( const iterator_range& l, - const ForwardRange& r ) - { - return iterator_range_detail::less_than( l, r ); - } - - template< class Iterator1T, class Iterator2T > - inline bool operator<=( const iterator_range& l, - const iterator_range& r ) - { - return iterator_range_detail::less_or_equal_than( l, r ); - } - - template< class IteratorT, class ForwardRange > - inline bool operator<=( const iterator_range& l, - const ForwardRange& r ) - { - return iterator_range_detail::less_or_equal_than( l, r ); - } - - template< class Iterator1T, class Iterator2T > - inline bool operator>( const iterator_range& l, - const iterator_range& r ) - { - return iterator_range_detail::greater_than( l, r ); - } - - template< class IteratorT, class ForwardRange > - inline bool operator>( const iterator_range& l, - const ForwardRange& r ) - { - return iterator_range_detail::greater_than( l, r ); - } - - template< class Iterator1T, class Iterator2T > - inline bool operator>=( const iterator_range& l, - const iterator_range& r ) - { - return iterator_range_detail::greater_or_equal_than( l, r ); - } - - template< class IteratorT, class ForwardRange > - inline bool operator>=( const iterator_range& l, - const ForwardRange& r ) - { - return iterator_range_detail::greater_or_equal_than( l, r ); - } - -#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING // iterator range utilities -----------------------------------------// diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 1df869d..0871332 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -162,6 +162,7 @@ test-suite range : [ range-test ticket_5547 ] [ range-test ticket_5556_is_sorted_namespace ] [ range-test ticket_5811_indirected_optional ] + [ range-test ticket_6715_iterator_range_equality ] [ range-test ticket_6944 ] ; diff --git a/test/ticket_6715_iterator_range_equality.cpp b/test/ticket_6715_iterator_range_equality.cpp new file mode 100644 index 0000000..0ca1d42 --- /dev/null +++ b/test/ticket_6715_iterator_range_equality.cpp @@ -0,0 +1,44 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// +// For more information, see http://www.boost.org/libs/range/ +// +#include + +#include +#include + +namespace boost +{ + namespace + { + class str_ref : public boost::iterator_range + { + }; + + void test_ticket_6715_iterator_range_equality() + { + str_ref a; + str_ref b; + BOOST_CHECK(a == b); + } + } +} + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test + = BOOST_TEST_SUITE( + "RangeTestSuite.ticket_6715_iterator_range_equality"); + + test->add(BOOST_TEST_CASE( + &boost::test_ticket_6715_iterator_range_equality)); + + return test; +} From 654ae838ee5228eec9006146cd1562c46d90f9d2 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 24 Feb 2014 18:26:03 +0000 Subject: [PATCH 26/60] refactored iterator_range to better handle SFINAE. --- include/boost/range/iterator_range_core.hpp | 499 ++++++++++++-------- test/adaptor_test/type_erased.cpp | 28 +- 2 files changed, 324 insertions(+), 203 deletions(-) diff --git a/include/boost/range/iterator_range_core.hpp b/include/boost/range/iterator_range_core.hpp index 967a457..1e671fc 100644 --- a/include/boost/range/iterator_range_core.hpp +++ b/include/boost/range/iterator_range_core.hpp @@ -26,6 +26,7 @@ #include #include #include +#include #include #include #include @@ -101,10 +102,251 @@ namespace boost return boost::equal(l, r); } - struct range_tag { }; - struct const_range_tag { }; - - struct iterator_range_tag { }; +struct range_tag +{ +}; + +struct const_range_tag +{ +}; + +struct iterator_range_tag +{ +}; + +template +class iterator_range_base + : public iterator_range_tag +{ + typedef range_detail::safe_bool< + IteratorT iterator_range_base::* + > safe_bool_t; + + typedef iterator_range_base type; + +protected: + typedef iterator_range_impl impl; + +public: + typedef BOOST_DEDUCED_TYPENAME + safe_bool_t::unspecified_bool_type unspecified_bool_type; + + typedef BOOST_DEDUCED_TYPENAME + iterator_value::type value_type; + + typedef BOOST_DEDUCED_TYPENAME + iterator_difference::type difference_type; + + typedef std::size_t size_type; // note: must be unsigned + + // Needed because value-type is the same for + // const and non-const iterators + typedef BOOST_DEDUCED_TYPENAME + iterator_reference::type reference; + + //! const_iterator type + /*! + There is no distinction between const_iterator and iterator. + These typedefs are provides to fulfill container interface + */ + typedef IteratorT const_iterator; + //! iterator type + typedef IteratorT iterator; + +protected: + iterator_range_base() + : m_Begin() + , m_End() + { + } + + template + iterator_range_base(Iterator Begin, Iterator End) + : m_Begin(Begin) + , m_End(End) + { + } + +public: + IteratorT begin() const + { + return m_Begin; + } + + IteratorT end() const + { + return m_End; + } + + bool empty() const + { + return m_Begin == m_End; + } + + operator unspecified_bool_type() const + { + return safe_bool_t::to_unspecified_bool( + m_Begin != m_End, &iterator_range_base::m_Begin); + } + + bool operator!() const + { + return empty(); + } + + bool equal(const iterator_range_base& r) const + { + return m_Begin == r.m_Begin && m_End == r.m_End; + } + + reference front() const + { + BOOST_ASSERT(!empty()); + return *m_Begin; + } + + void pop_front() + { + BOOST_ASSERT(!empty()); + ++m_Begin; + } + +protected: + template + void assign(Iterator first, Iterator last) + { + m_Begin = first; + m_End = last; + } + + template + void assign(const SinglePassRange& r) + { + m_Begin = impl::adl_begin(r); + m_End = impl::adl_end(r); + } + + template + void assign(SinglePassRange& r) + { + m_Begin = impl::adl_begin(r); + m_End = impl::adl_end(r); + } + + IteratorT m_Begin; + IteratorT m_End; +}; + +template +class iterator_range_base + : public iterator_range_base +{ + typedef iterator_range_base base_type; + +protected: + iterator_range_base() + { + } + + template + iterator_range_base(Iterator first, Iterator last) + : iterator_range_base(first, last) + { + } + +public: + BOOST_DEDUCED_TYPENAME base_type::reference back() const + { + BOOST_ASSERT(!this->empty()); + return *boost::prior(this->m_End); + } + + void pop_back() + { + BOOST_ASSERT(!this->empty()); + --this->m_End; + } +}; + +template +class iterator_range_base + : public iterator_range_base +{ + typedef iterator_range_base< + IteratorT, bidirectional_traversal_tag> base_type; + +public: + typedef BOOST_DEDUCED_TYPENAME + boost::mpl::if_< + boost::mpl::or_< + boost::is_abstract< + BOOST_DEDUCED_TYPENAME base_type::value_type + >, + boost::is_array< + BOOST_DEDUCED_TYPENAME base_type::value_type + > + >, + BOOST_DEDUCED_TYPENAME base_type::reference, + BOOST_DEDUCED_TYPENAME base_type::value_type + >::type abstract_value_type; + + // Rationale: + // typedef these here to reduce verbiage in the implementation of this + // type. + typedef BOOST_DEDUCED_TYPENAME base_type::difference_type difference_type; + typedef BOOST_DEDUCED_TYPENAME base_type::size_type size_type; + typedef BOOST_DEDUCED_TYPENAME base_type::reference reference; + +protected: + iterator_range_base() + { + } + + template + iterator_range_base(Iterator first, Iterator last) + : iterator_range_base( + first, last) + { + } + +public: + reference operator[](difference_type at) const + { + BOOST_ASSERT(at >= 0 && at < size()); + return this->m_Begin[at]; + } + + // + // When storing transform iterators, operator[]() + // fails because it returns by reference. Therefore + // operator()() is provided for these cases. + // + abstract_value_type operator()(difference_type at) const + { + BOOST_ASSERT(at >= 0 && at < size()); + return this->m_Begin[at]; + } + + void pop_front(difference_type n) + { + BOOST_ASSERT(n >= difference_type()); + BOOST_ASSERT(size() >= static_cast(n)); + std::advance(this->m_Begin, n); + } + + void pop_back(difference_type n) + { + BOOST_ASSERT(n >= difference_type()); + BOOST_ASSERT(size() >= static_cast(n)); + std::advance(this->m_End, -n); + } + + BOOST_DEDUCED_TYPENAME base_type::size_type size() const + { + return this->m_End - this->m_Begin; + } +}; + } // iterator range template class -----------------------------------------// @@ -128,217 +370,86 @@ namespace boost */ template class iterator_range - : public iterator_range_detail::iterator_range_tag + : public iterator_range_detail::iterator_range_base< + IteratorT, + typename iterator_traversal::type + > { - typedef range_detail::safe_bool< IteratorT iterator_range::* > safe_bool_t; - protected: // Used by sub_range - //! implementation class + typedef iterator_range_detail::iterator_range_base< + IteratorT, + typename iterator_traversal::type + > base_type; + + protected: typedef iterator_range_detail::iterator_range_impl impl; + public: - //! this type typedef iterator_range type; - typedef BOOST_DEDUCED_TYPENAME safe_bool_t::unspecified_bool_type unspecified_bool_type; - //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type); - //! Encapsulated value type - typedef BOOST_DEDUCED_TYPENAME - iterator_value::type value_type; - - //! Difference type - typedef BOOST_DEDUCED_TYPENAME - iterator_difference::type difference_type; - - //! Size type - typedef std::size_t size_type; // note: must be unsigned - - //! This type - typedef iterator_range this_type; - - //! Reference type - // - // Needed because value-type is the same for - // const and non-const iterators - // - typedef BOOST_DEDUCED_TYPENAME - iterator_reference::type reference; - - //! const_iterator type - /*! - There is no distinction between const_iterator and iterator. - These typedefs are provides to fulfill container interface - */ - typedef IteratorT const_iterator; - //! iterator type - typedef IteratorT iterator; - - private: // for return value of operator()() - typedef BOOST_DEDUCED_TYPENAME - boost::mpl::if_< boost::mpl::or_< boost::is_abstract< value_type >, - boost::is_array< value_type > >, - reference, value_type >::type abstract_value_type; - - public: - iterator_range() : m_Begin( iterator() ), m_End( iterator() ) - { } - - //! Constructor from a pair of iterators - template< class Iterator > - iterator_range( Iterator Begin, Iterator End ) : - m_Begin(Begin), m_End(End) - {} - - //! Constructor from a Range - template< class Range > - iterator_range( const Range& r ) : - m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ) - {} - - //! Constructor from a Range - template< class Range > - iterator_range( Range& r ) : - m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ) - {} - - //! Constructor from a Range - template< class Range > - iterator_range( const Range& r, iterator_range_detail::const_range_tag ) : - m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ) - {} - - //! Constructor from a Range - template< class Range > - iterator_range( Range& r, iterator_range_detail::range_tag ) : - m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ) - {} - - this_type& operator=( const this_type& r ) + iterator_range() { - m_Begin = r.begin(); - m_End = r.end(); + } + + template + iterator_range(Iterator first, Iterator last) + : base_type(first, last) + { + } + + template + iterator_range(const SinglePassRange& r) + : base_type(impl::adl_begin(r), impl::adl_end(r)) + { + } + + template + iterator_range(SinglePassRange& r) + : base_type(impl::adl_begin(r), impl::adl_end(r)) + { + } + + template + iterator_range(const SinglePassRange& r, + iterator_range_detail::const_range_tag) + : base_type(impl::adl_begin(r), impl::adl_end(r)) + { + } + + template + iterator_range(SinglePassRange& r, + iterator_range_detail::range_tag) + : base_type(impl::adl_begin(r), impl::adl_end(r)) + { + } + + template + iterator_range& operator=(const iterator_range& other) + { + this->assign(other.begin(), other.end()); return *this; } - template< class Iterator > - iterator_range& operator=( const iterator_range& r ) + template + iterator_range& operator=(iterator_range& other) { - m_Begin = r.begin(); - m_End = r.end(); + this->assign(other.begin(), other.end()); return *this; } - template< class ForwardRange > - iterator_range& operator=( ForwardRange& r ) + template + iterator_range& operator=(SinglePassRange& r) { - m_Begin = impl::adl_begin( r ); - m_End = impl::adl_end( r ); + this->assign(r); return *this; } - template< class ForwardRange > - iterator_range& operator=( const ForwardRange& r ) + template + iterator_range& operator=(const SinglePassRange& r) { - m_Begin = impl::adl_begin( r ); - m_End = impl::adl_end( r ); + this->assign(r); return *this; } - IteratorT begin() const - { - return m_Begin; - } - - IteratorT end() const - { - return m_End; - } - - difference_type size() const - { - return m_End - m_Begin; - } - - bool empty() const - { - return m_Begin == m_End; - } - - operator unspecified_bool_type() const - { - return safe_bool_t::to_unspecified_bool(m_Begin != m_End, &iterator_range::m_Begin); - } - - bool operator!() const - { - return empty(); - } - - bool equal(const iterator_range& r) const - { - return m_Begin == r.m_Begin && m_End == r.m_End; - } - - public: // convenience - reference front() const - { - BOOST_ASSERT( !empty() ); - return *m_Begin; - } - - reference back() const - { - BOOST_ASSERT( !empty() ); - IteratorT last( m_End ); - return *--last; - } - - // pop_front() - added to model the SinglePassRangePrimitiveConcept - void pop_front() - { - BOOST_ASSERT( !empty() ); - ++m_Begin; - } - - // pop_back() - added to model the BidirectionalRangePrimitiveConcept - void pop_back() - { - BOOST_ASSERT( !empty() ); - --m_End; - } - - reference operator[]( difference_type at ) const - { - BOOST_ASSERT( at >= 0 && at < size() ); - return m_Begin[at]; - } - - // - // When storing transform iterators, operator[]() - // fails because it returns by reference. Therefore - // operator()() is provided for these cases. - // - abstract_value_type operator()( difference_type at ) const - { - BOOST_ASSERT( at >= 0 && at < size() ); - return m_Begin[at]; - } - - iterator_range& advance_begin( difference_type n ) - { - std::advance( m_Begin, n ); - return *this; - } - - iterator_range& advance_end( difference_type n ) - { - std::advance( m_End, n ); - return *this; - } - - private: - // begin and end iterators - IteratorT m_Begin; - IteratorT m_End; - protected: // // Allow subclasses an easy way to access the diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index 60e6e39..a3693dc 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -12,6 +12,7 @@ #include #include +#include #include #include #include @@ -167,8 +168,6 @@ namespace boost_range_adaptor_type_erased_test { using namespace boost::adaptors; - typedef Buffer buffer_type; - typedef typename boost::range_value::type value_type; typedef typename boost::any_range_type_generator< @@ -451,13 +450,24 @@ namespace boost_range_adaptor_type_erased_test for (int i = 0; i < 10; ++i) c.push_back(i); - typedef boost::any_range< - int - , boost::random_access_traversal_tag - , int - , boost::range_difference< std::vector >::type - , boost::use_default - > any_range_type; + typedef boost::any_range_type_generator< + std::vector >::type any_range_type; + + BOOST_STATIC_ASSERT( + boost::is_same< + int, + boost::range_value::type + >::value + ); + + BOOST_STATIC_ASSERT( + boost::is_same< + boost::random_access_traversal_tag, + boost::iterator_traversal< + boost::range_iterator::type + >::type + >::value + ); any_range_type rng = c | type_erased_t(); From 9e6bdc13ba94af4e150afae547557a2fbbfe3bf0 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Wed, 26 Feb 2014 00:56:27 +0000 Subject: [PATCH 27/60] hotfix to regression in integer_range due to recent SFINAE change to iterator_range. --- include/boost/range/irange.hpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/include/boost/range/irange.hpp b/include/boost/range/irange.hpp index f35df47..b1a1240 100644 --- a/include/boost/range/irange.hpp +++ b/include/boost/range/irange.hpp @@ -51,6 +51,7 @@ namespace boost typedef typename base_t::value_type value_type; typedef typename base_t::difference_type difference_type; typedef typename base_t::reference reference; + typedef std::random_access_iterator_tag iterator_category; integer_iterator() : m_value() {} explicit integer_iterator(value_type x) : m_value(x) {} @@ -73,7 +74,11 @@ namespace boost difference_type distance_to(const integer_iterator& other) const { - return other.m_value - m_value; + return is_signed::value + ? (other.m_value - m_value) + : (other.m_value >= m_value) + ? static_cast(other.m_value - m_value) + : -static_cast(m_value - other.m_value); } bool equal(const integer_iterator& other) const @@ -123,6 +128,7 @@ namespace boost typedef typename base_t::value_type value_type; typedef typename base_t::difference_type difference_type; typedef typename base_t::reference reference; + typedef std::random_access_iterator_tag iterator_category; integer_iterator_with_step(value_type first, difference_type step, value_type step_size) : m_first(first) @@ -164,7 +170,7 @@ namespace boost friend class ::boost::iterator_core_access; value_type m_first; - value_type m_step; + difference_type m_step; difference_type m_step_size; }; From ceffd1cf79047fa262d74b13a148352e5ce4e9f5 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Wed, 26 Feb 2014 21:17:29 +0000 Subject: [PATCH 28/60] strided adaptor rewritten to correct defects and optimise performance. --- include/boost/range/adaptor/strided.hpp | 609 ++++++++++++++---- .../boost/range/detail/has_member_size.hpp | 66 ++ include/boost/range/irange.hpp | 10 +- include/boost/range/iterator_range_core.hpp | 8 +- include/boost/range/size.hpp | 25 +- test/Jamfile.v2 | 1 + test/adaptor_test/strided.cpp | 11 +- .../ticket_9519_strided_reversed.cpp | 67 ++ 8 files changed, 653 insertions(+), 144 deletions(-) create mode 100644 include/boost/range/detail/has_member_size.hpp create mode 100644 test/adaptor_test/ticket_9519_strided_reversed.cpp diff --git a/include/boost/range/adaptor/strided.hpp b/include/boost/range/adaptor/strided.hpp index e843f62..c5fea86 100755 --- a/include/boost/range/adaptor/strided.hpp +++ b/include/boost/range/adaptor/strided.hpp @@ -13,7 +13,7 @@ #include #include -#include +#include #include namespace boost @@ -23,59 +23,102 @@ namespace boost // strided_iterator for wrapping a forward traversal iterator template class strided_iterator - : public iterator_adaptor< + : public iterator_facade< strided_iterator - , BaseIterator - , use_default - , boost::forward_traversal_tag + , typename iterator_value::type + , forward_traversal_tag + , typename iterator_reference::type + , typename iterator_difference::type > { friend class ::boost::iterator_core_access; - typedef iterator_adaptor< - strided_iterator - , BaseIterator - , use_default - , boost::forward_traversal_tag - > super_t; + typedef iterator_facade< + strided_iterator + , typename iterator_value::type + , forward_traversal_tag + , typename iterator_reference::type + , typename iterator_difference::type + > super_t; public: - typedef BOOST_DEDUCED_TYPENAME std::iterator_traits::difference_type difference_type; + typedef typename super_t::difference_type difference_type; + typedef typename super_t::reference reference; typedef BaseIterator base_iterator; + typedef std::forward_iterator_tag iterator_category; strided_iterator() - : m_last() + : m_it() + , m_last() , m_stride() { } - strided_iterator(base_iterator first, base_iterator it, base_iterator last, difference_type stride) - : super_t(it) + strided_iterator(base_iterator it, + base_iterator last, + difference_type stride) + : m_it(it) , m_last(last) , m_stride(stride) { } template - strided_iterator(const strided_iterator& other, - BOOST_DEDUCED_TYPENAME enable_if_convertible::type* = 0) - : super_t(other) + strided_iterator( + const strided_iterator& other, + typename enable_if_convertible< + OtherIterator, + base_iterator + >::type* = 0 + ) + : m_it(other.base()) , m_last(other.base_end()) , m_stride(other.get_stride()) { } - base_iterator base_end() const { return m_last; } - difference_type get_stride() const { return m_stride; } + base_iterator base() const + { + return m_it; + } + + base_iterator base_end() const + { + return m_last; + } + + difference_type get_stride() const + { + return m_stride; + } private: void increment() { - base_iterator& it = this->base_reference(); - for (difference_type i = 0; (it != m_last) && (i < m_stride); ++i) - ++it; + for (difference_type i = 0; + (m_it != m_last) && (i < m_stride); ++i) + { + ++m_it; + } } + reference dereference() const + { + return *m_it; + } + + template + bool equal( + const strided_iterator& other, + typename enable_if_convertible< + OtherIterator, + base_iterator + >::type* = 0) const + { + return m_it == other.m_it; + } + + base_iterator m_it; base_iterator m_last; difference_type m_stride; }; @@ -83,214 +126,514 @@ namespace boost // strided_iterator for wrapping a bidirectional iterator template class strided_iterator - : public iterator_adaptor< + : public iterator_facade< strided_iterator - , BaseIterator - , use_default - , bidirectional_traversal_tag + , typename iterator_value::type + , bidirectional_traversal_tag + , typename iterator_reference::type + , typename iterator_difference::type > { friend class ::boost::iterator_core_access; - typedef iterator_adaptor< - strided_iterator - , BaseIterator - , use_default - , bidirectional_traversal_tag - > super_t; + typedef iterator_facade< + strided_iterator + , typename iterator_value::type + , bidirectional_traversal_tag + , typename iterator_reference::type + , typename iterator_difference::type + > super_t; public: - typedef BOOST_DEDUCED_TYPENAME std::iterator_traits::difference_type difference_type; + typedef typename super_t::difference_type difference_type; + typedef typename super_t::reference reference; typedef BaseIterator base_iterator; + typedef typename boost::make_unsigned::type + size_type; + typedef std::bidirectional_iterator_tag iterator_category; strided_iterator() - : m_first() - , m_last() + : m_it() + , m_offset() + , m_index() , m_stride() { } - strided_iterator(base_iterator first, base_iterator it, base_iterator last, difference_type stride) - : super_t(it) - , m_first(first) - , m_last(last) + strided_iterator(base_iterator it, + size_type index, + difference_type stride) + : m_it(it) + , m_offset() + , m_index(index) , m_stride(stride) { + if (stride && ((m_index % stride) != 0)) + m_index += (stride - (m_index % stride)); } template - strided_iterator(const strided_iterator& other, - BOOST_DEDUCED_TYPENAME enable_if_convertible::type* = 0) - : super_t(other.base()) - , m_first(other.base_begin()) - , m_last(other.base_end()) + strided_iterator( + const strided_iterator< + OtherIterator, + bidirectional_traversal_tag + >& other, + typename enable_if_convertible< + OtherIterator, + base_iterator + >::type* = 0 + ) + : m_it(other.base()) + , m_offset(other.get_offset()) + , m_index(other.get_index()) , m_stride(other.get_stride()) { } - base_iterator base_begin() const { return m_first; } - base_iterator base_end() const { return m_last; } - difference_type get_stride() const { return m_stride; } + base_iterator base() const + { + return m_it; + } + + difference_type get_offset() const + { + return m_offset; + } + + size_type get_index() const + { + return m_index; + } + + difference_type get_stride() const + { + return m_stride; + } private: void increment() { - base_iterator& it = this->base_reference(); - for (difference_type i = 0; (it != m_last) && (i < m_stride); ++i) - ++it; + m_offset += m_stride; } void decrement() { - base_iterator& it = this->base_reference(); - for (difference_type i = 0; (it != m_first) && (i < m_stride); ++i) - --it; + m_offset -= m_stride; } - base_iterator m_first; - base_iterator m_last; + reference dereference() const + { + update(); + return *m_it; + } + + void update() const + { + std::advance(m_it, m_offset); + m_index += m_offset; + m_offset = 0; + } + + template + bool equal( + const strided_iterator< + OtherIterator, + bidirectional_traversal_tag + >& other, + typename enable_if_convertible< + OtherIterator, + base_iterator + >::type* = 0) const + { + return (m_index + m_offset) == + (other.get_index() + other.get_offset()); + } + + mutable base_iterator m_it; + mutable difference_type m_offset; + mutable size_type m_index; difference_type m_stride; }; // strided_iterator implementation for wrapping a random access iterator template class strided_iterator - : public iterator_adaptor< - strided_iterator - , BaseIterator - , use_default - , random_access_traversal_tag - > + : public iterator_facade< + strided_iterator + , typename iterator_value::type + , random_access_traversal_tag + , typename iterator_reference::type + , typename iterator_difference::type + > { friend class ::boost::iterator_core_access; - typedef iterator_adaptor< - strided_iterator - , BaseIterator - , use_default - , random_access_traversal_tag - > super_t; + typedef iterator_facade< + strided_iterator + , typename iterator_value::type + , random_access_traversal_tag + , typename iterator_reference::type + , typename iterator_difference::type + > super_t; public: - typedef BOOST_DEDUCED_TYPENAME super_t::difference_type difference_type; + typedef typename super_t::difference_type difference_type; + typedef typename super_t::reference reference; typedef BaseIterator base_iterator; + typedef std::random_access_iterator_tag iterator_category; strided_iterator() - : m_first() - , m_last() + : m_it() + , m_first() , m_index(0) , m_stride() { } - strided_iterator(BaseIterator first, BaseIterator it, BaseIterator last, difference_type stride) - : super_t(it) + strided_iterator( + base_iterator first, + base_iterator it, + difference_type stride + ) + : m_it(it) , m_first(first) - , m_last(last) - , m_index(stride ? (it - first) / stride : 0) + , m_index(stride ? (it - first) : difference_type()) , m_stride(stride) { + if (stride && ((m_index % stride) != 0)) + m_index += (stride - (m_index % stride)); } template - strided_iterator(const strided_iterator& other, - BOOST_DEDUCED_TYPENAME enable_if_convertible::type* = 0) - : super_t(other.base()) + strided_iterator( + const strided_iterator< + OtherIterator, + random_access_traversal_tag + >& other, + typename enable_if_convertible< + OtherIterator, + base_iterator + >::type* = 0 + ) + : m_it(other.base()) , m_first(other.base_begin()) - , m_last(other.base_end()) , m_index(other.get_index()) , m_stride(other.get_stride()) { } - base_iterator base_begin() const { return m_first; } - base_iterator base_end() const { return m_last; } - difference_type get_stride() const { return m_stride; } - difference_type get_index() const { return m_index; } + base_iterator base_begin() const + { + return m_first; + } + + base_iterator base() const + { + return m_it; + } + + difference_type get_stride() const + { + return m_stride; + } + + difference_type get_index() const + { + return m_index; + } private: void increment() { m_index += m_stride; - if (m_index < (m_last - m_first)) - this->base_reference() = m_first + m_index; - else - this->base_reference() = m_last; } void decrement() { m_index -= m_stride; - if (m_index >= 0) - this->base_reference() = m_first + m_index; - else - this->base_reference() = m_first; } void advance(difference_type offset) { - offset *= m_stride; - m_index += offset; - if (m_index < 0) - this->base_reference() = m_first; - else if (m_index > (m_last - m_first)) - this->base_reference() = m_last; - else - this->base_reference() = m_first + m_index; + m_index += (m_stride * offset); + } + + // Implementation detail: only update the actual underlying iterator + // at the point of dereference. This is done so that the increment + // and decrement can overshoot the valid sequence as is required + // by striding. Since we can do all comparisons just with the index + // simply, and all dereferences must be within the valid range. + void update() const + { + m_it = m_first + m_index; } template - difference_type distance_to(const strided_iterator& other, - BOOST_DEDUCED_TYPENAME enable_if_convertible::type* = 0) const + difference_type distance_to( + const strided_iterator< + OtherIterator, + random_access_traversal_tag + >& other, + typename enable_if_convertible< + OtherIterator, base_iterator>::type* = 0) const { - if (other.base() >= this->base()) - return (other.base() - this->base() + (m_stride - 1)) / m_stride; - return (other.base() - this->base() - (m_stride - 1)) / m_stride; + BOOST_ASSERT((other.m_index - m_index) % m_stride == difference_type()); + return (other.m_index - m_index) / m_stride; } - bool equal(const strided_iterator& other) const + template + bool equal( + const strided_iterator< + OtherIterator, + random_access_traversal_tag + >& other, + typename enable_if_convertible< + OtherIterator, base_iterator>::type* = 0) const { - return this->base() == other.base(); + return m_index == other.m_index; + } + + reference dereference() const + { + update(); + return *m_it; } private: + mutable base_iterator m_it; base_iterator m_first; - base_iterator m_last; difference_type m_index; difference_type m_stride; }; - template inline - strided_iterator::type> - make_strided_iterator(BaseIterator first, BaseIterator it, - BaseIterator last, Difference stride) + template inline + strided_iterator< + typename range_iterator::type, + forward_traversal_tag + > + make_begin_strided_iterator( + Rng& rng, + Difference stride, + forward_traversal_tag) { - BOOST_ASSERT( stride >= 0 ); - typedef BOOST_DEDUCED_TYPENAME iterator_traversal::type traversal_tag; - return strided_iterator(first, it, last, stride); + return strided_iterator< + typename range_iterator::type, + forward_traversal_tag + >(boost::begin(rng), boost::end(rng), stride); } - template< class Rng - , class Category = BOOST_DEDUCED_TYPENAME iterator_traversal< - BOOST_DEDUCED_TYPENAME range_iterator::type - >::type - > + template inline + strided_iterator< + typename range_iterator::type, + forward_traversal_tag + > + make_begin_strided_iterator( + const Rng& rng, + Difference stride, + forward_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + forward_traversal_tag + >(boost::begin(rng), boost::end(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + forward_traversal_tag + > + make_end_strided_iterator( + Rng& rng, + Difference stride, + forward_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + forward_traversal_tag + >(boost::end(rng), boost::end(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + forward_traversal_tag + > + make_end_strided_iterator( + const Rng& rng, + Difference stride, + forward_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + forward_traversal_tag + >(boost::end(rng), boost::end(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + > + make_begin_strided_iterator( + Rng& rng, + Difference stride, + bidirectional_traversal_tag) + { + typedef typename range_difference::type difference_type; + + return strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + >(boost::begin(rng), difference_type(), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + > + make_begin_strided_iterator( + const Rng& rng, + Difference stride, + bidirectional_traversal_tag) + { + typedef typename range_difference::type difference_type; + + return strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + >(boost::begin(rng), difference_type(), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + > + make_end_strided_iterator( + Rng& rng, + Difference stride, + bidirectional_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + >(boost::end(rng), boost::size(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + > + make_end_strided_iterator( + const Rng& rng, + Difference stride, + bidirectional_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + bidirectional_traversal_tag + >(boost::end(rng), boost::size(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + > + make_begin_strided_iterator( + Rng& rng, + Difference stride, + random_access_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + >(boost::begin(rng), boost::begin(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + > + make_begin_strided_iterator( + const Rng& rng, + Difference stride, + random_access_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + >(boost::begin(rng), boost::begin(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + > + make_end_strided_iterator( + Rng& rng, + Difference stride, + random_access_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + >(boost::begin(rng), boost::end(rng), stride); + } + + template inline + strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + > + make_end_strided_iterator( + const Rng& rng, + Difference stride, + random_access_traversal_tag) + { + return strided_iterator< + typename range_iterator::type, + random_access_traversal_tag + >(boost::begin(rng), boost::end(rng), stride); + } + + template< + class Rng, + class Category = + typename iterator_traversal< + typename range_iterator::type + >::type + > class strided_range : public iterator_range< - range_detail::strided_iterator< - BOOST_DEDUCED_TYPENAME range_iterator::type, - Category - > - > + range_detail::strided_iterator< + typename range_iterator::type, + Category + > + > { typedef range_detail::strided_iterator< - BOOST_DEDUCED_TYPENAME range_iterator::type, - Category - > iter_type; + typename range_iterator::type, + Category + > iter_type; typedef iterator_range super_t; public: template strided_range(Difference stride, Rng& rng) - : super_t(make_strided_iterator(boost::begin(rng), boost::begin(rng), boost::end(rng), stride), - make_strided_iterator(boost::begin(rng), boost::end(rng), boost::end(rng), stride)) + : super_t( + range_detail::make_begin_strided_iterator( + rng, stride, + typename iterator_traversal< + typename range_iterator::type + >::type()), + range_detail::make_end_strided_iterator( + rng, stride, + typename iterator_traversal< + typename range_iterator::type + >::type())) { BOOST_ASSERT( stride >= 0 ); } @@ -300,7 +643,10 @@ namespace boost class strided_holder : public holder { public: - explicit strided_holder(Difference value) : holder(value) {} + explicit strided_holder(Difference value) + : holder(value) + { + } }; template @@ -327,7 +673,8 @@ namespace boost namespace { const range_detail::forwarder - strided = range_detail::forwarder(); + strided = range_detail::forwarder< + range_detail::strided_holder>(); } template diff --git a/include/boost/range/detail/has_member_size.hpp b/include/boost/range/detail/has_member_size.hpp new file mode 100644 index 0000000..0c639aa --- /dev/null +++ b/include/boost/range/detail/has_member_size.hpp @@ -0,0 +1,66 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// For more information, see http://www.boost.org/libs/range/ +// +#ifndef BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP +#define BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP + +#include +#include +#include +#include +#include + +namespace boost +{ + namespace range_detail + { + +template +class has_member_size_impl +{ +private: + template + class check + { + }; + + template + static boost::uint8_t f(check*); + + template + static boost::uint16_t f(...); + +public: + static const bool value = + (sizeof(f(0)) == sizeof(boost::uint8_t)); + + typedef typename mpl::if_c< + (sizeof(f(0)) == sizeof(boost::uint8_t)), + mpl::true_, + mpl::false_ + >::type type; +}; + +template +struct has_member_size +{ + typedef typename mpl::and_< + typename is_class::type, + typename has_member_size_impl::type + >::type type; + + static const bool value = + is_class::value && has_member_size_impl::value; +}; + + } // namespace range_detail +}// namespace boost + +#endif // include guard diff --git a/include/boost/range/irange.hpp b/include/boost/range/irange.hpp index f35df47..b1a1240 100644 --- a/include/boost/range/irange.hpp +++ b/include/boost/range/irange.hpp @@ -51,6 +51,7 @@ namespace boost typedef typename base_t::value_type value_type; typedef typename base_t::difference_type difference_type; typedef typename base_t::reference reference; + typedef std::random_access_iterator_tag iterator_category; integer_iterator() : m_value() {} explicit integer_iterator(value_type x) : m_value(x) {} @@ -73,7 +74,11 @@ namespace boost difference_type distance_to(const integer_iterator& other) const { - return other.m_value - m_value; + return is_signed::value + ? (other.m_value - m_value) + : (other.m_value >= m_value) + ? static_cast(other.m_value - m_value) + : -static_cast(m_value - other.m_value); } bool equal(const integer_iterator& other) const @@ -123,6 +128,7 @@ namespace boost typedef typename base_t::value_type value_type; typedef typename base_t::difference_type difference_type; typedef typename base_t::reference reference; + typedef std::random_access_iterator_tag iterator_category; integer_iterator_with_step(value_type first, difference_type step, value_type step_size) : m_first(first) @@ -164,7 +170,7 @@ namespace boost friend class ::boost::iterator_core_access; value_type m_first; - value_type m_step; + difference_type m_step; difference_type m_step_size; }; diff --git a/include/boost/range/iterator_range_core.hpp b/include/boost/range/iterator_range_core.hpp index 1e671fc..1e63b7e 100644 --- a/include/boost/range/iterator_range_core.hpp +++ b/include/boost/range/iterator_range_core.hpp @@ -371,13 +371,13 @@ public: template class iterator_range : public iterator_range_detail::iterator_range_base< - IteratorT, - typename iterator_traversal::type + IteratorT, + BOOST_DEDUCED_TYPENAME iterator_traversal::type > { typedef iterator_range_detail::iterator_range_base< - IteratorT, - typename iterator_traversal::type + IteratorT, + BOOST_DEDUCED_TYPENAME iterator_traversal::type > base_type; protected: diff --git a/include/boost/range/size.hpp b/include/boost/range/size.hpp index 9b63aff..cd7a90e 100644 --- a/include/boost/range/size.hpp +++ b/include/boost/range/size.hpp @@ -19,24 +19,39 @@ #include #include #include +#include #include +#include +#include namespace boost { namespace range_detail { + template - inline BOOST_DEDUCED_TYPENAME range_size::type + inline typename enable_if< + has_member_size, + typename range_size::type + >::type range_calculate_size(const SinglePassRange& rng) { - BOOST_ASSERT( (boost::end(rng) - boost::begin(rng)) >= 0 && - "reachability invariant broken!" ); - return boost::end(rng) - boost::begin(rng); + return rng.size(); + } + + template + inline typename disable_if< + has_member_size, + typename range_size::type + >::type + range_calculate_size(const SinglePassRange& rng) + { + return std::distance(boost::begin(rng), boost::end(rng)); } } template - inline BOOST_DEDUCED_TYPENAME range_size::type + inline typename range_size::type size(const SinglePassRange& rng) { #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 0871332..ef3d0cd 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -44,6 +44,7 @@ test-suite range : [ range-test adaptor_test/sliced ] [ range-test adaptor_test/strided ] [ range-test adaptor_test/strided2 ] + [ range-test adaptor_test/ticket_9519_strided_reversed ] [ range-test adaptor_test/tokenized ] [ range-test adaptor_test/transformed ] [ range-test adaptor_test/type_erased ] diff --git a/test/adaptor_test/strided.cpp b/test/adaptor_test/strided.cpp index ad9e9e4..6c8475d 100644 --- a/test/adaptor_test/strided.cpp +++ b/test/adaptor_test/strided.cpp @@ -137,8 +137,15 @@ namespace boost boost::ignore_unused_variable_warning(rng); typedef BOOST_DEDUCED_TYPENAME boost::range_iterator::type iter_t; - iter_t first(boost::begin(c), boost::begin(c), boost::end(c), 0); - iter_t last(boost::begin(c), boost::end(c), boost::end(c), 0); + typedef BOOST_DEDUCED_TYPENAME boost::iterator_traversal< + BOOST_DEDUCED_TYPENAME Container::const_iterator + >::type container_traversal_tag; + + iter_t first = boost::range_detail::make_begin_strided_iterator( + c, 0, container_traversal_tag()); + + iter_t last = boost::range_detail::make_end_strided_iterator( + c, 0, container_traversal_tag()); iter_t it = first; for (int i = 0; i < 10; ++i, ++it) diff --git a/test/adaptor_test/ticket_9519_strided_reversed.cpp b/test/adaptor_test/ticket_9519_strided_reversed.cpp new file mode 100644 index 0000000..0c91598 --- /dev/null +++ b/test/adaptor_test/ticket_9519_strided_reversed.cpp @@ -0,0 +1,67 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// +// For more information, see http://www.boost.org/libs/range/ +// +// Credit goes to Eric Niebler for providing an example to demonstrate this +// issue. This has been trivially modified to create this test case. +// +#include +#include +#include + +#include +#include + +#include +#include +#include + +namespace boost +{ + namespace + { + +void ticket_9519_strided_reversed_test() +{ + using namespace boost::adaptors; + + std::vector vi; + for (int i = 0; i < 50; ++i) + { + vi.push_back(i); + } + + std::vector output; + boost::push_back(output, vi | strided(3) | reversed); + + std::list reference; + for (int i = 0; i < 50; i += 3) + { + reference.push_front(i); + } + + BOOST_CHECK_EQUAL_COLLECTIONS(output.begin(), output.end(), + reference.begin(), reference.end()); +} + + } // anonymous namespace +} // namespace boost + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test + = BOOST_TEST_SUITE( + "RangeTestSuite.adaptor.ticket_9519_strided_reversed"); + + test->add(BOOST_TEST_CASE(&boost::ticket_9519_strided_reversed_test)); + + return test; +} + From 49cfefdef5af0b66bfc1ef0a0e835753fcc2fee9 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Wed, 26 Feb 2014 21:34:34 +0000 Subject: [PATCH 29/60] equal algorithm corrected to be O(1) with random access and pred. --- include/boost/range/algorithm/equal.hpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/boost/range/algorithm/equal.hpp b/include/boost/range/algorithm/equal.hpp index 4472bb1..36d768f 100644 --- a/include/boost/range/algorithm/equal.hpp +++ b/include/boost/range/algorithm/equal.hpp @@ -120,7 +120,9 @@ namespace boost RandomAccessTraversalReadableIterator1 last1, RandomAccessTraversalReadableIterator2 first2, RandomAccessTraversalReadableIterator2 last2, - BinaryPredicate pred ) + BinaryPredicate pred, + std::random_access_iterator_tag, + std::random_access_iterator_tag ) { return ((last1 - first1) == (last2 - first2)) && std::equal(first1, last1, first2, pred); From 2a065b2420aad49767abd063c4641866cd017da3 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Wed, 26 Feb 2014 21:40:39 +0000 Subject: [PATCH 30/60] trac_6732 join_iterator.hpp unused variable warn. --- include/boost/range/detail/join_iterator.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/include/boost/range/detail/join_iterator.hpp b/include/boost/range/detail/join_iterator.hpp index d025c81..ea0dd20 100644 --- a/include/boost/range/detail/join_iterator.hpp +++ b/include/boost/range/detail/join_iterator.hpp @@ -117,7 +117,8 @@ public: return *m_it; } - bool equal(const join_iterator_union& other, unsigned int selected) const + bool equal(const join_iterator_union& other, + unsigned int /*selected*/) const { return m_it == other.m_it; } From 259e917eaf4929b0137717011db9bdd40fc990ab Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Wed, 26 Feb 2014 22:02:27 +0000 Subject: [PATCH 31/60] trac_8693 const cast warn --- include/boost/range/algorithm_ext/push_back.hpp | 5 +++-- include/boost/range/algorithm_ext/push_front.hpp | 5 +++-- include/boost/range/detail/implementation_help.hpp | 11 +++++++++++ 3 files changed, 17 insertions(+), 4 deletions(-) diff --git a/include/boost/range/algorithm_ext/push_back.hpp b/include/boost/range/algorithm_ext/push_back.hpp index 51a7a7b..6fb9b9b 100755 --- a/include/boost/range/algorithm_ext/push_back.hpp +++ b/include/boost/range/algorithm_ext/push_back.hpp @@ -15,6 +15,7 @@ #include #include #include +#include #include namespace boost @@ -27,8 +28,8 @@ inline Container& push_back( Container& on, const Range& from ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - BOOST_ASSERT( (void*)&on != (void*)&from && - "cannot copy from a container to itself" ); + 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; } diff --git a/include/boost/range/algorithm_ext/push_front.hpp b/include/boost/range/algorithm_ext/push_front.hpp index 470d793..e893098 100755 --- a/include/boost/range/algorithm_ext/push_front.hpp +++ b/include/boost/range/algorithm_ext/push_front.hpp @@ -15,6 +15,7 @@ #include #include #include +#include #include namespace boost @@ -27,8 +28,8 @@ inline Container& push_front( Container& on, const Range& from ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - BOOST_ASSERT( (void*)&on != (void*)&from && - "cannot copy from a container to itself" ); + BOOST_ASSERT_MSG(!range_detail::is_same_object(on, from), + "cannot copy from a container to itself"); on.insert( on.begin(), boost::begin(from), boost::end(from) ); return on; } diff --git a/include/boost/range/detail/implementation_help.hpp b/include/boost/range/detail/implementation_help.hpp index ca12fa4..1560587 100755 --- a/include/boost/range/detail/implementation_help.hpp +++ b/include/boost/range/detail/implementation_help.hpp @@ -95,6 +95,17 @@ namespace boost return sz; } + inline bool is_same_address(const void* l, const void* r) + { + return l == r; + } + + template + inline bool is_same_object(const T1& l, const T2& r) + { + return range_detail::is_same_address(&l, &r); + } + } // namespace 'range_detail' } // namespace 'boost' From fd0f99c767086447657f662a11faec2969401cca Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Thu, 27 Feb 2014 13:51:06 +0000 Subject: [PATCH 32/60] inner_product avoids pre-condition check with input_iterators due to single-pass limitation. --- include/boost/range/numeric.hpp | 38 +++++++++++++++++++++++++++++++-- 1 file changed, 36 insertions(+), 2 deletions(-) diff --git a/include/boost/range/numeric.hpp b/include/boost/range/numeric.hpp index c70069f..0b61527 100644 --- a/include/boost/range/numeric.hpp +++ b/include/boost/range/numeric.hpp @@ -30,8 +30,10 @@ #include #include #include +#include #include #include +#include #include @@ -51,13 +53,41 @@ namespace boost return std::accumulate( boost::begin(rng), boost::end(rng), init, op ); } + namespace range_detail + { + template + inline bool inner_product_precondition( + const SinglePassRange1&, + const SinglePassRange2&, + std::input_iterator_tag, + std::input_iterator_tag) + { + return true; + } + + template + inline bool inner_product_precondition( + const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + std::forward_iterator_tag, + std::forward_iterator_tag) + { + return boost::size(rng2) >= boost::size(rng1); + } + + } // namespace range_detail template< class SinglePassRange1, class SinglePassRange2, class Value > inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) ); + BOOST_ASSERT( + range_detail::inner_product_precondition( + rng1, rng2, + typename range_category::type(), + typename range_category::type())); + return std::inner_product( boost::begin(rng1), boost::end(rng1), boost::begin(rng2), init ); } @@ -72,7 +102,11 @@ namespace boost { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) ); + BOOST_ASSERT( + range_detail::inner_product_precondition( + rng1, rng2, + typename range_category::type(), + typename range_category::type())); return std::inner_product( boost::begin(rng1), boost::end(rng1), boost::begin(rng2), init, op1, op2 ); From 9b477525de9e1f38431ea18c32ec98590d45724d Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Thu, 27 Feb 2014 15:59:03 +0000 Subject: [PATCH 33/60] reformatted numeric.hpp --- include/boost/range/numeric.hpp | 150 ++++++++++++++++++++------------ 1 file changed, 93 insertions(+), 57 deletions(-) diff --git a/include/boost/range/numeric.hpp b/include/boost/range/numeric.hpp index 0b61527..d1510cd 100644 --- a/include/boost/range/numeric.hpp +++ b/include/boost/range/numeric.hpp @@ -1,14 +1,8 @@ -/////////////////////////////////////////////////////////////////////////////// -/// \file algorithm.hpp -/// Contains range-based versions of the std algorithms -// -///////////////////////////////////////////////////////////////////////////// -// Copyright 2009 Neil Groves. +// Copyright 2009-2014 Neil Groves. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // - // Copyright 2006 Thorsten Ottosen. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at @@ -18,7 +12,9 @@ // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) - +// +// Contains range-based versions of the numeric std algorithms +// #if defined(_MSC_VER) #pragma once #endif @@ -39,18 +35,23 @@ namespace boost { - template< class SinglePassRange, class Value > - inline Value accumulate( const SinglePassRange& rng, Value init ) + template + inline Value accumulate(const SinglePassRange& rng, Value init) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return std::accumulate( boost::begin(rng), boost::end(rng), init ); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + + return std::accumulate(boost::begin(rng), boost::end(rng), init); } - template< class SinglePassRange, class Value, class BinaryOperation > - inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op ) + template + inline Value accumulate(const SinglePassRange& rng, Value init, + BinaryOperation op) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return std::accumulate( boost::begin(rng), boost::end(rng), init, op ); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept )); + + return std::accumulate(boost::begin(rng), boost::end(rng), init, op); } namespace range_detail @@ -77,76 +78,111 @@ namespace boost } // namespace range_detail - template< class SinglePassRange1, class SinglePassRange2, class Value > - inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init ) + template< + class SinglePassRange1, + class SinglePassRange2, + class Value + > + inline Value inner_product( + const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + Value init) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + BOOST_ASSERT( range_detail::inner_product_precondition( rng1, rng2, typename range_category::type(), typename range_category::type())); - return std::inner_product( boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), init ); + return std::inner_product( + boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), init); } - template< class SinglePassRange1, - class SinglePassRange2, - class Value, - class BinaryOperation1, class BinaryOperation2 > - inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, - Value init, - BinaryOperation1 op1, BinaryOperation2 op2 ) + template< + class SinglePassRange1, + class SinglePassRange2, + class Value, + class BinaryOperation1, + class BinaryOperation2 + > + inline Value inner_product( + const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + Value init, + BinaryOperation1 op1, + BinaryOperation2 op2) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + BOOST_ASSERT( range_detail::inner_product_precondition( rng1, rng2, typename range_category::type(), typename range_category::type())); - return std::inner_product( boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), init, op1, op2 ); + return std::inner_product( + boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), init, op1, op2); } - template< class SinglePassRange, class OutputIterator > - inline OutputIterator partial_sum ( const SinglePassRange& rng, - OutputIterator result ) + template + inline OutputIterator partial_sum(const SinglePassRange& rng, + OutputIterator result) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return std::partial_sum( boost::begin(rng), boost::end(rng), result ); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + + return std::partial_sum(boost::begin(rng), boost::end(rng), result); } - template< class SinglePassRange, class OutputIterator, class BinaryOperation > - inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result, - BinaryOperation op ) + template + inline OutputIterator partial_sum( + const SinglePassRange& rng, + OutputIterator result, + BinaryOperation op) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return std::partial_sum( boost::begin(rng), boost::end(rng), result, op ); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + + return std::partial_sum(boost::begin(rng), boost::end(rng), result, op); } - template< class SinglePassRange, class OutputIterator > - inline OutputIterator adjacent_difference ( const SinglePassRange& rng, - OutputIterator result ) + template + inline OutputIterator adjacent_difference( + const SinglePassRange& rng, + OutputIterator result) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return std::adjacent_difference( boost::begin(rng), boost::end(rng), - result ); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + + return std::adjacent_difference(boost::begin(rng), boost::end(rng), + result); } - template< class SinglePassRange, class OutputIterator, class BinaryOperation > - inline OutputIterator adjacent_difference ( const SinglePassRange& rng, - OutputIterator result, - BinaryOperation op ) + template + inline OutputIterator adjacent_difference( + const SinglePassRange& rng, + OutputIterator result, + BinaryOperation op) { - BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return std::adjacent_difference( boost::begin(rng), boost::end(rng), - result, op ); + BOOST_RANGE_CONCEPT_ASSERT(( + SinglePassRangeConcept)); + + return std::adjacent_difference(boost::begin(rng), boost::end(rng), + result, op); } -} +} // namespace boost #endif From 502abb988420f0e28dca329e77bcdf9143af5d77 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Thu, 27 Feb 2014 16:34:58 +0000 Subject: [PATCH 34/60] eliminate unused local typedef and signed/unsigned comparison warnings. --- test/algorithm.cpp | 13 ++++++++----- test/algorithm_test/inplace_merge.cpp | 7 +++++-- test/algorithm_test/max_element.cpp | 7 +++++-- test/algorithm_test/min_element.cpp | 7 +++++-- test/algorithm_test/mismatch.cpp | 18 ++++++++++-------- test/algorithm_test/random_shuffle.cpp | 3 ++- test/algorithm_test/remove_copy.cpp | 3 ++- test/algorithm_test/replace_copy.cpp | 3 ++- test/algorithm_test/rotate_copy.cpp | 7 +++++-- test/algorithm_test/search_n.cpp | 4 +++- test/compat3.cpp | 2 ++ test/iterator_pair.cpp | 14 ++++++++++---- 12 files changed, 59 insertions(+), 29 deletions(-) diff --git a/test/algorithm.cpp b/test/algorithm.cpp index 2160eaf..ebe0496 100644 --- a/test/algorithm.cpp +++ b/test/algorithm.cpp @@ -107,12 +107,15 @@ template void test_random_algorithms(Rng & rng, std::random_access_iterator_tag) { typedef BOOST_DEDUCED_TYPENAME boost::range_iterator::type iterator; - typedef BOOST_DEDUCED_TYPENAME boost::range_value::type value_type; - typedef BOOST_DEDUCED_TYPENAME boost::range_size::type size_type BOOST_RANGE_UNUSED; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_category::type iterator_category; - - + typedef BOOST_DEDUCED_TYPENAME boost::range_value::type value_type; + + typedef BOOST_DEDUCED_TYPENAME boost::range_size::type + size_type BOOST_RANGE_UNUSED; + + typedef BOOST_DEDUCED_TYPENAME boost::iterator_category::type + iterator_category BOOST_RANGE_UNUSED; + // just make sure these compile (for now) if(0) { diff --git a/test/algorithm_test/inplace_merge.cpp b/test/algorithm_test/inplace_merge.cpp index d0cad73..948e95e 100644 --- a/test/algorithm_test/inplace_merge.cpp +++ b/test/algorithm_test/inplace_merge.cpp @@ -28,7 +28,9 @@ namespace boost void test(Container1& cont1, Container2& cont2) { typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t; - typedef BOOST_DEDUCED_TYPENAME std::vector::iterator iterator_t; + + typedef BOOST_DEDUCED_TYPENAME std::vector::iterator + iterator_t BOOST_RANGE_UNUSED; std::vector reference_target(cont1.begin(), cont1.end()); reference_target.insert(reference_target.end(), @@ -74,7 +76,8 @@ namespace boost void test_pred(Container1 cont1, Container2 cont2, BinaryPredicate pred) { typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t; - typedef BOOST_DEDUCED_TYPENAME std::vector::iterator iterator_t; + typedef BOOST_DEDUCED_TYPENAME std::vector::iterator + iterator_t BOOST_RANGE_UNUSED; sort_container(cont1, pred); sort_container(cont2, pred); diff --git a/test/algorithm_test/max_element.cpp b/test/algorithm_test/max_element.cpp index 9a26099..d4e87d5 100644 --- a/test/algorithm_test/max_element.cpp +++ b/test/algorithm_test/max_element.cpp @@ -106,8 +106,11 @@ namespace boost_range_test_algorithm_max_element { using namespace boost::assign; - typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t; - typedef BOOST_DEDUCED_TYPENAME boost::remove_const::type container_t; + typedef BOOST_DEDUCED_TYPENAME Container::value_type + value_t BOOST_RANGE_UNUSED; + + typedef BOOST_DEDUCED_TYPENAME boost::remove_const::type + container_t; boost::range_test::range_return_test_driver test_driver; diff --git a/test/algorithm_test/min_element.cpp b/test/algorithm_test/min_element.cpp index 0f9fa68..bb92d2c 100644 --- a/test/algorithm_test/min_element.cpp +++ b/test/algorithm_test/min_element.cpp @@ -104,8 +104,11 @@ namespace boost_range_test_algorithm_min_element { using namespace boost::assign; - typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t; - typedef BOOST_DEDUCED_TYPENAME boost::remove_const::type container_t; + typedef BOOST_DEDUCED_TYPENAME Container::value_type + value_t BOOST_RANGE_UNUSED; + + typedef BOOST_DEDUCED_TYPENAME boost::remove_const::type + container_t; boost::range_test::range_return_test_driver test_driver; diff --git a/test/algorithm_test/mismatch.cpp b/test/algorithm_test/mismatch.cpp index 2336e59..407b5fc 100644 --- a/test/algorithm_test/mismatch.cpp +++ b/test/algorithm_test/mismatch.cpp @@ -160,15 +160,17 @@ namespace boost MutableContainer2 cont2; const Container2& cref_cont2 = cont2; - typedef BOOST_DEDUCED_TYPENAME Container1::iterator iterator1_t; - typedef BOOST_DEDUCED_TYPENAME Container1::const_iterator const_iterator1_t; - typedef BOOST_DEDUCED_TYPENAME Container2::iterator iterator2_t; - typedef BOOST_DEDUCED_TYPENAME Container2::const_iterator const_iterator2_t; + typedef BOOST_DEDUCED_TYPENAME Container1::iterator + iterator1_t BOOST_RANGE_UNUSED; - typedef std::pair pair_mmit_t; - typedef std::pair pair_cmit_t; - typedef std::pair pair_mcit_t; - typedef std::pair pair_ccit_t; + typedef BOOST_DEDUCED_TYPENAME Container1::const_iterator + const_iterator1_t BOOST_RANGE_UNUSED; + + typedef BOOST_DEDUCED_TYPENAME Container2::iterator + iterator2_t BOOST_RANGE_UNUSED; + + typedef BOOST_DEDUCED_TYPENAME Container2::const_iterator + const_iterator2_t BOOST_RANGE_UNUSED; eval_mismatch(cont1, cont2, cont1.end(), cont2.end()); eval_mismatch(cont1, cont2, std::equal_to(), cont1.end(), cont2.end()); diff --git a/test/algorithm_test/random_shuffle.cpp b/test/algorithm_test/random_shuffle.cpp index 410749a..71915ee 100644 --- a/test/algorithm_test/random_shuffle.cpp +++ b/test/algorithm_test/random_shuffle.cpp @@ -90,7 +90,8 @@ namespace boost template void test_random_shuffle_nogen_impl(Container& cont) { - typedef BOOST_DEDUCED_TYPENAME range_iterator::type iterator_t; + typedef BOOST_DEDUCED_TYPENAME range_iterator::type + iterator_t BOOST_RANGE_UNUSED; const int MAX_RETRIES = 10000; diff --git a/test/algorithm_test/remove_copy.cpp b/test/algorithm_test/remove_copy.cpp index 4050ef4..b3eb8e2 100644 --- a/test/algorithm_test/remove_copy.cpp +++ b/test/algorithm_test/remove_copy.cpp @@ -36,7 +36,8 @@ namespace typedef typename boost::range_value::type value_type; std::vector reference; - typedef BOOST_DEDUCED_TYPENAME std::vector::iterator iterator_t; + typedef BOOST_DEDUCED_TYPENAME std::vector::iterator + iterator_t BOOST_RANGE_UNUSED; test_append( std::remove_copy(c.begin(), c.end(), diff --git a/test/algorithm_test/replace_copy.cpp b/test/algorithm_test/replace_copy.cpp index 6ae12e2..5629856 100644 --- a/test/algorithm_test/replace_copy.cpp +++ b/test/algorithm_test/replace_copy.cpp @@ -38,7 +38,8 @@ namespace typedef typename boost::range_value::type value_type; std::vector reference; - typedef BOOST_DEDUCED_TYPENAME std::vector::iterator iterator_t; + typedef BOOST_DEDUCED_TYPENAME std::vector::iterator + iterator_t BOOST_RANGE_UNUSED; test_append( std::replace_copy(c.begin(), c.end(), diff --git a/test/algorithm_test/rotate_copy.cpp b/test/algorithm_test/rotate_copy.cpp index 5615479..05aa4d2 100644 --- a/test/algorithm_test/rotate_copy.cpp +++ b/test/algorithm_test/rotate_copy.cpp @@ -31,11 +31,14 @@ namespace template void test_rotate_copy_impl(Container& cont, Iterator where_it) { - typedef BOOST_DEDUCED_TYPENAME boost::range_value::type value_type; + typedef BOOST_DEDUCED_TYPENAME boost::range_value::type + value_type; + std::vector reference; std::vector test; - typedef BOOST_DEDUCED_TYPENAME boost::range_iterator::type iterator_t; + typedef BOOST_DEDUCED_TYPENAME boost::range_iterator::type + iterator_t BOOST_RANGE_UNUSED; test_append( std::rotate_copy(cont.begin(), where_it, cont.end(), diff --git a/test/algorithm_test/search_n.cpp b/test/algorithm_test/search_n.cpp index 246d397..76f5b78 100644 --- a/test/algorithm_test/search_n.cpp +++ b/test/algorithm_test/search_n.cpp @@ -60,7 +60,9 @@ namespace Integer count, const Value& value, BinaryPredicate pred) { - typedef typename std::iterator_traits::iterator_category cat_t; + typedef typename std::iterator_traits< + ForwardIterator + >::iterator_category cat_t BOOST_RANGE_UNUSED; if (count <= 0) return first; diff --git a/test/compat3.cpp b/test/compat3.cpp index 5249c58..e4e4c83 100644 --- a/test/compat3.cpp +++ b/test/compat3.cpp @@ -10,6 +10,7 @@ #include #include +#include #include enum Container {}; @@ -51,6 +52,7 @@ void compat1() { std::vector v; iterator_of< std::vector >::type i = v.begin(); + boost::ignore_unused_variable_warning(i); } #include diff --git a/test/iterator_pair.cpp b/test/iterator_pair.cpp index 997b5fb..ba13d75 100644 --- a/test/iterator_pair.cpp +++ b/test/iterator_pair.cpp @@ -63,18 +63,24 @@ void check_iterator_pair() BOOST_CHECK( boost::begin( pair ) == pair.first ); BOOST_CHECK( boost::end( pair ) == pair.second ); BOOST_CHECK( boost::empty( pair ) == (pair.first == pair.second) ); - BOOST_CHECK( boost::size( pair ) == std::distance( pair.first, pair.second ) ); + BOOST_CHECK( boost::size( pair ) == + static_cast( + std::distance(pair.first, pair.second)) ); BOOST_CHECK( boost::begin( const_pair ) == const_pair.first ); BOOST_CHECK( boost::end( const_pair ) == const_pair.second ); BOOST_CHECK( boost::empty( const_pair ) == (const_pair.first == const_pair.second) ); - BOOST_CHECK( boost::size( const_pair ) == std::distance( const_pair.first, const_pair.second ) ); + BOOST_CHECK( boost::size( const_pair ) == + static_cast( + std::distance(const_pair.first, const_pair.second)) ); BOOST_CHECK( boost::begin( constness_pair ) == constness_pair.first ); BOOST_CHECK( boost::end( constness_pair ) == constness_pair.second ); BOOST_CHECK( boost::empty( constness_pair ) == (constness_pair.first == const_pair.second) ); - BOOST_CHECK( boost::size( constness_pair ) == std::distance( constness_pair.first, constness_pair.second ) ); - + BOOST_CHECK( boost::size( constness_pair ) == + static_cast( + std::distance(constness_pair.first, + constness_pair.second)) ); } From 3af0142509f34de502f9c7da87e4aa918fe0ad96 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Thu, 27 Feb 2014 17:42:32 +0000 Subject: [PATCH 35/60] fixed counting_range from a range. --- include/boost/range/counting_range.hpp | 40 ++++++++++++++++---------- test/counting_range.cpp | 17 +++++++++++ 2 files changed, 42 insertions(+), 15 deletions(-) diff --git a/include/boost/range/counting_range.hpp b/include/boost/range/counting_range.hpp index b8e4e3a..d886a21 100644 --- a/include/boost/range/counting_range.hpp +++ b/include/boost/range/counting_range.hpp @@ -17,11 +17,11 @@ #include #include +#include #include namespace boost { - template inline iterator_range > counting_range(Value first, Value last) @@ -33,29 +33,39 @@ namespace boost } template - inline iterator_range::type> > + inline iterator_range< + counting_iterator< + BOOST_DEDUCED_TYPENAME range_iterator::type + > + > counting_range(const Range& rng) { - typedef counting_iterator::type> counting_iterator_t; + typedef counting_iterator< + BOOST_DEDUCED_TYPENAME range_iterator::type + > counting_iterator_t; + typedef iterator_range result_t; - return boost::empty(rng) - ? result_t() - : result_t( - counting_iterator_t(*boost::begin(rng)), - counting_iterator_t(*boost::prior(boost::end(rng)))); + + return result_t(counting_iterator_t(boost::begin(rng)), + counting_iterator_t(boost::end(rng))); } template - inline iterator_range::type> > + inline iterator_range< + counting_iterator< + BOOST_DEDUCED_TYPENAME range_iterator::type + > + > counting_range(Range& rng) { - typedef counting_iterator::type> counting_iterator_t; + typedef counting_iterator< + BOOST_DEDUCED_TYPENAME range_iterator::type + > counting_iterator_t; + typedef iterator_range result_t; - return boost::empty(rng) - ? result_t() - : result_t( - counting_iterator_t(*boost::begin(rng)), - counting_iterator_t(*boost::prior(boost::end(rng)))); + + return result_t(counting_iterator_t(boost::begin(rng)), + counting_iterator_t(boost::end(rng))); } } // namespace boost diff --git a/test/counting_range.cpp b/test/counting_range.cpp index 18aceba..d1f1d3f 100644 --- a/test/counting_range.cpp +++ b/test/counting_range.cpp @@ -11,6 +11,7 @@ // Disable a warning from since this noise might // stop us detecting a problem in our code. #include +#include #include #include @@ -51,6 +52,22 @@ namespace boost counting_range_test_impl(-100, 100); counting_range_test_impl(50, 55); } + + void counting_range_test_range() + { + std::vector v; + for (int i = 0; i < 10; ++i) + v.push_back(i); + + std::vector::iterator> x; + push_back(x, counting_range(v)); + + std::vector t; + push_back(t, x | boost::adaptors::indirected); + + BOOST_CHECK_EQUAL_COLLECTIONS(t.begin(), t.end(), + v.begin(), v.end()); + } } void counting_range_test() From 79d2a66831af16f29befaa4d32461928b9431a15 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sun, 2 Mar 2014 15:35:50 +0000 Subject: [PATCH 36/60] trac 5816 - fix any_range requiring copyable elements. --- .../range/detail/any_iterator_interface.hpp | 29 +++++++--- .../range/detail/any_iterator_wrapper.hpp | 54 +++++++++++++++--- test/adaptor_test/type_erased.cpp | 55 +++++++++++++++++++ 3 files changed, 123 insertions(+), 15 deletions(-) diff --git a/include/boost/range/detail/any_iterator_interface.hpp b/include/boost/range/detail/any_iterator_interface.hpp index 2451491..cd56714 100644 --- a/include/boost/range/detail/any_iterator_interface.hpp +++ b/include/boost/range/detail/any_iterator_interface.hpp @@ -27,25 +27,40 @@ namespace boost { typedef typename mpl::if_< typename is_reference::type, - typename add_reference< - typename add_const< - typename remove_reference::type - >::type - >::type, + typename add_const< + typename remove_reference::type + >::type&, T >::type type; }; + template + struct mutable_reference_type_generator + { + typedef typename mpl::if_< + typename mpl::and_< + typename is_const::type, + typename mpl::not_::type>::type + >::type, + T, + typename add_reference::type + >::type type; + }; + template< class Reference , class Buffer > struct any_incrementable_iterator_interface { - typedef Reference reference; + typedef typename mutable_reference_type_generator< + Reference + >::type reference; + typedef typename const_reference_type_generator< Reference >::type const_reference; + typedef typename remove_const< typename remove_reference::type >::type reference_as_value_type; @@ -87,7 +102,7 @@ namespace boost virtual any_single_pass_iterator_interface* clone_reference_as_value(buffer_type& buffer) const = 0; - virtual Reference dereference() const = 0; + virtual reference dereference() const = 0; virtual bool equal(const any_single_pass_iterator_interface& other) const = 0; }; diff --git a/include/boost/range/detail/any_iterator_wrapper.hpp b/include/boost/range/detail/any_iterator_wrapper.hpp index 502e3e8..2526aa8 100644 --- a/include/boost/range/detail/any_iterator_wrapper.hpp +++ b/include/boost/range/detail/any_iterator_wrapper.hpp @@ -19,6 +19,17 @@ namespace boost { namespace range_detail { + template + Reference dereference_cast(T& x) + { + return static_cast(x); + } + template + Reference dereference_cast(const T& x) + { + return static_cast(const_cast(x)); + } + template< class WrappedIterator , class Reference @@ -114,7 +125,13 @@ namespace boost { struct disabler {}; BOOST_RANGE_CONCEPT_ASSERT(( SinglePassIteratorConcept )); + typedef any_single_pass_iterator_interface< + Reference, + Buffer + > base_type; + public: + typedef typename base_type::reference reference; any_single_pass_iterator_wrapper() : m_it() @@ -178,9 +195,9 @@ namespace boost return m_it == boost::polymorphic_downcast(&other)->m_it; } - virtual Reference dereference() const + virtual reference dereference() const { - return *m_it; + return dereference_cast(*m_it); } private: @@ -199,7 +216,14 @@ namespace boost > { BOOST_RANGE_CONCEPT_ASSERT(( ForwardIteratorConcept )); + typedef any_forward_iterator_interface< + Reference, + Buffer + > base_type; + public: + typedef typename base_type::reference reference; + any_forward_iterator_wrapper() : m_it() {} @@ -263,9 +287,9 @@ namespace boost return m_it == boost::polymorphic_downcast(&other)->m_it; } - virtual Reference dereference() const + virtual reference dereference() const { - return *m_it; + return dereference_cast(*m_it); } private: WrappedIterator m_it; @@ -283,7 +307,14 @@ namespace boost > { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalIteratorConcept )); + typedef any_bidirectional_iterator_interface< + Reference, + Buffer + > base_type; + public: + typedef typename base_type::reference reference; + any_bidirectional_iterator_wrapper() : m_it() { @@ -353,9 +384,9 @@ namespace boost return m_it == boost::polymorphic_downcast(&other)->m_it; } - virtual Reference dereference() const + virtual reference dereference() const { - return *m_it; + return dereference_cast(*m_it); } private: @@ -376,7 +407,14 @@ namespace boost > { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessIteratorConcept )); + typedef any_random_access_iterator_interface< + Reference, + Difference, + Buffer + > base_type; + public: + typedef typename base_type::reference reference; typedef Difference difference_type; any_random_access_iterator_wrapper() @@ -457,9 +495,9 @@ namespace boost m_it += offset; } - virtual Reference dereference() const + virtual reference dereference() const { - return *m_it; + return dereference_cast(*m_it); } virtual Difference distance_to(const any_random_access_iterator_interface& other) const diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index a3693dc..801fec6 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -476,6 +476,60 @@ namespace boost_range_adaptor_type_erased_test BOOST_CHECK_EQUAL( rng[i], i ); } } + + class dummy_interface + { + public: + virtual ~dummy_interface() { } + virtual void test() = 0; + protected: + dummy_interface() { } + private: + dummy_interface(const dummy_interface&); + void operator=(const dummy_interface&); + }; + + class dummy_impl + : public dummy_interface + { + public: + dummy_impl() { } + dummy_impl(const dummy_impl&) { } + dummy_impl& operator=(const dummy_impl&) { return *this; } + virtual void test() { } + }; + + typedef boost::any_range< + dummy_interface, + boost::random_access_traversal_tag, + dummy_interface&, + std::ptrdiff_t + > any_interface_range; + + struct foo_dummy_interface_fn + { + void operator()(dummy_interface& iface) + { + iface.test(); + } + }; + + void foo_test_dummy_interface_range(any_interface_range rng) + { + std::for_each(boost::begin(rng), boost::end(rng), + foo_dummy_interface_fn()); + } + + void test_type_erased_abstract() + { + std::vector v(10); + + any_interface_range r(v); + + foo_test_dummy_interface_range(r); + + foo_test_dummy_interface_range(any_interface_range(v)); + } } boost::unit_test::test_suite* @@ -492,6 +546,7 @@ init_unit_test_suite(int argc, char* argv[]) test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_multiple_different_template_parameter_conversion ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_mix_values ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_operator_brackets ) ); + test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_abstract ) ); return test; } From 8b60f2c768521226bf9fe0bb6edcd0e2919f2702 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sun, 2 Mar 2014 22:50:24 +0000 Subject: [PATCH 37/60] iterator_range interop with variant. --- include/boost/range/iterator_range_core.hpp | 28 +++- include/boost/range/sub_range.hpp | 147 ++++++++------------ test/Jamfile.v2 | 1 + test/iterator_range_variant.cpp | 60 ++++++++ 4 files changed, 144 insertions(+), 92 deletions(-) create mode 100644 test/iterator_range_variant.cpp diff --git a/include/boost/range/iterator_range_core.hpp b/include/boost/range/iterator_range_core.hpp index 1e63b7e..59a7b8c 100644 --- a/include/boost/range/iterator_range_core.hpp +++ b/include/boost/range/iterator_range_core.hpp @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -380,6 +381,19 @@ public: BOOST_DEDUCED_TYPENAME iterator_traversal::type > base_type; + template + struct is_compatible_range + : is_convertible< + BOOST_DEDUCED_TYPENAME mpl::eval_if< + has_range_iterator, + range_iterator, + mpl::identity + >::type, + BOOST_DEDUCED_TYPENAME base_type::iterator + > + { + }; + protected: typedef iterator_range_detail::iterator_range_impl impl; @@ -397,13 +411,23 @@ public: } template - iterator_range(const SinglePassRange& r) + iterator_range( + const SinglePassRange& r, + BOOST_DEDUCED_TYPENAME enable_if< + is_compatible_range + >::type* = 0 + ) : base_type(impl::adl_begin(r), impl::adl_end(r)) { } template - iterator_range(SinglePassRange& r) + iterator_range( + SinglePassRange& r, + BOOST_DEDUCED_TYPENAME enable_if< + is_compatible_range + >::type* = 0 + ) : base_type(impl::adl_begin(r), impl::adl_end(r)) { } diff --git a/include/boost/range/sub_range.hpp b/include/boost/range/sub_range.hpp index 0b00086..69b13a9 100644 --- a/include/boost/range/sub_range.hpp +++ b/include/boost/range/sub_range.hpp @@ -31,14 +31,18 @@ namespace boost { - + template< class ForwardRange > - class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator::type > + class sub_range + : public iterator_range< + BOOST_DEDUCED_TYPENAME range_iterator::type + > { typedef BOOST_DEDUCED_TYPENAME range_iterator::type iterator_t; typedef iterator_range< iterator_t > base; typedef BOOST_DEDUCED_TYPENAME base::impl impl; + public: typedef BOOST_DEDUCED_TYPENAME range_value::type value_type; typedef BOOST_DEDUCED_TYPENAME range_iterator::type iterator; @@ -46,17 +50,25 @@ namespace boost typedef BOOST_DEDUCED_TYPENAME range_difference::type difference_type; typedef BOOST_DEDUCED_TYPENAME range_size::type size_type; typedef BOOST_DEDUCED_TYPENAME base::reference reference; - - public: // for return value of front/back - typedef BOOST_DEDUCED_TYPENAME - boost::mpl::if_< boost::is_reference, - const BOOST_DEDUCED_TYPENAME boost::remove_reference::type&, - reference >::type const_reference; + + private: + template + struct is_compatible_range + : is_convertible< + BOOST_DEDUCED_TYPENAME mpl::eval_if< + has_range_iterator, + range_iterator, + mpl::identity + >::type, + iterator + > + { + }; public: - sub_range() : base() + sub_range() { } - + #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) ) sub_range( const sub_range& r ) : base( static_cast( r ) ) @@ -64,39 +76,57 @@ namespace boost #endif template< class ForwardRange2 > - sub_range( ForwardRange2& r ) : - -#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 ) - base( impl::adl_begin( r ), impl::adl_end( r ) ) -#else - base( r ) -#endif - { } - - template< class ForwardRange2 > - sub_range( const ForwardRange2& r ) : + sub_range( + ForwardRange2& r, + BOOST_DEDUCED_TYPENAME enable_if< + is_compatible_range + >::type* = 0 + ) : #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 ) base( impl::adl_begin( r ), impl::adl_end( r ) ) #else base( r ) -#endif +#endif + { } + + template< class ForwardRange2 > + sub_range( + const ForwardRange2& r, + BOOST_DEDUCED_TYPENAME enable_if< + is_compatible_range + >::type* = 0 + ) : + +#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 ) + base( impl::adl_begin( r ), impl::adl_end( r ) ) +#else + base( r ) +#endif { } template< class Iter > sub_range( Iter first, Iter last ) : base( first, last ) { } - - template< class ForwardRange2 > - sub_range& operator=( ForwardRange2& r ) + + template + BOOST_DEDUCED_TYPENAME enable_if< + is_compatible_range, + sub_range& + >::type + operator=(ForwardRange2& r) { base::operator=( r ); return *this; } - template< class ForwardRange2 > - sub_range& operator=( const ForwardRange2& r ) + template + BOOST_DEDUCED_TYPENAME enable_if< + is_compatible_range, + sub_range& + >::type + operator=( const ForwardRange2& r ) { base::operator=( r ); return *this; @@ -107,71 +137,8 @@ namespace boost base::operator=( static_cast(r) ); return *this; } - - public: - - iterator begin() { return base::begin(); } - const_iterator begin() const { return base::begin(); } - iterator end() { return base::end(); } - const_iterator end() const { return base::end(); } - difference_type size() const { return base::size(); } - - - public: // convenience - reference front() - { - return base::front(); - } - - const_reference front() const - { - return base::front(); - } - - reference back() - { - return base::back(); - } - - const_reference back() const - { - return base::back(); - } - - reference operator[]( difference_type sz ) - { - return base::operator[](sz); - } - - const_reference operator[]( difference_type sz ) const - { - return base::operator[](sz); - } - }; - template< class ForwardRange, class ForwardRange2 > - inline bool operator==( const sub_range& l, - const sub_range& r ) - { - return boost::equal( l, r ); - } - - template< class ForwardRange, class ForwardRange2 > - inline bool operator!=( const sub_range& l, - const sub_range& r ) - { - return !boost::equal( l, r ); - } - - template< class ForwardRange, class ForwardRange2 > - inline bool operator<( const sub_range& l, - const sub_range& r ) - { - return iterator_range_detail::less_than( l, r ); - } - - } // namespace 'boost' #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index ef3d0cd..3c57250 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -150,6 +150,7 @@ test-suite range : [ range-test istream_range ] [ range-test iterator_pair ] [ range-test iterator_range ] + [ range-test iterator_range_variant ] # [ range-test mfc : $(VC71_ROOT)/atlmfc/include ] [ range-test join ] [ range-test partial_workaround ] diff --git a/test/iterator_range_variant.cpp b/test/iterator_range_variant.cpp new file mode 100644 index 0000000..d55ae85 --- /dev/null +++ b/test/iterator_range_variant.cpp @@ -0,0 +1,60 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace +{ + enum E + { + e1, e2, e3 + }; + + void test_variant_report() + { + typedef boost::mpl::vector< + E, + std::string, + boost::iterator_range + >::type args; + + typedef boost::make_variant_over::type variant_t; + + variant_t v; + std::string s; + v = boost::iterator_range(s.begin(), s.end()); + v = e2; + v = std::string(); + + // Rationale: + // This is cast to const char* to guard against ambiguity in the case + // where std::string::iterator it a char* + v = static_cast(""); + } +} + +boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE("iterator range and variant interoperability"); + + test->add(BOOST_TEST_CASE(&test_variant_report)); + + return test; +} From 63acc5c633c648d51a4b6cf62b35a4fc86b97563 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 00:10:08 +0000 Subject: [PATCH 38/60] trac 8676 sliced adaptor fixed. --- include/boost/range/adaptor/sliced.hpp | 3 +- include/boost/range/iterator_range_core.hpp | 3 - test/Jamfile.v2 | 1 + .../ticket_8676_sliced_transformed.cpp | 56 +++++++++++++++++++ 4 files changed, 59 insertions(+), 4 deletions(-) create mode 100644 test/adaptor_test/ticket_8676_sliced_transformed.cpp diff --git a/include/boost/range/adaptor/sliced.hpp b/include/boost/range/adaptor/sliced.hpp index 14ad986..b88597d 100755 --- a/include/boost/range/adaptor/sliced.hpp +++ b/include/boost/range/adaptor/sliced.hpp @@ -34,7 +34,8 @@ namespace boost public: template sliced_range(Rng& rng, T t, U u) - : base_t(boost::make_iterator_range(rng, t, u - boost::size(rng))) + : base_t(boost::next(boost::begin(rng), t), + boost::next(boost::begin(rng), u)) { } }; diff --git a/include/boost/range/iterator_range_core.hpp b/include/boost/range/iterator_range_core.hpp index 59a7b8c..7bbae2a 100644 --- a/include/boost/range/iterator_range_core.hpp +++ b/include/boost/range/iterator_range_core.hpp @@ -708,7 +708,6 @@ public: BOOST_DEDUCED_TYPENAME range_difference::type advance_begin, BOOST_DEDUCED_TYPENAME range_difference::type advance_end ) { - //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" ); return iterator_range_detail::make_range_impl( r, advance_begin, advance_end ); } @@ -720,7 +719,6 @@ public: BOOST_DEDUCED_TYPENAME range_difference::type advance_begin, BOOST_DEDUCED_TYPENAME range_difference::type advance_end ) { - //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" ); return iterator_range_detail::make_range_impl( r, advance_begin, advance_end ); } @@ -730,7 +728,6 @@ public: BOOST_DEDUCED_TYPENAME range_difference::type advance_begin, BOOST_DEDUCED_TYPENAME range_difference::type advance_end ) { - //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" ); return iterator_range_detail::make_range_impl( r, advance_begin, advance_end ); } diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 3c57250..97b3d6d 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -44,6 +44,7 @@ test-suite range : [ range-test adaptor_test/sliced ] [ range-test adaptor_test/strided ] [ range-test adaptor_test/strided2 ] + [ range-test adaptor_test/ticket_8676_sliced_transformed ] [ range-test adaptor_test/ticket_9519_strided_reversed ] [ range-test adaptor_test/tokenized ] [ range-test adaptor_test/transformed ] diff --git a/test/adaptor_test/ticket_8676_sliced_transformed.cpp b/test/adaptor_test/ticket_8676_sliced_transformed.cpp new file mode 100644 index 0000000..da0125e --- /dev/null +++ b/test/adaptor_test/ticket_8676_sliced_transformed.cpp @@ -0,0 +1,56 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// +// For more information, see http://www.boost.org/libs/range/ +// +#include +#include +#include +#include +#include +#include + +namespace +{ + struct identity + { + typedef int result_type; + result_type operator()(int i) const { return i; } + }; + + void sliced_and_transformed() + { + using namespace boost::adaptors; + + std::vector input; + for (int i = 0; i < 10; ++i) + input.push_back(i); + + std::vector out1; + boost::push_back(out1, input | sliced(2, 8) + | transformed(identity())); + + std::vector out2; + boost::push_back(out2, input | transformed(identity()) + | sliced(2, 8)); + + BOOST_CHECK_EQUAL_COLLECTIONS(out1.begin(), out1.end(), + out2.begin(), out2.end()); + } +} // anonymous namespace + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test + = BOOST_TEST_SUITE( "Range adaptors - sliced and transformed" ); + + test->add(BOOST_TEST_CASE(&sliced_and_transformed)); + + return test; +} From 132828a8db4eeab08c4c58f2162d93bbdafd9593 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 00:26:22 +0000 Subject: [PATCH 39/60] make msvc happy with the ticket 6715 test case. --- test/ticket_6715_iterator_range_equality.cpp | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/test/ticket_6715_iterator_range_equality.cpp b/test/ticket_6715_iterator_range_equality.cpp index 0ca1d42..96a61a9 100644 --- a/test/ticket_6715_iterator_range_equality.cpp +++ b/test/ticket_6715_iterator_range_equality.cpp @@ -12,6 +12,7 @@ #include #include +#include namespace boost { @@ -19,12 +20,18 @@ namespace boost { class str_ref : public boost::iterator_range { + public: + explicit str_ref(const std::string& str) + : boost::iterator_range( + str.c_str(), str.c_str() + str.size()) + { + } }; - + void test_ticket_6715_iterator_range_equality() { - str_ref a; - str_ref b; + str_ref a("test"); + str_ref b("test"); BOOST_CHECK(a == b); } } From d87e1f3adef0efc10e56e457482d38edcd814179 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 00:30:11 +0000 Subject: [PATCH 40/60] make intel happy with type_erased static_assert calls. --- test/adaptor_test/type_erased.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index 801fec6..ad5d600 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -453,21 +453,21 @@ namespace boost_range_adaptor_type_erased_test typedef boost::any_range_type_generator< std::vector >::type any_range_type; - BOOST_STATIC_ASSERT( + BOOST_STATIC_ASSERT(( boost::is_same< int, boost::range_value::type >::value - ); + )); - BOOST_STATIC_ASSERT( + BOOST_STATIC_ASSERT(( boost::is_same< boost::random_access_traversal_tag, boost::iterator_traversal< boost::range_iterator::type >::type >::value - ); + )); any_range_type rng = c | type_erased_t(); From 17c0fa271c6926a4aa67254686c9559208ac040a Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 01:24:56 +0000 Subject: [PATCH 41/60] trac 9515 - fix for uniqued adaptor consistent with unique algorithm. --- .../boost/range/adaptor/adjacent_filtered.hpp | 58 ++++++-------- test/adaptor_test/uniqued.cpp | 79 +++++++++++++++++++ 2 files changed, 103 insertions(+), 34 deletions(-) diff --git a/include/boost/range/adaptor/adjacent_filtered.hpp b/include/boost/range/adaptor/adjacent_filtered.hpp index f717cb3..159d8ee 100644 --- a/include/boost/range/adaptor/adjacent_filtered.hpp +++ b/include/boost/range/adaptor/adjacent_filtered.hpp @@ -62,54 +62,44 @@ namespace boost , pred_t(pred) , m_last(last) { - move_to_next_valid(); } template skip_iterator( const skip_iterator& other ) : base_t(other.base()) , pred_t(other) - , m_last(other.m_last) {} - - void move_to_next_valid() + , m_last(other.m_last) { - iter_t& it = this->base_reference(); - pred_t& bi_pred = *this; - if (it != m_last) - { - if (default_pass) - { - iter_t nxt = ::boost::next(it); - while (nxt != m_last && !bi_pred(*it, *nxt)) - { - ++it; - ++nxt; - } - } - else - { - iter_t nxt = ::boost::next(it); - for(; nxt != m_last; ++it, ++nxt) - { - if (bi_pred(*it, *nxt)) - { - break; - } - } - if (nxt == m_last) - { - it = m_last; - } - } - } } void increment() { iter_t& it = this->base_reference(); BOOST_ASSERT( it != m_last ); + pred_t& bi_pred = *this; + iter_t prev = it; ++it; - move_to_next_valid(); + if (it != m_last) + { + if (default_pass) + { + while (it != m_last && !bi_pred(*prev, *it)) + { + ++it; + ++prev; + } + } + else + { + for (; it != m_last; ++it, ++prev) + { + if (bi_pred(*prev, *it)) + { + break; + } + } + } + } } iter_t m_last; diff --git a/test/adaptor_test/uniqued.cpp b/test/adaptor_test/uniqued.cpp index 9c96744..fdf5454 100644 --- a/test/adaptor_test/uniqued.cpp +++ b/test/adaptor_test/uniqued.cpp @@ -9,6 +9,10 @@ // For more information, see http://www.boost.org/libs/range/ // #include +#include +#include +#include +#include #include #include @@ -74,9 +78,82 @@ namespace boost uniqued_test_impl< std::set< int > >(); uniqued_test_impl< std::multiset< int > >(); } + +class istring +{ +public: + istring() + : m_value("") + { } + + explicit istring(const char* value) + : m_value(value) + { + } + + bool operator==(istring r) const + { + return boost::iequals(m_value, r.m_value); + } + + bool operator!=(istring r) const + { + return !operator==(r); + } + + inline friend std::ostream& operator<<(std::ostream& out, istring o) + { + return out << o.m_value; + } + + const char* get() const { return m_value; } + +private: + const char* m_value; +}; + +struct istring_to_string +{ + typedef std::string result_type; + + std::string operator()(istring s) const + { + return s.get(); + } +}; + +// This is based on a test-case provided by Eric Neibler. +void uniqued_return_first() +{ + using namespace boost::adaptors; + + std::vector strs; + strs.push_back(istring("hello")); + strs.push_back(istring("hElLo")); + strs.push_back(istring("HELLO")); + strs.push_back(istring("ZZZZ")); + + std::vector output1; + + boost::unique_copy(strs, std::back_inserter(output1)); + + std::vector output2; + boost::push_back(output2, strs | uniqued); + + std::vector test1; + boost::push_back(test1, output1 | transformed(istring_to_string())); + + std::vector test2; + boost::push_back(test2, output2 | transformed(istring_to_string())); + + BOOST_CHECK_EQUAL_COLLECTIONS(test1.begin(), test1.end(), + test2.begin(), test2.end()); } + } // anonymous namespace +} // namespace boost + boost::unit_test::test_suite* init_unit_test_suite(int argc, char* argv[]) { @@ -85,5 +162,7 @@ init_unit_test_suite(int argc, char* argv[]) test->add( BOOST_TEST_CASE( &boost::uniqued_test ) ); + test->add(BOOST_TEST_CASE(&boost::uniqued_return_first)); + return test; } From 4cb056c80be1b376cc26dd60bf0818292c9db0a0 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 12:30:23 +0000 Subject: [PATCH 42/60] ticket 5811 - attempt to fix link error on many automated regression test hosts. --- test/ticket_5811_indirected_optional.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/test/ticket_5811_indirected_optional.cpp b/test/ticket_5811_indirected_optional.cpp index 8b4033b..1279a4a 100644 --- a/test/ticket_5811_indirected_optional.cpp +++ b/test/ticket_5811_indirected_optional.cpp @@ -10,6 +10,7 @@ // #include #include +#include #include #include From 42a7f0c70cab2d35731b717dd76983df52e25d37 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 14:21:35 +0000 Subject: [PATCH 43/60] trac 6742 - unit test showing working phoenix combined with the transformed adaptor. --- test/Jamfile.v2 | 275 +++++++++--------- .../ticket_6742_transformed_c4789_warning.cpp | 69 +++++ 2 files changed, 207 insertions(+), 137 deletions(-) create mode 100644 test/adaptor_test/ticket_6742_transformed_c4789_warning.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 97b3d6d..09a29d5 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -13,12 +13,12 @@ import testing ; project - : requirements - /boost/test//boost_unit_test_framework/ - /boost/regex//boost_regex/ - static - multi - ; + : requirements + /boost/test//boost_unit_test_framework/ + /boost/regex//boost_regex/ + static + multi + ; rule range-test ( name : includes * ) { @@ -31,141 +31,142 @@ rule range-test ( name : includes * ) } test-suite range : - [ compile-fail compile_fail/iterator_range1.cpp ] - [ range-test adaptor_test/adjacent_filtered ] - [ range-test adaptor_test/copied ] - [ range-test adaptor_test/filtered ] - [ range-test adaptor_test/indexed ] - [ range-test adaptor_test/indirected ] - [ range-test adaptor_test/map ] - [ range-test adaptor_test/replaced ] - [ range-test adaptor_test/replaced_if ] - [ range-test adaptor_test/reversed ] - [ range-test adaptor_test/sliced ] - [ range-test adaptor_test/strided ] - [ range-test adaptor_test/strided2 ] + [ compile-fail compile_fail/iterator_range1.cpp ] + [ range-test adaptor_test/adjacent_filtered ] + [ range-test adaptor_test/copied ] + [ range-test adaptor_test/filtered ] + [ range-test adaptor_test/indexed ] + [ range-test adaptor_test/indirected ] + [ range-test adaptor_test/map ] + [ range-test adaptor_test/replaced ] + [ range-test adaptor_test/replaced_if ] + [ range-test adaptor_test/reversed ] + [ range-test adaptor_test/sliced ] + [ range-test adaptor_test/strided ] + [ range-test adaptor_test/strided2 ] + [ range-test adaptor_test/ticket_6742_transformed_c4789_warning ] [ range-test adaptor_test/ticket_8676_sliced_transformed ] - [ range-test adaptor_test/ticket_9519_strided_reversed ] - [ range-test adaptor_test/tokenized ] - [ range-test adaptor_test/transformed ] - [ range-test adaptor_test/type_erased ] - [ range-test adaptor_test/uniqued ] - [ range-test adaptor_test/adjacent_filtered_example ] - [ range-test adaptor_test/copied_example ] - [ range-test adaptor_test/filtered_example ] - [ range-test adaptor_test/indexed_example ] - [ range-test adaptor_test/indirected_example ] - [ range-test adaptor_test/map_keys_example ] - [ range-test adaptor_test/map_values_example ] - [ range-test adaptor_test/replaced_example ] - [ range-test adaptor_test/replaced_if_example ] - [ range-test adaptor_test/reversed_example ] - [ range-test adaptor_test/sliced_example ] - [ range-test adaptor_test/strided_example ] - [ range-test adaptor_test/transformed_example ] - [ range-test adaptor_test/tokenized_example ] - [ range-test adaptor_test/type_erased_example ] - [ range-test adaptor_test/uniqued_example ] - [ range-test algorithm_test/adjacent_find ] - [ range-test algorithm_test/binary_search ] - [ range-test algorithm_test/copy ] - [ range-test algorithm_test/copy_backward ] - [ range-test algorithm_test/count ] - [ range-test algorithm_test/count_if ] - [ range-test algorithm_test/equal ] - [ range-test algorithm_test/equal_range ] - [ range-test algorithm_test/fill ] - [ range-test algorithm_test/find ] - [ range-test algorithm_test/find_if ] - [ range-test algorithm_test/find_end ] - [ range-test algorithm_test/find_first_of ] - [ range-test algorithm_test/for_each ] - [ range-test algorithm_test/generate ] - [ range-test algorithm_test/heap ] - [ range-test algorithm_test/includes ] - [ range-test algorithm_test/inplace_merge ] - [ range-test algorithm_test/lexicographical_compare ] - [ range-test algorithm_test/lower_bound ] - [ range-test algorithm_test/max_element ] - [ range-test algorithm_test/merge ] - [ range-test algorithm_test/min_element ] - [ range-test algorithm_test/mismatch ] - [ range-test algorithm_test/next_permutation ] - [ range-test algorithm_test/nth_element ] - [ range-test algorithm_test/partial_sort ] - [ range-test algorithm_test/partition ] - [ range-test algorithm_test/prev_permutation ] - [ range-test algorithm_test/random_shuffle ] - [ range-test algorithm_test/remove ] - [ range-test algorithm_test/remove_copy ] - [ range-test algorithm_test/remove_copy_if ] - [ range-test algorithm_test/remove_if ] - [ range-test algorithm_test/replace ] - [ range-test algorithm_test/replace_copy ] - [ range-test algorithm_test/replace_copy_if ] - [ range-test algorithm_test/replace_if ] - [ range-test algorithm_test/reverse ] - [ range-test algorithm_test/reverse_copy ] - [ range-test algorithm_test/rotate ] - [ range-test algorithm_test/rotate_copy ] - [ range-test algorithm_test/search ] - [ range-test algorithm_test/search_n ] - [ range-test algorithm_test/set_difference ] - [ range-test algorithm_test/set_intersection ] - [ range-test algorithm_test/set_symmetric_difference ] - [ range-test algorithm_test/set_union ] - [ range-test algorithm_test/sort ] - [ range-test algorithm_test/stable_partition ] - [ range-test algorithm_test/stable_sort ] - [ range-test algorithm_test/swap_ranges ] - [ range-test algorithm_test/transform ] - [ range-test algorithm_test/unique ] - [ range-test algorithm_test/unique_copy ] - [ range-test algorithm_test/upper_bound ] - [ range-test algorithm_ext_test/copy_n ] - [ range-test algorithm_ext_test/erase ] - [ range-test algorithm_ext_test/for_each_ext ] - [ range-test algorithm_ext_test/insert ] - [ range-test algorithm_ext_test/iota ] - [ range-test algorithm_ext_test/is_sorted ] - [ range-test algorithm_ext_test/overwrite ] - [ range-test algorithm_ext_test/push_back ] - [ range-test algorithm_ext_test/push_front ] - [ range-test adl_conformance ] - [ range-test adl_conformance_no_using ] - [ range-test algorithm ] - [ range-test algorithm_example ] - [ range-test array ] -# [ range-test atl : $(VC71_ROOT)/atlmfc/include ] + [ range-test adaptor_test/ticket_9519_strided_reversed ] + [ range-test adaptor_test/tokenized ] + [ range-test adaptor_test/transformed ] + [ range-test adaptor_test/type_erased ] + [ range-test adaptor_test/uniqued ] + [ range-test adaptor_test/adjacent_filtered_example ] + [ range-test adaptor_test/copied_example ] + [ range-test adaptor_test/filtered_example ] + [ range-test adaptor_test/indexed_example ] + [ range-test adaptor_test/indirected_example ] + [ range-test adaptor_test/map_keys_example ] + [ range-test adaptor_test/map_values_example ] + [ range-test adaptor_test/replaced_example ] + [ range-test adaptor_test/replaced_if_example ] + [ range-test adaptor_test/reversed_example ] + [ range-test adaptor_test/sliced_example ] + [ range-test adaptor_test/strided_example ] + [ range-test adaptor_test/transformed_example ] + [ range-test adaptor_test/tokenized_example ] + [ range-test adaptor_test/type_erased_example ] + [ range-test adaptor_test/uniqued_example ] + [ range-test algorithm_test/adjacent_find ] + [ range-test algorithm_test/binary_search ] + [ range-test algorithm_test/copy ] + [ range-test algorithm_test/copy_backward ] + [ range-test algorithm_test/count ] + [ range-test algorithm_test/count_if ] + [ range-test algorithm_test/equal ] + [ range-test algorithm_test/equal_range ] + [ range-test algorithm_test/fill ] + [ range-test algorithm_test/find ] + [ range-test algorithm_test/find_if ] + [ range-test algorithm_test/find_end ] + [ range-test algorithm_test/find_first_of ] + [ range-test algorithm_test/for_each ] + [ range-test algorithm_test/generate ] + [ range-test algorithm_test/heap ] + [ range-test algorithm_test/includes ] + [ range-test algorithm_test/inplace_merge ] + [ range-test algorithm_test/lexicographical_compare ] + [ range-test algorithm_test/lower_bound ] + [ range-test algorithm_test/max_element ] + [ range-test algorithm_test/merge ] + [ range-test algorithm_test/min_element ] + [ range-test algorithm_test/mismatch ] + [ range-test algorithm_test/next_permutation ] + [ range-test algorithm_test/nth_element ] + [ range-test algorithm_test/partial_sort ] + [ range-test algorithm_test/partition ] + [ range-test algorithm_test/prev_permutation ] + [ range-test algorithm_test/random_shuffle ] + [ range-test algorithm_test/remove ] + [ range-test algorithm_test/remove_copy ] + [ range-test algorithm_test/remove_copy_if ] + [ range-test algorithm_test/remove_if ] + [ range-test algorithm_test/replace ] + [ range-test algorithm_test/replace_copy ] + [ range-test algorithm_test/replace_copy_if ] + [ range-test algorithm_test/replace_if ] + [ range-test algorithm_test/reverse ] + [ range-test algorithm_test/reverse_copy ] + [ range-test algorithm_test/rotate ] + [ range-test algorithm_test/rotate_copy ] + [ range-test algorithm_test/search ] + [ range-test algorithm_test/search_n ] + [ range-test algorithm_test/set_difference ] + [ range-test algorithm_test/set_intersection ] + [ range-test algorithm_test/set_symmetric_difference ] + [ range-test algorithm_test/set_union ] + [ range-test algorithm_test/sort ] + [ range-test algorithm_test/stable_partition ] + [ range-test algorithm_test/stable_sort ] + [ range-test algorithm_test/swap_ranges ] + [ range-test algorithm_test/transform ] + [ range-test algorithm_test/unique ] + [ range-test algorithm_test/unique_copy ] + [ range-test algorithm_test/upper_bound ] + [ range-test algorithm_ext_test/copy_n ] + [ range-test algorithm_ext_test/erase ] + [ range-test algorithm_ext_test/for_each_ext ] + [ range-test algorithm_ext_test/insert ] + [ range-test algorithm_ext_test/iota ] + [ range-test algorithm_ext_test/is_sorted ] + [ range-test algorithm_ext_test/overwrite ] + [ range-test algorithm_ext_test/push_back ] + [ range-test algorithm_ext_test/push_front ] + [ range-test adl_conformance ] + [ range-test adl_conformance_no_using ] + [ range-test algorithm ] + [ range-test algorithm_example ] + [ range-test array ] +# [ range-test atl : $(VC71_ROOT)/atlmfc/include ] [ range-test begin ] - [ range-test combine ] - [ range-test compat2 ] - [ range-test compat3 ] - [ range-test const_ranges ] - [ range-test counting_range ] - [ range-test end ] - [ range-test extension_mechanism ] - [ range-test extension_size ] - [ range-test has_range_iterator ] - [ range-test irange ] - [ range-test istream_range ] - [ range-test iterator_pair ] - [ range-test iterator_range ] - [ range-test iterator_range_variant ] -# [ range-test mfc : $(VC71_ROOT)/atlmfc/include ] + [ range-test combine ] + [ range-test compat2 ] + [ range-test compat3 ] + [ range-test const_ranges ] + [ range-test counting_range ] + [ range-test end ] + [ range-test extension_mechanism ] + [ range-test extension_size ] + [ range-test has_range_iterator ] + [ range-test irange ] + [ range-test istream_range ] + [ range-test iterator_pair ] + [ range-test iterator_range ] + [ range-test iterator_range_variant ] +# [ range-test mfc : $(VC71_ROOT)/atlmfc/include ] [ range-test join ] - [ range-test partial_workaround ] - [ range-test pointer_as_iterator ] - [ range-test reversible_range ] - [ range-test std_container ] - [ range-test string ] - [ range-test sub_range ] - [ range-test ticket_5486 ] - [ range-test ticket_5544_terminate_irange ] - [ range-test ticket_5547 ] - [ range-test ticket_5556_is_sorted_namespace ] + [ range-test partial_workaround ] + [ range-test pointer_as_iterator ] + [ range-test reversible_range ] + [ range-test std_container ] + [ range-test string ] + [ range-test sub_range ] + [ range-test ticket_5486 ] + [ range-test ticket_5544_terminate_irange ] + [ range-test ticket_5547 ] + [ range-test ticket_5556_is_sorted_namespace ] [ range-test ticket_5811_indirected_optional ] [ range-test ticket_6715_iterator_range_equality ] - [ range-test ticket_6944 ] + [ range-test ticket_6944 ] ; diff --git a/test/adaptor_test/ticket_6742_transformed_c4789_warning.cpp b/test/adaptor_test/ticket_6742_transformed_c4789_warning.cpp new file mode 100644 index 0000000..fdd7118 --- /dev/null +++ b/test/adaptor_test/ticket_6742_transformed_c4789_warning.cpp @@ -0,0 +1,69 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// +// For more information, see http://www.boost.org/libs/range/ +// +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace +{ + struct test_struct + { + double x; + double y; + }; + + struct get_x + { + typedef double result_type; + double operator()(const test_struct& s) const + { + return s.x; + } + }; + + void range_transformed_warning() + { + using namespace boost::phoenix::arg_names; + using namespace boost::adaptors; + + test_struct t; + t.x = 2.0; + t.y = -4.0; + std::vector v(10u, t); + + std::vector output1; + boost::push_back(output1, v | transformed((&arg1)->*& test_struct::x)); + + std::vector output2; + boost::push_back(output2, v | transformed(get_x())); + + BOOST_CHECK_EQUAL_COLLECTIONS( + output1.begin(), output1.end(), + output2.begin(), output2.end()); + } +} // anonymous namespace + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test + = BOOST_TEST_SUITE( "Range adaptors - transformed warning" ); + + test->add(BOOST_TEST_CASE(&range_transformed_warning)); + + return test; +} From ea6ca22e3f38a6710f6a6f126bd71585852e28fb Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 15:00:42 +0000 Subject: [PATCH 44/60] trac 7188 c4127 warning in the equal function. --- include/boost/range/algorithm/equal.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/boost/range/algorithm/equal.hpp b/include/boost/range/algorithm/equal.hpp index 36d768f..2b44f3b 100644 --- a/include/boost/range/algorithm/equal.hpp +++ b/include/boost/range/algorithm/equal.hpp @@ -31,7 +31,7 @@ namespace boost IteratorCategoryTag1, IteratorCategoryTag2 ) { - while (true) + for (;;) { // If we have reached the end of the left range then this is // the end of the loop. They are equal if and only if we have @@ -71,7 +71,7 @@ namespace boost IteratorCategoryTag1, IteratorCategoryTag2 ) { - while (true) + for (;;) { // If we have reached the end of the left range then this is // the end of the loop. They are equal if and only if we have From c9b96f2c882cee26f0b327e52888b8c9edc9a090 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 15:43:05 +0000 Subject: [PATCH 45/60] trac 7376 - join iterator reference type. --- include/boost/range/detail/join_iterator.hpp | 3 + test/join.cpp | 106 +++++++++++++++++++ 2 files changed, 109 insertions(+) diff --git a/include/boost/range/detail/join_iterator.hpp b/include/boost/range/detail/join_iterator.hpp index ea0dd20..1020ebf 100644 --- a/include/boost/range/detail/join_iterator.hpp +++ b/include/boost/range/detail/join_iterator.hpp @@ -9,6 +9,9 @@ // aschoedl contributed an improvement to the determination // of the Reference type parameter. // +// Leonid Gershanovich reported Trac ticket 7376 about the dereference operator +// requiring identical reference types due to using the ternary if. +// // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_DETAIL_JOIN_ITERATOR_HPP_INCLUDED diff --git a/test/join.cpp b/test/join.cpp index cff3f35..586f05c 100644 --- a/test/join.cpp +++ b/test/join.cpp @@ -8,7 +8,12 @@ // // For more information, see http://www.boost.org/libs/range/ // +// Credits: +// Trac 7376 - was raised by Leonid Gershanovich and his sample was used to +// make the test case to cover this condition. +// #include +#include #include #include @@ -274,6 +279,106 @@ namespace boost boost::push_back(joined, join(v1, v2)); } + namespace trac7376 + { + struct base_type + { + explicit base_type(boost::int32_t value) + : value(value) + { + } + + virtual boost::int32_t get() const = 0; + + boost::int32_t value; + }; + + struct derived_type1 + : base_type + { + derived_type1(boost::int32_t value) + : base_type(value) + { + } + + virtual boost::int32_t get() const + { + return value * 2; + } + }; + + struct derived_type2 + : base_type + { + derived_type2(boost::int32_t value) + : base_type(value) + { + } + + virtual boost::int32_t get() const + { + return value * 4; + } + }; + + struct apply_get + { + typedef boost::int32_t result_type; + result_type operator()(const base_type& arg) const + { + return arg.get(); + } + }; + + void test_reference_types() + { + using namespace boost::adaptors; + + typedef boost::range_detail::join_iterator< + std::vector::iterator, + std::vector::iterator, + const base_type&, + const base_type& + > join_iterator_t; + + std::vector reference_output; + + std::vector x; + for (boost::int32_t i = 0; i < 10; ++i) + { + x.push_back(derived_type1(i)); + reference_output.push_back(i * 2); + } + + std::vector y; + for (boost::int32_t i = 0; i < 10; ++i) + { + y.push_back(derived_type2(i)); + reference_output.push_back(i * 4); + } + + join_iterator_t it( + x, + y, + boost::range_detail::join_iterator_begin_tag()); + + std::vector output; + boost::push_back( + output, + boost::make_iterator_range( + join_iterator_t( + x, y, + boost::range_detail::join_iterator_begin_tag()), + join_iterator_t( + x, y, + boost::range_detail::join_iterator_end_tag())) + | transformed(apply_get())); + + BOOST_CHECK_EQUAL_COLLECTIONS( + output.begin(), output.end(), + reference_output.begin(), reference_output.end()); + } + } // namespace trac7376 } } @@ -285,6 +390,7 @@ init_unit_test_suite(int argc, char* argv[]) test->add( BOOST_TEST_CASE( &boost::join_test ) ); test->add( BOOST_TEST_CASE( &boost::test_join_iterator_reference_type_constness_ticket8483 ) ); + test->add( BOOST_TEST_CASE( &boost::trac7376::test_reference_types ) ); return test; } From b3180d3a5a615a084346064b26644c6bd7d2759f Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 18:30:13 +0000 Subject: [PATCH 46/60] trac 9514 - adjacent_filtered requires a ForwardRange. --- doc/reference/adaptors/adjacent_filtered.qbk | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/reference/adaptors/adjacent_filtered.qbk b/doc/reference/adaptors/adjacent_filtered.qbk index f8b4289..312646c 100644 --- a/doc/reference/adaptors/adjacent_filtered.qbk +++ b/doc/reference/adaptors/adjacent_filtered.qbk @@ -14,8 +14,8 @@ * [*Precondition:] The `value_type` of the range is convertible to both argument types of `bi_pred`. * [*Postcondition:] For all adjacent elements `[x,y]` in the returned range, `bi_pred(x,y)` is `true`. * [*Throws:] Whatever the copy constructor of `bi_pred` might throw. -* [*Range Category:] __single_pass_range__ -* [*Return Type:] `boost::adjacent_filtered_range` +* [*Range Category:] __forward_range__ +* [*Return Type:] `boost::adjacent_filtered_range` * [*Returned Range Category:] The minimum of the range category of `rng` and __forward_range__ [section:adjacent_filtered_example adjacent_filtered example] From ef388661b3f976bd35c10c3af30524d4e44ffe09 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 18:36:01 +0000 Subject: [PATCH 47/60] trac 8927 - added comment about std::partition requirements pre C++11. --- doc/reference/algorithm/partition.qbk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/reference/algorithm/partition.qbk b/doc/reference/algorithm/partition.qbk index 8ae28e5..a97a893 100644 --- a/doc/reference/algorithm/partition.qbk +++ b/doc/reference/algorithm/partition.qbk @@ -50,7 +50,7 @@ Defined in the header file `boost/range/algorithm/partition.hpp` [heading Requirements] -* `ForwardRange` is a model of the __forward_range__ Concept. +* `ForwardRange` is a model of the __forward_range__ Concept. For C++ versions prior to C++11 the underlying std::partition requires Bidirectional Iterators, hence the requirement for older library versions is for a __bidirectional_range__. * `UnaryPredicate` is a model of the `PredicateConcept`. * `ForwardRange`'s value type is convertible to `UnaryPredicate`'s argument type. From c9a04a1a9a1b80a747f59e2952a80fe8faa61a99 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Mon, 3 Mar 2014 18:58:33 +0000 Subject: [PATCH 48/60] trac 7842 - documentation inaccuracies on intro page for range adaptors. --- doc/reference/adaptors.qbk | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/doc/reference/adaptors.qbk b/doc/reference/adaptors.qbk index 96f2ca3..b3efaee 100644 --- a/doc/reference/adaptors.qbk +++ b/doc/reference/adaptors.qbk @@ -69,7 +69,7 @@ What should we do if we only want to copy an element `a` if it satisfies some pr * `boost::copy_if( rng, pred, out )` * `boost::count_if( rng, pred )` -These algorithms are only defined to maintain a one to one relationship with the standard library algorithms. This approach of adding algorithm suffers a combinatorial explosion. Inevitably many algorithms are missing `_if` variants and there is redundant development overhead for each new algorithm. The Adaptor Generator is the design solution to this problem. +These algorithms are only defined to maintain a one to one relationship with the standard library algorithms. This approach of adding algorithm suffers a combinatorial explosion. Inevitably many algorithms are missing `_if` variants and there is redundant development overhead for each new algorithm. The Adaptor Generator is the design solution to this problem. It is conceivable that some algorithms are capable of optimization by tightly coupling the filter with the algorithm. The adaptors provide a more general solution with superior separation of orthogonal concerns. [heading Range Adaptor alternative to copy_if algorithm] `` @@ -86,10 +86,10 @@ boost::count_if( rng, pred ); `` can be expressed as `` -boost::count( rng | boost::adaptors::filtered(pred), out ); +boost::size( rng | boost::adaptors::filtered(pred) ); `` -What this means is that ['*no*] algorithm with the `_if` suffix is needed. Furthermore, it turns out that algorithms with the `_copy` suffix are not needed either. Consider the somewhat misdesigned `replace_copy_if()` which may be used as +What this means is that many algorithms no longer require nor benefit from an optimized implementation with an `_if` suffix. Furthermore, it turns out that algorithms with the `_copy` suffix are often not needed either. Consider `replace_copy_if()` which may be used as `` std::vector vec; @@ -116,7 +116,7 @@ boost::push_back(vec, rng | boost::adaptors::replaced_if(pred, new_value) In this manner, the ['*composition*] of Range Adaptors has the following consequences: -1. we no longer need `_if`, `_copy`, `_copy_if` and `_n` variants of algorithms. +1. we no longer need many of the `_if`, `_copy`, `_copy_if` and `_n` variants of algorithms. 2. we can generate a multitude of new algorithms on the fly, for example, above we generated `reverse_replace_copy_if()` From 43ab929257c19da924c2d12aeb0b5818db14e18e Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:18:46 +0000 Subject: [PATCH 49/60] type_erased abstract and brackets tests separated. --- test/Jamfile.v2 | 2 + test/adaptor_test/type_erased.cpp | 361 +-------------------- test/adaptor_test/type_erased_abstract.cpp | 93 ++++++ test/adaptor_test/type_erased_brackets.cpp | 75 +++++ test/adaptor_test/type_erased_test.hpp | 289 +++++++++++++++++ 5 files changed, 461 insertions(+), 359 deletions(-) create mode 100644 test/adaptor_test/type_erased_abstract.cpp create mode 100644 test/adaptor_test/type_erased_brackets.cpp create mode 100644 test/adaptor_test/type_erased_test.hpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 09a29d5..9a8a5e0 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -50,6 +50,8 @@ test-suite range : [ range-test adaptor_test/tokenized ] [ range-test adaptor_test/transformed ] [ range-test adaptor_test/type_erased ] + [ range-test adaptor_test/type_erased_abstract ] + [ range-test adaptor_test/type_erased_brackets ] [ range-test adaptor_test/uniqued ] [ range-test adaptor_test/adjacent_filtered_example ] [ range-test adaptor_test/copied_example ] diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index ad5d600..80bed09 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -6,14 +6,13 @@ // http://www.boost.org/LICENSE_1_0.txt) // #include +#include "type_erased_test.hpp" -#include #include #include #include #include -#include #include #include @@ -24,96 +23,6 @@ namespace boost_range_adaptor_type_erased_test { - class MockType - { - public: - MockType() - : m_x(0) - { - } - - MockType(boost::int32_t x) - : m_x(x) - { - } - - boost::int32_t get() const { return m_x; } - - inline bool operator==(const MockType& other) const - { - return m_x == other.m_x; - } - - inline bool operator!=(const MockType& other) const - { - return m_x != other.m_x; - } - - private: - boost::int32_t m_x; - }; - - class MockType2 : public MockType - { - public: - MockType2() {} - MockType2(boost::int32_t x) : MockType(x) { } - MockType2(const MockType& other) : MockType(other) { } - }; - - inline std::ostream& operator<<(std::ostream& out, const MockType& obj) - { - out << obj.get(); - return out; - } - - template - void test_type_erased_impl(Container& c) - { - using namespace boost::adaptors; - typedef typename boost::range_value::type value_type; - typedef typename boost::adaptors::type_erased<> type_erased_t; - - - std::vector output; - - boost::push_back(output, boost::adaptors::type_erase(c, type_erased_t())); - - BOOST_CHECK_EQUAL_COLLECTIONS( output.begin(), output.end(), - c.begin(), c.end() ); - - output.clear(); - boost::push_back(output, c | type_erased_t()); - - BOOST_CHECK_EQUAL_COLLECTIONS( output.begin(), output.end(), - c.begin(), c.end() ); - } - - template - void test_const_and_mutable(Container& c) - { - test_type_erased_impl(c); - - const Container& const_c = c; - test_type_erased_impl(const_c); - } - - template - void test_driver() - { - using namespace boost::assign; - - typedef typename boost::range_value::type value_type; - - Container c; - test_const_and_mutable(c); - - c += value_type(1); - test_const_and_mutable(c); - - c += value_type(2); - test_const_and_mutable(c); - } void test_type_erased() { @@ -124,183 +33,6 @@ namespace boost_range_adaptor_type_erased_test test_driver< std::vector >(); } - template< - class Traversal - , class Container - > - void test_writeable(Container&, boost::single_pass_traversal_tag) - {} - - template< - class Traversal - , class Container - > - void test_writeable(Container& source, boost::forward_traversal_tag) - { - using namespace boost::adaptors; - - typedef typename boost::range_value::type value_type; - typedef typename boost::range_difference::type difference_type; - typedef typename boost::range_reference::type mutable_reference_type; - typedef boost::any_range< - value_type - , Traversal - , mutable_reference_type - , difference_type - > mutable_any_range; - - mutable_any_range r = source | boost::adaptors::type_erased<>(); - std::vector output_test; - boost::fill(r, value_type(1)); - BOOST_CHECK_EQUAL( boost::distance(r), boost::distance(source) ); - std::vector reference_output(source.size(), value_type(1)); - BOOST_CHECK_EQUAL_COLLECTIONS( reference_output.begin(), reference_output.end(), - r.begin(), r.end() ); - - } - - template< - class Container - , class Traversal - , class Buffer - > - void test_type_erased_impl() - { - using namespace boost::adaptors; - - typedef typename boost::range_value::type value_type; - - typedef typename boost::any_range_type_generator< - Container - , boost::use_default - , Traversal - , boost::use_default - , boost::use_default - , Buffer - >::type mutable_any_range; - - typedef typename boost::any_range_type_generator< - const Container - , boost::use_default - , Traversal - , boost::use_default - , boost::use_default - , Buffer - >::type const_any_range; - - typedef boost::adaptors::type_erased< - boost::use_default - , Traversal - , boost::use_default - , boost::use_default - , Buffer - > type_erased_t; - - Container source; - for (int i = 0; i < 10; ++i) - source.push_back(value_type(i)); - - mutable_any_range r(source); - BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), - r.begin(), r.end() ); - - r = mutable_any_range(); - BOOST_CHECK_EQUAL( r.empty(), true ); - - r = source | type_erased_t(); - BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), - r.begin(), r.end() ); - r = mutable_any_range(); - - r = boost::adaptors::type_erase(source, type_erased_t()); - BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), - r.begin(), r.end() ); - r = mutable_any_range(); - - test_writeable(source, Traversal()); - - // convert and construct a const any_range from a mutable source - // range - const_any_range cr(source); - BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), - cr.begin(), cr.end() ); - // assign an empty range and ensure that this correctly results - // in an empty range. This is important for the validity of - // the rest of the tests. - cr = const_any_range(); - BOOST_CHECK_EQUAL( cr.empty(), true ); - - // Test the pipe type_erased adaptor from a constant source - // range to a constant any_range - const Container& const_source = source; - cr = const_any_range(); - cr = const_source | type_erased_t(); - BOOST_CHECK_EQUAL_COLLECTIONS( const_source.begin(), const_source.end(), - cr.begin(), cr.end() ); - - // Test the pipe type erased adaptor from a mutable source - // range to a constant any_range - cr = const_any_range(); - cr = source | type_erased_t(); - BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), - cr.begin(), cr.end() ); - - // Use the function form of the type_erase adaptor from a constant - // source range - cr = const_any_range(); - cr = boost::adaptors::type_erase(const_source, type_erased_t()); - BOOST_CHECK_EQUAL_COLLECTIONS( const_source.begin(), const_source.end(), - cr.begin(), cr.end() ); - - // Assignment from mutable to const... - cr = const_any_range(); - cr = r; - BOOST_CHECK_EQUAL_COLLECTIONS( cr.begin(), cr.end(), - r.begin(), r.end() ); - - // Converting copy from mutable to const... - cr = const_any_range(); - cr = const_any_range(r); - BOOST_CHECK_EQUAL_COLLECTIONS( cr.begin(), cr.end(), - r.begin(), r.end() ); - } - - template< - class Container - , class Traversal - , class Buffer - > - class test_type_erased_impl_fn - { - public: - typedef void result_type; - void operator()() - { - test_type_erased_impl< Container, Traversal, Buffer >(); - } - }; - - template< - class Container - , class Traversal - > - void test_type_erased_exercise_buffer_types() - { - using boost::any_iterator_default_buffer; - using boost::any_iterator_buffer; - using boost::any_iterator_heap_only_buffer; - using boost::any_iterator_stack_only_buffer; - - test_type_erased_impl_fn< Container, Traversal, any_iterator_default_buffer >()(); - test_type_erased_impl_fn< Container, Traversal, any_iterator_heap_only_buffer >()(); - test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<1> >()(); - test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<2> >()(); - test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<32> >()(); - test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<64> >()(); - test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<128> >()(); - test_type_erased_impl_fn< Container, Traversal, any_iterator_stack_only_buffer<128> >()(); - } - void test_type_erased_single_pass() { test_type_erased_exercise_buffer_types< std::list, boost::single_pass_traversal_tag >(); @@ -442,94 +174,6 @@ namespace boost_range_adaptor_type_erased_test test_type_erased_mix_values_driver< boost::random_access_traversal_tag >(); } - void test_type_erased_operator_brackets() - { - typedef boost::adaptors::type_erased<> type_erased_t; - - std::vector c; - for (int i = 0; i < 10; ++i) - c.push_back(i); - - typedef boost::any_range_type_generator< - std::vector >::type any_range_type; - - BOOST_STATIC_ASSERT(( - boost::is_same< - int, - boost::range_value::type - >::value - )); - - BOOST_STATIC_ASSERT(( - boost::is_same< - boost::random_access_traversal_tag, - boost::iterator_traversal< - boost::range_iterator::type - >::type - >::value - )); - - any_range_type rng = c | type_erased_t(); - - for (int i = 0; i < 10; ++i) - { - BOOST_CHECK_EQUAL( rng[i], i ); - } - } - - class dummy_interface - { - public: - virtual ~dummy_interface() { } - virtual void test() = 0; - protected: - dummy_interface() { } - private: - dummy_interface(const dummy_interface&); - void operator=(const dummy_interface&); - }; - - class dummy_impl - : public dummy_interface - { - public: - dummy_impl() { } - dummy_impl(const dummy_impl&) { } - dummy_impl& operator=(const dummy_impl&) { return *this; } - virtual void test() { } - }; - - typedef boost::any_range< - dummy_interface, - boost::random_access_traversal_tag, - dummy_interface&, - std::ptrdiff_t - > any_interface_range; - - struct foo_dummy_interface_fn - { - void operator()(dummy_interface& iface) - { - iface.test(); - } - }; - - void foo_test_dummy_interface_range(any_interface_range rng) - { - std::for_each(boost::begin(rng), boost::end(rng), - foo_dummy_interface_fn()); - } - - void test_type_erased_abstract() - { - std::vector v(10); - - any_interface_range r(v); - - foo_test_dummy_interface_range(r); - - foo_test_dummy_interface_range(any_interface_range(v)); - } } boost::unit_test::test_suite* @@ -545,8 +189,7 @@ init_unit_test_suite(int argc, char* argv[]) test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_random_access ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_multiple_different_template_parameter_conversion ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_mix_values ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_operator_brackets ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_abstract ) ); return test; } + diff --git a/test/adaptor_test/type_erased_abstract.cpp b/test/adaptor_test/type_erased_abstract.cpp new file mode 100644 index 0000000..3f3263e --- /dev/null +++ b/test/adaptor_test/type_erased_abstract.cpp @@ -0,0 +1,93 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include +#include + +#include +#include +#include + +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { +class dummy_interface +{ +public: + virtual ~dummy_interface() { } + virtual void test() = 0; +protected: + dummy_interface() { } +private: + dummy_interface(const dummy_interface&); + void operator=(const dummy_interface&); +}; + +class dummy_impl + : public dummy_interface +{ +public: + dummy_impl() { } + dummy_impl(const dummy_impl&) { } + dummy_impl& operator=(const dummy_impl&) { return *this; } + virtual void test() { } +}; + +typedef boost::any_range< + dummy_interface, + boost::random_access_traversal_tag, + dummy_interface&, + std::ptrdiff_t +> any_interface_range; + +struct foo_dummy_interface_fn +{ + void operator()(dummy_interface& iface) + { + iface.test(); + } +}; + +void foo_test_dummy_interface_range(any_interface_range rng) +{ + std::for_each(boost::begin(rng), boost::end(rng), + foo_dummy_interface_fn()); +} + +void test_type_erased_abstract() +{ + std::vector v(10); + + any_interface_range r(v); + + foo_test_dummy_interface_range(r); + + foo_test_dummy_interface_range(any_interface_range(v)); +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test + = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased_abstract" ); + + test->add( + BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::test_type_erased_abstract)); + + return test; +} diff --git a/test/adaptor_test/type_erased_brackets.cpp b/test/adaptor_test/type_erased_brackets.cpp new file mode 100644 index 0000000..95e61ec --- /dev/null +++ b/test/adaptor_test/type_erased_brackets.cpp @@ -0,0 +1,75 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include + +#include +#include +#include + +#include +#include +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { + +void test_type_erased_operator_brackets() +{ + typedef boost::adaptors::type_erased<> type_erased_t; + + std::vector c; + for (int i = 0; i < 10; ++i) + c.push_back(i); + + typedef boost::any_range_type_generator< + std::vector >::type any_range_type; + + BOOST_STATIC_ASSERT(( + boost::is_same< + int, + boost::range_value::type + >::value + )); + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::random_access_traversal_tag, + boost::iterator_traversal< + boost::range_iterator::type + >::type + >::value + )); + + any_range_type rng = c | type_erased_t(); + + for (int i = 0; i < 10; ++i) + { + BOOST_CHECK_EQUAL( rng[i], i ); + } +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test + = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased" ); + + test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_operator_brackets ) ); + + return test; +} + diff --git a/test/adaptor_test/type_erased_test.hpp b/test/adaptor_test/type_erased_test.hpp new file mode 100644 index 0000000..9a42e81 --- /dev/null +++ b/test/adaptor_test/type_erased_test.hpp @@ -0,0 +1,289 @@ +// Boost.Range library +// +// Copyright Neil Groves 2010. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#ifndef BOOST_RANGE_ADAPTOR_TEST_TYPE_ERASED_TEST_HPP +#define BOOST_RANGE_ADAPTOR_TEST_TYPE_ERASED_TEST_HPP + +#include +#include +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + +class MockType +{ +public: + MockType() + : m_x(0) + { + } + + MockType(boost::int32_t x) + : m_x(x) + { + } + + boost::int32_t get() const { return m_x; } + + inline bool operator==(const MockType& other) const + { + return m_x == other.m_x; + } + + inline bool operator!=(const MockType& other) const + { + return m_x != other.m_x; + } + +private: + boost::int32_t m_x; +}; + +class MockType2 : public MockType +{ +public: + MockType2() {} + MockType2(boost::int32_t x) : MockType(x) { } + MockType2(const MockType& other) : MockType(other) { } +}; + +inline std::ostream& operator<<(std::ostream& out, const MockType& obj) +{ + out << obj.get(); + return out; +} + +template +void test_type_erased_impl(Container& c) +{ + using namespace boost::adaptors; + typedef typename boost::range_value::type value_type; + typedef typename boost::adaptors::type_erased<> type_erased_t; + + + std::vector output; + + boost::push_back(output, boost::adaptors::type_erase(c, type_erased_t())); + + BOOST_CHECK_EQUAL_COLLECTIONS( output.begin(), output.end(), + c.begin(), c.end() ); + + output.clear(); + boost::push_back(output, c | type_erased_t()); + + BOOST_CHECK_EQUAL_COLLECTIONS( output.begin(), output.end(), + c.begin(), c.end() ); +} + +template +void test_const_and_mutable(Container& c) +{ + test_type_erased_impl(c); + + const Container& const_c = c; + test_type_erased_impl(const_c); +} + +template +void test_driver() +{ + using namespace boost::assign; + + typedef typename boost::range_value::type value_type; + + Container c; + test_const_and_mutable(c); + + c += value_type(1); + test_const_and_mutable(c); + + c += value_type(2); + test_const_and_mutable(c); +} + +template< + class Traversal + , class Container +> +void test_writeable(Container&, boost::single_pass_traversal_tag) +{} + +template< + class Traversal + , class Container +> +void test_writeable(Container& source, boost::forward_traversal_tag) +{ + using namespace boost::adaptors; + + typedef typename boost::range_value::type value_type; + typedef typename boost::range_difference::type difference_type; + typedef typename boost::range_reference::type mutable_reference_type; + typedef boost::any_range< + value_type + , Traversal + , mutable_reference_type + , difference_type + > mutable_any_range; + + mutable_any_range r = source | boost::adaptors::type_erased<>(); + std::vector output_test; + boost::fill(r, value_type(1)); + BOOST_CHECK_EQUAL( boost::distance(r), boost::distance(source) ); + std::vector reference_output(source.size(), value_type(1)); + BOOST_CHECK_EQUAL_COLLECTIONS( reference_output.begin(), reference_output.end(), + r.begin(), r.end() ); + +} + +template< + class Container + , class Traversal + , class Buffer +> +void test_type_erased_impl() +{ + using namespace boost::adaptors; + + typedef typename boost::range_value::type value_type; + + typedef typename boost::any_range_type_generator< + Container + , boost::use_default + , Traversal + , boost::use_default + , boost::use_default + , Buffer + >::type mutable_any_range; + + typedef typename boost::any_range_type_generator< + const Container + , boost::use_default + , Traversal + , boost::use_default + , boost::use_default + , Buffer + >::type const_any_range; + + typedef boost::adaptors::type_erased< + boost::use_default + , Traversal + , boost::use_default + , boost::use_default + , Buffer + > type_erased_t; + + Container source; + for (int i = 0; i < 10; ++i) + source.push_back(value_type(i)); + + mutable_any_range r(source); + BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), + r.begin(), r.end() ); + + r = mutable_any_range(); + BOOST_CHECK_EQUAL( r.empty(), true ); + + r = source | type_erased_t(); + BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), + r.begin(), r.end() ); + r = mutable_any_range(); + + r = boost::adaptors::type_erase(source, type_erased_t()); + BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), + r.begin(), r.end() ); + r = mutable_any_range(); + + test_writeable(source, Traversal()); + + // convert and construct a const any_range from a mutable source + // range + const_any_range cr(source); + BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), + cr.begin(), cr.end() ); + // assign an empty range and ensure that this correctly results + // in an empty range. This is important for the validity of + // the rest of the tests. + cr = const_any_range(); + BOOST_CHECK_EQUAL( cr.empty(), true ); + + // Test the pipe type_erased adaptor from a constant source + // range to a constant any_range + const Container& const_source = source; + cr = const_any_range(); + cr = const_source | type_erased_t(); + BOOST_CHECK_EQUAL_COLLECTIONS( const_source.begin(), const_source.end(), + cr.begin(), cr.end() ); + + // Test the pipe type erased adaptor from a mutable source + // range to a constant any_range + cr = const_any_range(); + cr = source | type_erased_t(); + BOOST_CHECK_EQUAL_COLLECTIONS( source.begin(), source.end(), + cr.begin(), cr.end() ); + + // Use the function form of the type_erase adaptor from a constant + // source range + cr = const_any_range(); + cr = boost::adaptors::type_erase(const_source, type_erased_t()); + BOOST_CHECK_EQUAL_COLLECTIONS( const_source.begin(), const_source.end(), + cr.begin(), cr.end() ); + + // Assignment from mutable to const... + cr = const_any_range(); + cr = r; + BOOST_CHECK_EQUAL_COLLECTIONS( cr.begin(), cr.end(), + r.begin(), r.end() ); + + // Converting copy from mutable to const... + cr = const_any_range(); + cr = const_any_range(r); + BOOST_CHECK_EQUAL_COLLECTIONS( cr.begin(), cr.end(), + r.begin(), r.end() ); +} + +template< + class Container + , class Traversal + , class Buffer +> +class test_type_erased_impl_fn +{ +public: + typedef void result_type; + void operator()() + { + test_type_erased_impl< Container, Traversal, Buffer >(); + } +}; + +template< + class Container + , class Traversal +> +void test_type_erased_exercise_buffer_types() +{ + using boost::any_iterator_default_buffer; + using boost::any_iterator_buffer; + using boost::any_iterator_heap_only_buffer; + using boost::any_iterator_stack_only_buffer; + + test_type_erased_impl_fn< Container, Traversal, any_iterator_default_buffer >()(); + test_type_erased_impl_fn< Container, Traversal, any_iterator_heap_only_buffer >()(); + test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<1> >()(); + test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<2> >()(); + test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<32> >()(); + test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<64> >()(); + test_type_erased_impl_fn< Container, Traversal, any_iterator_buffer<128> >()(); + test_type_erased_impl_fn< Container, Traversal, any_iterator_stack_only_buffer<128> >()(); +} + +} // namespace boost_range_adaptor_type_erased_test + +#endif // include guard From 8de7e29fc711fd873b35a1679a0b68151ec0ca73 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:26:50 +0000 Subject: [PATCH 50/60] type_erased mix of values test separated. --- test/Jamfile.v2 | 1 + test/adaptor_test/type_erased.cpp | 281 +++++++++---------- test/adaptor_test/type_erased_mix_values.cpp | 101 +++++++ 3 files changed, 234 insertions(+), 149 deletions(-) create mode 100644 test/adaptor_test/type_erased_mix_values.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 9a8a5e0..82b152b 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -52,6 +52,7 @@ test-suite range : [ range-test adaptor_test/type_erased ] [ range-test adaptor_test/type_erased_abstract ] [ range-test adaptor_test/type_erased_brackets ] + [ range-test adaptor_test/type_erased_mix_values ] [ range-test adaptor_test/uniqued ] [ range-test adaptor_test/adjacent_filtered_example ] [ range-test adaptor_test/copied_example ] diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index 80bed09..3163998 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -23,159 +23,143 @@ namespace boost_range_adaptor_type_erased_test { - - void test_type_erased() + namespace { - test_driver< std::list >(); - test_driver< std::vector >(); - test_driver< std::list >(); - test_driver< std::vector >(); - } - - void test_type_erased_single_pass() - { - test_type_erased_exercise_buffer_types< std::list, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::single_pass_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::list, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::single_pass_traversal_tag >(); - } - - void test_type_erased_forward() - { - test_type_erased_exercise_buffer_types< std::list, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::forward_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::list, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::forward_traversal_tag >(); - } - - void test_type_erased_bidirectional() - { - test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); - } - - void test_type_erased_random_access() - { - test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::random_access_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::random_access_traversal_tag >(); - } - - void test_type_erased_multiple_different_template_parameter_conversion() - { - typedef boost::any_range< - int - , boost::random_access_traversal_tag - , int& - , std::ptrdiff_t - > source_range_type; - - typedef boost::any_range< - int - , boost::single_pass_traversal_tag - , const int& - , std::ptrdiff_t - > target_range_type; - - source_range_type source; - - // Converting via construction - target_range_type t1(source); - - // Converting via assignment - target_range_type t2; - t2 = source; - - // Converting via construction to a type with a reference type - // that is a value - typedef boost::any_range< - int - , boost::single_pass_traversal_tag - , int - , std::ptrdiff_t - > target_range2_type; - - target_range2_type t3(source); - target_range2_type t4; - t4 = source; - } - - template< - class Traversal - , class ValueType - , class SourceValueType - , class SourceReference - , class TargetValueType - , class TargetReference - > - void test_type_erased_mix_values_impl() - { - typedef std::vector< ValueType > Container; - - typedef typename boost::any_range_type_generator< - Container - , SourceValueType - , Traversal - , SourceReference - >::type source_type; - - typedef typename boost::any_range_type_generator< - Container - , TargetValueType - , Traversal - , TargetReference - >::type target_type; - - Container test_data; - for (int i = 0; i < 10; ++i) - test_data.push_back(i); - - const source_type source_data(test_data); - target_type t1(source_data); - BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), - t1.begin(), t1.end() ); - - target_type t2; - t2 = source_data; - BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), - t2.begin(), t2.end() ); - } - - template - void test_type_erased_mix_values_driver() - { - test_type_erased_mix_values_impl< - Traversal, - MockType, - MockType2, const MockType&, - MockType, const MockType& - >(); - } - - void test_type_erased_mix_values() - { - test_type_erased_mix_values_driver< boost::single_pass_traversal_tag >(); - test_type_erased_mix_values_driver< boost::forward_traversal_tag >(); - test_type_erased_mix_values_driver< boost::bidirectional_traversal_tag >(); - test_type_erased_mix_values_driver< boost::random_access_traversal_tag >(); - } +void test_type_erased() +{ + test_driver< std::list >(); + test_driver< std::vector >(); + test_driver< std::list >(); + test_driver< std::vector >(); } +void test_type_erased_single_pass() +{ + test_type_erased_exercise_buffer_types< std::list, boost::single_pass_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::single_pass_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::single_pass_traversal_tag >(); + + test_type_erased_exercise_buffer_types< std::list, boost::single_pass_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::single_pass_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::single_pass_traversal_tag >(); +} + +void test_type_erased_forward() +{ + test_type_erased_exercise_buffer_types< std::list, boost::forward_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::forward_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::forward_traversal_tag >(); + + test_type_erased_exercise_buffer_types< std::list, boost::forward_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::forward_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::forward_traversal_tag >(); +} + +void test_type_erased_bidirectional() +{ + test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); + + test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); +} + +void test_type_erased_random_access() +{ + test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::random_access_traversal_tag >(); + + test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::random_access_traversal_tag >(); +} + +void test_type_erased_multiple_different_template_parameter_conversion() +{ + typedef boost::any_range< + int + , boost::random_access_traversal_tag + , int& + , std::ptrdiff_t + > source_range_type; + + typedef boost::any_range< + int + , boost::single_pass_traversal_tag + , const int& + , std::ptrdiff_t + > target_range_type; + + source_range_type source; + + // Converting via construction + target_range_type t1(source); + + // Converting via assignment + target_range_type t2; + t2 = source; + + // Converting via construction to a type with a reference type + // that is a value + typedef boost::any_range< + int + , boost::single_pass_traversal_tag + , int + , std::ptrdiff_t + > target_range2_type; + + target_range2_type t3(source); + target_range2_type t4; + t4 = source; +} + +template< + class Traversal + , class ValueType + , class SourceValueType + , class SourceReference + , class TargetValueType + , class TargetReference +> +void test_type_erased_mix_values_impl() +{ + typedef std::vector< ValueType > Container; + + typedef typename boost::any_range_type_generator< + Container + , SourceValueType + , Traversal + , SourceReference + >::type source_type; + + typedef typename boost::any_range_type_generator< + Container + , TargetValueType + , Traversal + , TargetReference + >::type target_type; + + Container test_data; + for (int i = 0; i < 10; ++i) + test_data.push_back(i); + + const source_type source_data(test_data); + target_type t1(source_data); + BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), + t1.begin(), t1.end() ); + + target_type t2; + t2 = source_data; + BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), + t2.begin(), t2.end() ); +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + boost::unit_test::test_suite* init_unit_test_suite(int argc, char* argv[]) { @@ -188,7 +172,6 @@ init_unit_test_suite(int argc, char* argv[]) test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_bidirectional ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_random_access ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_multiple_different_template_parameter_conversion ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_mix_values ) ); return test; } diff --git a/test/adaptor_test/type_erased_mix_values.cpp b/test/adaptor_test/type_erased_mix_values.cpp new file mode 100644 index 0000000..ae5fe84 --- /dev/null +++ b/test/adaptor_test/type_erased_mix_values.cpp @@ -0,0 +1,101 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include + +#include +#include +#include + +#include +#include +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { + +template< + class Traversal + , class ValueType + , class SourceValueType + , class SourceReference + , class TargetValueType + , class TargetReference +> +void mix_values_impl() +{ + typedef std::vector< ValueType > Container; + + typedef typename boost::any_range_type_generator< + Container + , SourceValueType + , Traversal + , SourceReference + >::type source_type; + + typedef typename boost::any_range_type_generator< + Container + , TargetValueType + , Traversal + , TargetReference + >::type target_type; + + Container test_data; + for (int i = 0; i < 10; ++i) + test_data.push_back(i); + + const source_type source_data(test_data); + target_type t1(source_data); + BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), + t1.begin(), t1.end() ); + + target_type t2; + t2 = source_data; + BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), + t2.begin(), t2.end() ); +} + +template +void mix_values_driver() +{ + mix_values_impl< + Traversal, + MockType, + MockType2, const MockType&, + MockType, const MockType& + >(); +} + +void mix_values() +{ + mix_values_driver< boost::single_pass_traversal_tag >(); + mix_values_driver< boost::forward_traversal_tag >(); + mix_values_driver< boost::bidirectional_traversal_tag >(); + mix_values_driver< boost::random_access_traversal_tag >(); +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_mix_values"); + + test->add(BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::mix_values)); + + return test; +} + From b5f60f04486ac2e22440b00668c8a49519b9a135 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:28:22 +0000 Subject: [PATCH 51/60] removed obsolete test code from type_erased.cpp. --- test/adaptor_test/type_erased.cpp | 41 ------------------------------- 1 file changed, 41 deletions(-) diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index 3163998..f2e8a97 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -116,47 +116,6 @@ void test_type_erased_multiple_different_template_parameter_conversion() t4 = source; } -template< - class Traversal - , class ValueType - , class SourceValueType - , class SourceReference - , class TargetValueType - , class TargetReference -> -void test_type_erased_mix_values_impl() -{ - typedef std::vector< ValueType > Container; - - typedef typename boost::any_range_type_generator< - Container - , SourceValueType - , Traversal - , SourceReference - >::type source_type; - - typedef typename boost::any_range_type_generator< - Container - , TargetValueType - , Traversal - , TargetReference - >::type target_type; - - Container test_data; - for (int i = 0; i < 10; ++i) - test_data.push_back(i); - - const source_type source_data(test_data); - target_type t1(source_data); - BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), - t1.begin(), t1.end() ); - - target_type t2; - t2 = source_data; - BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), - t2.begin(), t2.end() ); -} - } // anonymous namespace } // namespace boost_range_adaptor_type_erased_test From c96897198a4170cb37f9de73785b3567a96b0f0f Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:34:36 +0000 Subject: [PATCH 52/60] type_erased test separated the template parameter conversion test. --- test/Jamfile.v2 | 1 + test/adaptor_test/type_erased.cpp | 40 ---------- test/adaptor_test/type_erased_tparam_conv.cpp | 78 +++++++++++++++++++ 3 files changed, 79 insertions(+), 40 deletions(-) create mode 100644 test/adaptor_test/type_erased_tparam_conv.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 82b152b..c110885 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -53,6 +53,7 @@ test-suite range : [ range-test adaptor_test/type_erased_abstract ] [ range-test adaptor_test/type_erased_brackets ] [ range-test adaptor_test/type_erased_mix_values ] + [ range-test adaptor_test/type_erased_tparam_conv ] [ range-test adaptor_test/uniqued ] [ range-test adaptor_test/adjacent_filtered_example ] [ range-test adaptor_test/copied_example ] diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index f2e8a97..239b592 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -77,45 +77,6 @@ void test_type_erased_random_access() test_type_erased_exercise_buffer_types< std::vector, boost::random_access_traversal_tag >(); } -void test_type_erased_multiple_different_template_parameter_conversion() -{ - typedef boost::any_range< - int - , boost::random_access_traversal_tag - , int& - , std::ptrdiff_t - > source_range_type; - - typedef boost::any_range< - int - , boost::single_pass_traversal_tag - , const int& - , std::ptrdiff_t - > target_range_type; - - source_range_type source; - - // Converting via construction - target_range_type t1(source); - - // Converting via assignment - target_range_type t2; - t2 = source; - - // Converting via construction to a type with a reference type - // that is a value - typedef boost::any_range< - int - , boost::single_pass_traversal_tag - , int - , std::ptrdiff_t - > target_range2_type; - - target_range2_type t3(source); - target_range2_type t4; - t4 = source; -} - } // anonymous namespace } // namespace boost_range_adaptor_type_erased_test @@ -130,7 +91,6 @@ init_unit_test_suite(int argc, char* argv[]) test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_forward ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_bidirectional ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_random_access ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_multiple_different_template_parameter_conversion ) ); return test; } diff --git a/test/adaptor_test/type_erased_tparam_conv.cpp b/test/adaptor_test/type_erased_tparam_conv.cpp new file mode 100644 index 0000000..4342f99 --- /dev/null +++ b/test/adaptor_test/type_erased_tparam_conv.cpp @@ -0,0 +1,78 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include + +#include +#include +#include + +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { + +void template_parameter_conversion() +{ + typedef boost::any_range< + int + , boost::random_access_traversal_tag + , int& + , std::ptrdiff_t + > source_range_type; + + typedef boost::any_range< + int + , boost::single_pass_traversal_tag + , const int& + , std::ptrdiff_t + > target_range_type; + + source_range_type source; + + // Converting via construction + target_range_type t1(source); + + // Converting via assignment + target_range_type t2; + t2 = source; + + // Converting via construction to a type with a reference type + // that is a value + typedef boost::any_range< + int + , boost::single_pass_traversal_tag + , int + , std::ptrdiff_t + > target_range2_type; + + target_range2_type t3(source); + target_range2_type t4; + t4 = source; +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_tparam_conv"); + + test->add(BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::template_parameter_conversion)); + + return test; +} + From 438e735dcce70baef2acf300789f24aa5f5bf87b Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:41:19 +0000 Subject: [PATCH 53/60] type_erased split out single-pass. --- test/Jamfile.v2 | 1 + test/adaptor_test/type_erased.cpp | 12 ---- test/adaptor_test/type_erased_single_pass.cpp | 62 +++++++++++++++++++ 3 files changed, 63 insertions(+), 12 deletions(-) create mode 100644 test/adaptor_test/type_erased_single_pass.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index c110885..1e817c7 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -54,6 +54,7 @@ test-suite range : [ range-test adaptor_test/type_erased_brackets ] [ range-test adaptor_test/type_erased_mix_values ] [ range-test adaptor_test/type_erased_tparam_conv ] + [ range-test adaptor_test/type_erased_single_pass ] [ range-test adaptor_test/uniqued ] [ range-test adaptor_test/adjacent_filtered_example ] [ range-test adaptor_test/copied_example ] diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index 239b592..f95ed68 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -35,17 +35,6 @@ void test_type_erased() test_driver< std::vector >(); } -void test_type_erased_single_pass() -{ - test_type_erased_exercise_buffer_types< std::list, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::single_pass_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::list, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::single_pass_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::single_pass_traversal_tag >(); -} - void test_type_erased_forward() { test_type_erased_exercise_buffer_types< std::list, boost::forward_traversal_tag >(); @@ -87,7 +76,6 @@ init_unit_test_suite(int argc, char* argv[]) = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased" ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_single_pass ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_forward ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_bidirectional ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_random_access ) ); diff --git a/test/adaptor_test/type_erased_single_pass.cpp b/test/adaptor_test/type_erased_single_pass.cpp new file mode 100644 index 0000000..8ae2fe1 --- /dev/null +++ b/test/adaptor_test/type_erased_single_pass.cpp @@ -0,0 +1,62 @@ +// Boost.Range library +// +// Copyright Neil Groves 2010. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include + +#include +#include +#include + +#include +#include +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { + +void test_single_pass() +{ + test_type_erased_exercise_buffer_types< + std::list, boost::single_pass_traversal_tag>(); + + test_type_erased_exercise_buffer_types< + std::deque, boost::single_pass_traversal_tag>(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::single_pass_traversal_tag>(); + + test_type_erased_exercise_buffer_types< + std::list, boost::single_pass_traversal_tag>(); + + test_type_erased_exercise_buffer_types< + std::deque, boost::single_pass_traversal_tag>(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::single_pass_traversal_tag>(); +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_single_pass"); + + test->add(BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::test_single_pass)); + + return test; +} + From 379fbc51e3f182609a27d26800c91adab77c05df Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:46:57 +0000 Subject: [PATCH 54/60] type_erased unit test separated bidirectional traversal. --- test/Jamfile.v2 | 1 + test/adaptor_test/type_erased.cpp | 16 +----- .../type_erased_bidirectional.cpp | 52 +++++++++++++++++++ 3 files changed, 54 insertions(+), 15 deletions(-) create mode 100644 test/adaptor_test/type_erased_bidirectional.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 1e817c7..a0c10e0 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -55,6 +55,7 @@ test-suite range : [ range-test adaptor_test/type_erased_mix_values ] [ range-test adaptor_test/type_erased_tparam_conv ] [ range-test adaptor_test/type_erased_single_pass ] + [ range-test adaptor_test/type_erased_bidirectional ] [ range-test adaptor_test/uniqued ] [ range-test adaptor_test/adjacent_filtered_example ] [ range-test adaptor_test/copied_example ] diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index f95ed68..e2b2b9b 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -10,15 +10,13 @@ #include -#include -#include #include #include #include #include #include -#include +#include #include namespace boost_range_adaptor_type_erased_test @@ -46,17 +44,6 @@ void test_type_erased_forward() test_type_erased_exercise_buffer_types< std::vector, boost::forward_traversal_tag >(); } -void test_type_erased_bidirectional() -{ - test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); -} - void test_type_erased_random_access() { test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); @@ -77,7 +64,6 @@ init_unit_test_suite(int argc, char* argv[]) test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_forward ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_bidirectional ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_random_access ) ); return test; diff --git a/test/adaptor_test/type_erased_bidirectional.cpp b/test/adaptor_test/type_erased_bidirectional.cpp new file mode 100644 index 0000000..94ed740 --- /dev/null +++ b/test/adaptor_test/type_erased_bidirectional.cpp @@ -0,0 +1,52 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include + +#include +#include +#include + +#include +#include +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { + +void test_bidirectional() +{ + test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); + + test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_bidirectional"); + + test->add(BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::test_bidirectional)); + + return test; +} + From bd1fd9610e44dbaf67f2fea6814d2319d5aae6c4 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:52:02 +0000 Subject: [PATCH 55/60] type_erased test separated the forward traversal. --- test/Jamfile.v2 | 1 + test/adaptor_test/type_erased.cpp | 12 ----- test/adaptor_test/type_erased_forward.cpp | 62 +++++++++++++++++++++++ 3 files changed, 63 insertions(+), 12 deletions(-) create mode 100644 test/adaptor_test/type_erased_forward.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index a0c10e0..013e8d2 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -55,6 +55,7 @@ test-suite range : [ range-test adaptor_test/type_erased_mix_values ] [ range-test adaptor_test/type_erased_tparam_conv ] [ range-test adaptor_test/type_erased_single_pass ] + [ range-test adaptor_test/type_erased_forward ] [ range-test adaptor_test/type_erased_bidirectional ] [ range-test adaptor_test/uniqued ] [ range-test adaptor_test/adjacent_filtered_example ] diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index e2b2b9b..8752df9 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -33,17 +33,6 @@ void test_type_erased() test_driver< std::vector >(); } -void test_type_erased_forward() -{ - test_type_erased_exercise_buffer_types< std::list, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::forward_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::list, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::forward_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::forward_traversal_tag >(); -} - void test_type_erased_random_access() { test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); @@ -63,7 +52,6 @@ init_unit_test_suite(int argc, char* argv[]) = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased" ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_forward ) ); test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_random_access ) ); return test; diff --git a/test/adaptor_test/type_erased_forward.cpp b/test/adaptor_test/type_erased_forward.cpp new file mode 100644 index 0000000..41e491b --- /dev/null +++ b/test/adaptor_test/type_erased_forward.cpp @@ -0,0 +1,62 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include + +#include +#include +#include + +#include +#include +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { + +void test_forward() +{ + test_type_erased_exercise_buffer_types< + std::list, boost::forward_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::deque, boost::forward_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::forward_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::list, boost::forward_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::deque, boost::forward_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::forward_traversal_tag >(); +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased_forward" ); + + test->add(BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::test_forward)); + + return test; +} + From a4633c2c1eb370996823a6232036663c0f1a2c2a Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 11:53:13 +0000 Subject: [PATCH 56/60] type_erased_bidrectional.cpp formatting. --- .../type_erased_bidirectional.cpp | 22 ++++++++++++++----- 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/test/adaptor_test/type_erased_bidirectional.cpp b/test/adaptor_test/type_erased_bidirectional.cpp index 94ed740..fbcd852 100644 --- a/test/adaptor_test/type_erased_bidirectional.cpp +++ b/test/adaptor_test/type_erased_bidirectional.cpp @@ -26,13 +26,23 @@ namespace boost_range_adaptor_type_erased_test void test_bidirectional() { - test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< + std::list, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::list, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::deque, boost::bidirectional_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::bidirectional_traversal_tag >(); + test_type_erased_exercise_buffer_types< + std::deque, boost::bidirectional_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::bidirectional_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::list, boost::bidirectional_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::deque, boost::bidirectional_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::bidirectional_traversal_tag >(); } } // anonymous namespace From 620653545317506abfb15b4c7bb72f6a0004925b Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 12:02:28 +0000 Subject: [PATCH 57/60] type_erased random_access adapter separated. --- test/Jamfile.v2 | 1 + test/adaptor_test/type_erased.cpp | 18 ++---- .../type_erased_random_access.cpp | 55 +++++++++++++++++++ 3 files changed, 60 insertions(+), 14 deletions(-) create mode 100644 test/adaptor_test/type_erased_random_access.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 013e8d2..a7b479a 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -57,6 +57,7 @@ test-suite range : [ range-test adaptor_test/type_erased_single_pass ] [ range-test adaptor_test/type_erased_forward ] [ range-test adaptor_test/type_erased_bidirectional ] + [ range-test adaptor_test/type_erased_random_access ] [ range-test adaptor_test/uniqued ] [ range-test adaptor_test/adjacent_filtered_example ] [ range-test adaptor_test/copied_example ] diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index 8752df9..aad2f27 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -16,7 +16,6 @@ #include #include -#include #include namespace boost_range_adaptor_type_erased_test @@ -33,26 +32,17 @@ void test_type_erased() test_driver< std::vector >(); } -void test_type_erased_random_access() -{ - test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::random_access_traversal_tag >(); - - test_type_erased_exercise_buffer_types< std::deque, boost::random_access_traversal_tag >(); - test_type_erased_exercise_buffer_types< std::vector, boost::random_access_traversal_tag >(); -} - } // anonymous namespace } // namespace boost_range_adaptor_type_erased_test boost::unit_test::test_suite* init_unit_test_suite(int argc, char* argv[]) { - boost::unit_test::test_suite* test - = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased" ); + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased"); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased ) ); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_random_access ) ); + test->add(BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::test_type_erased)); return test; } diff --git a/test/adaptor_test/type_erased_random_access.cpp b/test/adaptor_test/type_erased_random_access.cpp new file mode 100644 index 0000000..5caea9e --- /dev/null +++ b/test/adaptor_test/type_erased_random_access.cpp @@ -0,0 +1,55 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +#include +#include "type_erased_test.hpp" + +#include + +#include +#include +#include + +#include +#include +#include + +namespace boost_range_adaptor_type_erased_test +{ + namespace + { + +void test_random_access() +{ + test_type_erased_exercise_buffer_types< + std::deque, boost::random_access_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::random_access_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::deque, boost::random_access_traversal_tag >(); + + test_type_erased_exercise_buffer_types< + std::vector, boost::random_access_traversal_tag >(); +} + + } // anonymous namespace +} // namespace boost_range_adaptor_type_erased_test + +boost::unit_test::test_suite* +init_unit_test_suite(int argc, char* argv[]) +{ + boost::unit_test::test_suite* test = + BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_random_access"); + + test->add(BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::test_random_access)); + + return test; +} + From 0d93777ecef223b93e7013edd0a297e0e3d34b3c Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 12:33:51 +0000 Subject: [PATCH 58/60] type_erased unit test reduce dependencies of the recently split type_erased tests. --- test/adaptor_test/type_erased.cpp | 5 ---- test/adaptor_test/type_erased_abstract.cpp | 11 +++----- .../type_erased_bidirectional.cpp | 7 +---- test/adaptor_test/type_erased_brackets.cpp | 19 +++++-------- test/adaptor_test/type_erased_forward.cpp | 9 ++----- test/adaptor_test/type_erased_mix_values.cpp | 27 +++++++------------ .../type_erased_random_access.cpp | 5 ---- test/adaptor_test/type_erased_single_pass.cpp | 5 ---- test/adaptor_test/type_erased_tparam_conv.cpp | 4 --- 9 files changed, 23 insertions(+), 69 deletions(-) diff --git a/test/adaptor_test/type_erased.cpp b/test/adaptor_test/type_erased.cpp index aad2f27..edea1c4 100644 --- a/test/adaptor_test/type_erased.cpp +++ b/test/adaptor_test/type_erased.cpp @@ -10,11 +10,6 @@ #include -#include -#include -#include - -#include #include #include diff --git a/test/adaptor_test/type_erased_abstract.cpp b/test/adaptor_test/type_erased_abstract.cpp index 3f3263e..dd54890 100644 --- a/test/adaptor_test/type_erased_abstract.cpp +++ b/test/adaptor_test/type_erased_abstract.cpp @@ -8,20 +8,15 @@ #include #include "type_erased_test.hpp" -#include #include -#include -#include -#include - -#include #include namespace boost_range_adaptor_type_erased_test { namespace { + class dummy_interface { public: @@ -80,10 +75,10 @@ void test_type_erased_abstract() } // namespace boost_range_adaptor_type_erased_test boost::unit_test::test_suite* -init_unit_test_suite(int argc, char* argv[]) +init_unit_test_suite(int, char*[]) { boost::unit_test::test_suite* test - = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased_abstract" ); + = BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_abstract"); test->add( BOOST_TEST_CASE( diff --git a/test/adaptor_test/type_erased_bidirectional.cpp b/test/adaptor_test/type_erased_bidirectional.cpp index fbcd852..3dc86fe 100644 --- a/test/adaptor_test/type_erased_bidirectional.cpp +++ b/test/adaptor_test/type_erased_bidirectional.cpp @@ -10,11 +10,6 @@ #include -#include -#include -#include - -#include #include #include #include @@ -49,7 +44,7 @@ void test_bidirectional() } // namespace boost_range_adaptor_type_erased_test boost::unit_test::test_suite* -init_unit_test_suite(int argc, char* argv[]) +init_unit_test_suite(int, char*[]) { boost::unit_test::test_suite* test = BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_bidirectional"); diff --git a/test/adaptor_test/type_erased_brackets.cpp b/test/adaptor_test/type_erased_brackets.cpp index 95e61ec..9d5c7dd 100644 --- a/test/adaptor_test/type_erased_brackets.cpp +++ b/test/adaptor_test/type_erased_brackets.cpp @@ -10,13 +10,6 @@ #include -#include -#include -#include - -#include -#include -#include #include namespace boost_range_adaptor_type_erased_test @@ -24,7 +17,7 @@ namespace boost_range_adaptor_type_erased_test namespace { -void test_type_erased_operator_brackets() +void test_operator_brackets() { typedef boost::adaptors::type_erased<> type_erased_t; @@ -55,7 +48,7 @@ void test_type_erased_operator_brackets() for (int i = 0; i < 10; ++i) { - BOOST_CHECK_EQUAL( rng[i], i ); + BOOST_CHECK_EQUAL(rng[i], i); } } @@ -63,12 +56,14 @@ void test_type_erased_operator_brackets() } // namespace boost_range_adaptor_type_erased_test boost::unit_test::test_suite* -init_unit_test_suite(int argc, char* argv[]) +init_unit_test_suite(int, char*[]) { boost::unit_test::test_suite* test - = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased" ); + = BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_brackets"); - test->add( BOOST_TEST_CASE( &boost_range_adaptor_type_erased_test::test_type_erased_operator_brackets ) ); + test->add( + BOOST_TEST_CASE( + &boost_range_adaptor_type_erased_test::test_operator_brackets)); return test; } diff --git a/test/adaptor_test/type_erased_forward.cpp b/test/adaptor_test/type_erased_forward.cpp index 41e491b..7f6540f 100644 --- a/test/adaptor_test/type_erased_forward.cpp +++ b/test/adaptor_test/type_erased_forward.cpp @@ -10,13 +10,8 @@ #include -#include -#include -#include - -#include -#include #include +#include #include namespace boost_range_adaptor_type_erased_test @@ -49,7 +44,7 @@ void test_forward() } // namespace boost_range_adaptor_type_erased_test boost::unit_test::test_suite* -init_unit_test_suite(int argc, char* argv[]) +init_unit_test_suite(int, char*[]) { boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.type_erased_forward" ); diff --git a/test/adaptor_test/type_erased_mix_values.cpp b/test/adaptor_test/type_erased_mix_values.cpp index ae5fe84..e91644c 100644 --- a/test/adaptor_test/type_erased_mix_values.cpp +++ b/test/adaptor_test/type_erased_mix_values.cpp @@ -10,13 +10,6 @@ #include -#include -#include -#include - -#include -#include -#include #include namespace boost_range_adaptor_type_erased_test @@ -34,7 +27,7 @@ template< > void mix_values_impl() { - typedef std::vector< ValueType > Container; + typedef std::vector Container; typedef typename boost::any_range_type_generator< Container @@ -56,13 +49,13 @@ void mix_values_impl() const source_type source_data(test_data); target_type t1(source_data); - BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), - t1.begin(), t1.end() ); + BOOST_CHECK_EQUAL_COLLECTIONS(source_data.begin(), source_data.end(), + t1.begin(), t1.end()); target_type t2; t2 = source_data; - BOOST_CHECK_EQUAL_COLLECTIONS( source_data.begin(), source_data.end(), - t2.begin(), t2.end() ); + BOOST_CHECK_EQUAL_COLLECTIONS(source_data.begin(), source_data.end(), + t2.begin(), t2.end()); } template @@ -78,17 +71,17 @@ void mix_values_driver() void mix_values() { - mix_values_driver< boost::single_pass_traversal_tag >(); - mix_values_driver< boost::forward_traversal_tag >(); - mix_values_driver< boost::bidirectional_traversal_tag >(); - mix_values_driver< boost::random_access_traversal_tag >(); + mix_values_driver(); + mix_values_driver(); + mix_values_driver(); + mix_values_driver(); } } // anonymous namespace } // namespace boost_range_adaptor_type_erased_test boost::unit_test::test_suite* -init_unit_test_suite(int argc, char* argv[]) +init_unit_test_suite(int, char*[]) { boost::unit_test::test_suite* test = BOOST_TEST_SUITE("RangeTestSuite.adaptor.type_erased_mix_values"); diff --git a/test/adaptor_test/type_erased_random_access.cpp b/test/adaptor_test/type_erased_random_access.cpp index 5caea9e..39cf1c6 100644 --- a/test/adaptor_test/type_erased_random_access.cpp +++ b/test/adaptor_test/type_erased_random_access.cpp @@ -10,11 +10,6 @@ #include -#include -#include -#include - -#include #include #include diff --git a/test/adaptor_test/type_erased_single_pass.cpp b/test/adaptor_test/type_erased_single_pass.cpp index 8ae2fe1..ad0c4ae 100644 --- a/test/adaptor_test/type_erased_single_pass.cpp +++ b/test/adaptor_test/type_erased_single_pass.cpp @@ -10,11 +10,6 @@ #include -#include -#include -#include - -#include #include #include #include diff --git a/test/adaptor_test/type_erased_tparam_conv.cpp b/test/adaptor_test/type_erased_tparam_conv.cpp index 4342f99..e235ab3 100644 --- a/test/adaptor_test/type_erased_tparam_conv.cpp +++ b/test/adaptor_test/type_erased_tparam_conv.cpp @@ -10,10 +10,6 @@ #include -#include -#include -#include - #include #include From b84385cfceb808e725cc7f2a45a9df71cb555a25 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 12:54:07 +0000 Subject: [PATCH 59/60] trac 8803 - size(const Rng&) returns size_type. It also no longer requires random access. --- doc/reference/synopsis.qbk | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/doc/reference/synopsis.qbk b/doc/reference/synopsis.qbk index 76719df..bfef5c1 100644 --- a/doc/reference/synopsis.qbk +++ b/doc/reference/synopsis.qbk @@ -73,6 +73,10 @@ namespace boost typename range_difference::type distance( const T& r ); + template< class T > + typename range_size::type + size( const T& r ); + // // Bidirectional Range functions // @@ -93,14 +97,6 @@ namespace boost typename range_reverse_iterator::type rend( const T& r ); - // - // Random Access Range functions - // - - template< class T > - typename range_difference::type - size( const T& r ); - // // Special const Range functions // From 194f357eeb5957e430b740f68cf4f8b10e59eee8 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Tue, 4 Mar 2014 13:33:59 +0000 Subject: [PATCH 60/60] trac 6685 - MFC range map adaptor. --- doc/mfc_atl.qbk | 4 ++ doc/upgrade.qbk | 11 +++ include/boost/range/mfc_map.hpp | 114 ++++++++++++++++++++++++++++++++ 3 files changed, 129 insertions(+) create mode 100644 include/boost/range/mfc_map.hpp diff --git a/doc/mfc_atl.qbk b/doc/mfc_atl.qbk index de2e225..0056283 100644 --- a/doc/mfc_atl.qbk +++ b/doc/mfc_atl.qbk @@ -74,6 +74,10 @@ If the `` is included before or after Boost.Range headers, ] Other Boost.Range metafunctions are defined by the following. Let `Range` be any type listed above and `Ref` be the same as `range_reference::type`. `range_value::type` is the same as `remove_reference::type>::type`, `range_difference::type` is the same as `std::ptrdiff_t`, and `range_pointer::type` is the same as `add_pointer::type>::type`. As for `const Range`, see below. + +Adam Walling has provided the header `` to add support +for the map adaptor with MFC map types. + [endsect] [section:atl_ranges ATL Ranges] diff --git a/doc/upgrade.qbk b/doc/upgrade.qbk index 482a825..ef66325 100644 --- a/doc/upgrade.qbk +++ b/doc/upgrade.qbk @@ -5,6 +5,17 @@ /] [section:upgrade Upgrade version of Boost.Range] +[section:upgrade_from_1_55 Upgrade from version 1.55] +# __iterator_range__ is now implemented by implementing the member functions +`size()`, `operator[]` via inheritance of base-classes specialized by the +traversal type of the underlying iterator. This is normally requires no +alteration of code. It does mean that types that derive from iterator_range may +need to prefix `this->` to the various member functions. Additionally it has +been noted that some calling code was relying on member functions such as +`size()` being present despite the underlying iterators not being random-access +due to `iterator_reference::type` not being a reference. The suggested +refactoring is to use `boost::size(rng)`. + [section:upgrade_from_1_49 Upgrade from version 1.49] # __size__ now returns the type Rng::size_type if the range has size_type; diff --git a/include/boost/range/mfc_map.hpp b/include/boost/range/mfc_map.hpp new file mode 100644 index 0000000..2cd42b4 --- /dev/null +++ b/include/boost/range/mfc_map.hpp @@ -0,0 +1,114 @@ +// Boost.Range library +// +// Copyright Adam D. Walling 2012. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_ADAPTOR_MFC_MAP_HPP +#define BOOST_RANGE_ADAPTOR_MFC_MAP_HPP + +#if !defined(BOOST_RANGE_MFC_NO_CPAIR) + +#include +#include + +namespace boost +{ + namespace range_detail + { + // CMap and CMapStringToString range iterators return CPair, + // which has a key and value member. Other MFC range iterators + // already return adapted std::pair objects. This allows usage + // of the map_keys and map_values range adaptors with CMap + // and CMapStringToString + + // CPair has a VALUE value member, and a KEY key member; we will + // use VALUE& as the result_type consistent with CMap::operator[] + + // specialization for CMap + template + struct select_first< CMap > + { + typedef BOOST_DEDUCED_TYPENAME CMap map_type; + typedef BOOST_DEDUCED_TYPENAME range_reference::type argument_type; + typedef BOOST_DEDUCED_TYPENAME const KEY& result_type; + + result_type operator()( argument_type r ) const + { + return r.key; + } + }; + + template + struct select_second_mutable< CMap > + { + typedef BOOST_DEDUCED_TYPENAME CMap map_type; + typedef BOOST_DEDUCED_TYPENAME range_reference::type argument_type; + typedef BOOST_DEDUCED_TYPENAME VALUE& result_type; + + result_type operator()( argument_type r ) const + { + return r.value; + } + }; + + template + struct select_second_const< CMap > + { + typedef BOOST_DEDUCED_TYPENAME CMap map_type; + typedef BOOST_DEDUCED_TYPENAME range_reference::type argument_type; + typedef BOOST_DEDUCED_TYPENAME const VALUE& result_type; + + result_type operator()( argument_type r ) const + { + return r.value; + } + }; + + + // specialization for CMapStringToString + template<> + struct select_first< CMapStringToString > + { + typedef range_reference::type argument_type; + typedef const CString& result_type; + + result_type operator()( argument_type r ) const + { + return r.key; + } + }; + + template<> + struct select_second_mutable< CMapStringToString > + { + typedef range_reference::type argument_type; + typedef CString& result_type; + + result_type operator()( argument_type r ) const + { + return r.value; + } + }; + + template<> + struct select_second_const< CMapStringToString > + { + typedef range_reference::type argument_type; + typedef const CString& result_type; + + result_type operator()( argument_type r ) const + { + return r.value; + } + }; + } // 'range_detail' +} // 'boost' + +#endif // !defined(BOOST_RANGE_MFC_NO_CPAIR) + +#endif