From 5a4ba24d361ac0676d2cce95fdff22824ecdc287 Mon Sep 17 00:00:00 2001 From: Georgy Guminov Date: Sun, 19 Jan 2025 16:38:30 +0300 Subject: [PATCH] Fixes. --- include/boost/generator_iterator.hpp | 2 +- .../iterator/function_input_iterator.hpp | 30 +++++----- include/boost/iterator/iterator_adaptor.hpp | 2 +- include/boost/iterator/iterator_facade.hpp | 21 ++++--- include/boost/iterator/new_iterator_tests.hpp | 59 +++++++++++-------- test/iterator_facade.cpp | 24 ++++---- test/static_assert_same.hpp | 2 +- 7 files changed, 76 insertions(+), 64 deletions(-) diff --git a/include/boost/generator_iterator.hpp b/include/boost/generator_iterator.hpp index 0fe1569..e5c2459 100644 --- a/include/boost/generator_iterator.hpp +++ b/include/boost/generator_iterator.hpp @@ -68,7 +68,7 @@ struct generator_iterator_generator template inline generator_iterator -make_generator_iterator(Generator & gen) +make_generator_iterator(Generator& gen) { typedef generator_iterator result_t; return result_t(&gen); diff --git a/include/boost/iterator/function_input_iterator.hpp b/include/boost/iterator/function_input_iterator.hpp index 15175b2..be72a42 100644 --- a/include/boost/iterator/function_input_iterator.hpp +++ b/include/boost/iterator/function_input_iterator.hpp @@ -50,12 +50,12 @@ namespace iterators { iterators::function_input_iterator, typename result_of_nullary_lvalue_call::type, single_pass_traversal_tag, - typename result_of_nullary_lvalue_call::type const & + typename result_of_nullary_lvalue_call::type const& > { public: function_object_input_iterator() {} - function_object_input_iterator(Function & f_, Input state_ = Input()) + function_object_input_iterator(Function& f_, Input state_ = Input()) : f(std::addressof(f_)), state(state_) {} void increment() { @@ -66,14 +66,14 @@ namespace iterators { ++state; } - typename result_of_nullary_lvalue_call::type const & + typename result_of_nullary_lvalue_call::type const& dereference() const { if (!value) value = (*f)(); return value.get(); } - bool equal(function_object_input_iterator const & other) const { + bool equal(function_object_input_iterator const& other) const { return f == other.f && state == other.state; } @@ -89,12 +89,12 @@ namespace iterators { iterators::function_input_iterator, typename function_types::result_type::type, single_pass_traversal_tag, - typename function_types::result_type::type const & + typename function_types::result_type::type const& > { public: function_pointer_input_iterator() {} - function_pointer_input_iterator(Function &f_, Input state_ = Input()) + function_pointer_input_iterator(Function& f_, Input state_ = Input()) : f(f_), state(state_) {} void increment() { @@ -105,14 +105,14 @@ namespace iterators { ++state; } - typename function_types::result_type::type const & + typename function_types::result_type::type const& dereference() const { if (!value) value = (*f)(); return value.get(); } - bool equal(function_pointer_input_iterator const & other) const { + bool equal(function_pointer_input_iterator const& other) const { return f == other.f && state == other.state; } @@ -138,30 +138,30 @@ namespace iterators { impl::function_object_input_iterator >::type base_type; public: - function_input_iterator(Function & f, Input i) + function_input_iterator(Function& f, Input i) : base_type(f, i) {} }; template inline function_input_iterator - make_function_input_iterator(Function & f, Input state) { + make_function_input_iterator(Function& f, Input state) { typedef function_input_iterator result_t; return result_t(f, state); } template inline function_input_iterator - make_function_input_iterator(Function * f, Input state) { + make_function_input_iterator(Function* f, Input state) { typedef function_input_iterator result_t; return result_t(f, state); } struct infinite { - infinite & operator++() { return *this; } - infinite & operator++(int) { return *this; } - bool operator==(infinite &) const { return false; }; - bool operator==(infinite const &) const { return false; }; + infinite& operator++() { return *this; } + infinite& operator++(int) { return *this; } + bool operator==(infinite&) const { return false; }; + bool operator==(infinite const&) const { return false; }; }; } // namespace iterators diff --git a/include/boost/iterator/iterator_adaptor.hpp b/include/boost/iterator/iterator_adaptor.hpp index 9c6cbfa..214c320 100644 --- a/include/boost/iterator/iterator_adaptor.hpp +++ b/include/boost/iterator/iterator_adaptor.hpp @@ -204,7 +204,7 @@ namespace iterators { public: iterator_adaptor() {} - explicit iterator_adaptor(Base const &iter) + explicit iterator_adaptor(Base const& iter) : m_iterator(iter) { } diff --git a/include/boost/iterator/iterator_facade.hpp b/include/boost/iterator/iterator_facade.hpp index 6029208..d9b97d7 100644 --- a/include/boost/iterator/iterator_facade.hpp +++ b/include/boost/iterator/iterator_facade.hpp @@ -8,7 +8,6 @@ #define BOOST_ITERATOR_FACADE_23022003THW_HPP #include -#include #include #include @@ -171,7 +170,7 @@ namespace iterators { // Provides (r++)->foo() value_type* operator->() const { - return boost::addressof(stored_value); + return std::addressof(stored_value); } private: @@ -271,7 +270,7 @@ namespace iterators { // Provides (r++)->foo() value_type* operator->() const { - return boost::addressof(dereference_proxy.stored_value); + return std::addressof(dereference_proxy.stored_value); } private: @@ -372,15 +371,15 @@ namespace iterators { { struct proxy { - explicit proxy(Reference const & x) : m_ref(x) {} - Reference* operator->() { return boost::addressof(m_ref); } + explicit proxy(Reference const& x) : m_ref(x) {} + Reference* operator->() { return std::addressof(m_ref); } // This function is needed for MWCW and BCC, which won't call // operator-> again automatically per 13.3.1.2 para 8 - operator Reference*() { return boost::addressof(m_ref); } + operator Reference*() { return std::addressof(m_ref); } Reference m_ref; }; typedef proxy result_type; - static result_type apply(Reference const & x) + static result_type apply(Reference const& x) { return result_type(x); } @@ -392,7 +391,7 @@ namespace iterators { typedef Pointer result_type; static result_type apply(T& x) { - return boost::addressof(x); + return std::addressof(x); } }; @@ -459,7 +458,7 @@ namespace iterators { template typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, std::false_type) { - return *iter; + return *iter; } struct choose_difference_type @@ -762,11 +761,11 @@ namespace iterators { typename boost::iterators::detail::operator_brackets_result::type operator[](difference_type n) const { - const auto use_proxy = boost::iterators::detail::use_operator_brackets_proxy::value; + using use_proxy = boost::iterators::detail::use_operator_brackets_proxy; return boost::iterators::detail::make_operator_brackets_result( this->derived() + n - , std::integral_constant{} + , std::integral_constant{} ); } diff --git a/include/boost/iterator/new_iterator_tests.hpp b/include/boost/iterator/new_iterator_tests.hpp index a8a8335..f2b7f71 100644 --- a/include/boost/iterator/new_iterator_tests.hpp +++ b/include/boost/iterator/new_iterator_tests.hpp @@ -45,28 +45,33 @@ namespace boost { // Do separate tests for *i++ so we can treat, e.g., smart pointers, // as readable and/or writable iterators. template -void readable_iterator_traversal_test(Iterator i1, T v, std::true_type) { - T v2(*i1++); - BOOST_TEST(v == v2); +void readable_iterator_traversal_test(Iterator i1, T v, std::true_type) +{ + T v2(*i1++); + BOOST_TEST(v == v2); } template -void readable_iterator_traversal_test(const Iterator i1, T v, std::false_type) {} +void readable_iterator_traversal_test(const Iterator i1, T v, std::false_type) +{} template -void writable_iterator_traversal_test(Iterator i1, T v, std::true_type) { - ++i1; // we just wrote into that position - *i1++ = v; - Iterator x(i1++); - (void)x; +void writable_iterator_traversal_test(Iterator i1, T v, std::true_type) +{ + ++i1; // we just wrote into that position + *i1++ = v; + Iterator x(i1++); + (void)x; } template -void writable_iterator_traversal_test(const Iterator i1, T v, std::false_type) {} +void writable_iterator_traversal_test(const Iterator i1, T v, std::false_type) +{} // Preconditions: *i == v template -void readable_iterator_test(const Iterator i1, T v) { +void readable_iterator_test(const Iterator i1, T v) +{ Iterator i2(i1); // Copy Constructible typedef typename std::iterator_traits::reference ref_t; ref_t r1 = *i1; @@ -104,7 +109,9 @@ void writable_iterator_test(Iterator i, T v, T v2) { #endif } -template void swappable_iterator_test(Iterator i, Iterator j) { +template +void swappable_iterator_test(Iterator i, Iterator j) +{ Iterator i2(i), j2(j); typename std::iterator_traits::value_type bi = *i, bj = *j; iter_swap(i2, j2); @@ -117,10 +124,10 @@ void constant_lvalue_iterator_test(Iterator i, T v1) { Iterator i2(i); typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::reference reference; - static_assert(std::is_same::value, + static_assert(std::is_same::value, "reference type must be the same as const value_type& for " "constant lvalue iterator."); - const T &v2 = *i2; + const T& v2 = *i2; BOOST_TEST(v1 == v2); #ifndef BOOST_NO_LVALUE_RETURN_DETECTION static_assert(is_lvalue_iterator::value @@ -134,17 +141,17 @@ void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) { Iterator i2(i); typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::reference reference; - static_assert(std::is_same::value, + static_assert(std::is_same::value, "reference type must be the same as value_type& for " "non-constant lvalue iterator."); - T &v3 = *i2; + T& v3 = *i2; BOOST_TEST(v1 == v3); // A non-const lvalue iterator is not necessarily writable, but we // are assuming the value_type is assignable here *i = v2; - T &v4 = *i2; + T& v4 = *i2; BOOST_TEST(v2 == v4); #ifndef BOOST_NO_LVALUE_RETURN_DETECTION static_assert(is_lvalue_iterator::value, @@ -155,7 +162,8 @@ void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) { } template -void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) { +void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) +{ Iterator i2; Iterator i3(i); i2 = i; @@ -176,7 +184,8 @@ void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) { } template -void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) { +void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) +{ forward_readable_iterator_test(i, j, val1, val2); Iterator i2 = i; ++i2; @@ -186,7 +195,8 @@ void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) { // bidirectional // Preconditions: *i == v1, *++i == v2 template -void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) { +void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) +{ Iterator j(i); ++j; forward_readable_iterator_test(i, j, v1, v2); @@ -215,12 +225,14 @@ void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) { // random access // Preconditions: [i,i+N) is a valid range template -void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) { +void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) +{ bidirectional_readable_iterator_test(i, vals[0], vals[1]); const Iterator j = i; int c; - for (c = 0; c < N - 1; ++c) { + for (c = 0; c < N - 1; ++c) + { BOOST_TEST(i == j + c); BOOST_TEST(*i == vals[c]); typename std::iterator_traits::value_type x = j[c]; @@ -235,7 +247,8 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) { } Iterator k = j + N - 1; - for (c = 0; c < N - 1; ++c) { + for (c = 0; c < N - 1; ++c) + { BOOST_TEST(i == k - c); BOOST_TEST(*i == vals[N - 1 - c]); typename std::iterator_traits::value_type x = j[N - 1 - c]; diff --git a/test/iterator_facade.cpp b/test/iterator_facade.cpp index a44325a..a216e55 100644 --- a/test/iterator_facade.cpp +++ b/test/iterator_facade.cpp @@ -149,11 +149,11 @@ template struct abstract_iterator : boost::iterator_facade< abstract_iterator - , A & + , A& // In order to be value type as a reference, traversal category has // to satisfy least forward traversal. , boost::forward_traversal_tag - , A & + , A& > { abstract_iterator(I iter) : iter(iter) {} @@ -161,7 +161,7 @@ struct abstract_iterator void increment() { ++iter; } - A & dereference() const + A& dereference() const { return *iter; } bool equal(abstract_iterator const& y) const @@ -172,30 +172,30 @@ struct abstract_iterator struct base { - virtual void assign(const base &) = 0; - virtual bool equal(const base &) const = 0; + virtual void assign(const base&) = 0; + virtual bool equal(const base&) const = 0; }; struct derived : base { derived(int state) : state(state) { } - derived(const derived &d) : state(d.state) { } - derived(const base &b) { derived::assign(b); } + derived(const derived& d) : state(d.state) { } + derived(const base& b) { derived::assign(b); } - virtual void assign(const base &b) + virtual void assign(const base& b) { - state = dynamic_cast(b).state; + state = dynamic_cast(b).state; } - virtual bool equal(const base &b) const + virtual bool equal(const base& b) const { - return state == dynamic_cast(b).state; + return state == dynamic_cast(b).state; } int state; }; -inline bool operator==(const base &lhs, const base &rhs) +inline bool operator==(const base& lhs, const base& rhs) { return lhs.equal(rhs); } diff --git a/test/static_assert_same.hpp b/test/static_assert_same.hpp index fb1c847..12d5066 100644 --- a/test/static_assert_same.hpp +++ b/test/static_assert_same.hpp @@ -7,7 +7,7 @@ #include -#define STATIC_ASSERT_SAME( T1,T2 ) static_assert(std::is_same::value, "T1 ans T2 are expected to be the same types.") +#define STATIC_ASSERT_SAME( T1,T2 ) static_assert(std::is_same::value, "T1 and T2 are expected to be the same types.") template struct static_assert_same