feedc0de/boost_iterator
1
0
Fork 0
forked from boostorg/iterator
Code Pull Requests Activity

Fixes.

Browse Source
This commit is contained in:
Georgy Guminov
2025-01-19 16:38:30 +03:00
parent fdfafce2b9
commit 5a4ba24d36
7 changed files with 76 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/boost/generator_iterator.hpp
View File

@@ -68,7 +68,7 @@ struct generator_iterator_generator
template <class Generator> template <class Generator>
inline generator_iterator<Generator> inline generator_iterator<Generator>
make_generator_iterator(Generator & gen) make_generator_iterator(Generator& gen)
{ {
typedef generator_iterator<Generator> result_t; typedef generator_iterator<Generator> result_t;
return result_t(&gen); return result_t(&gen);

30
include/boost/iterator/function_input_iterator.hpp
View File

@@ -50,12 +50,12 @@ namespace iterators {
iterators::function_input_iterator<Function, Input>, iterators::function_input_iterator<Function, Input>,
typename result_of_nullary_lvalue_call<Function>::type, typename result_of_nullary_lvalue_call<Function>::type,
single_pass_traversal_tag, single_pass_traversal_tag,
typename result_of_nullary_lvalue_call<Function>::type const & typename result_of_nullary_lvalue_call<Function>::type const&
> >
{ {
public: public:
function_object_input_iterator() {} 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_) {} : f(std::addressof(f_)), state(state_) {}
void increment() { void increment() {
@@ -66,14 +66,14 @@ namespace iterators {
++state; ++state;
} }
typename result_of_nullary_lvalue_call<Function>::type const & typename result_of_nullary_lvalue_call<Function>::type const&
dereference() const { dereference() const {
if (!value) if (!value)
value = (*f)(); value = (*f)();
return value.get(); 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; return f == other.f && state == other.state;
} }
@@ -89,12 +89,12 @@ namespace iterators {
iterators::function_input_iterator<Function, Input>, iterators::function_input_iterator<Function, Input>,
typename function_types::result_type<Function>::type, typename function_types::result_type<Function>::type,
single_pass_traversal_tag, single_pass_traversal_tag,
typename function_types::result_type<Function>::type const & typename function_types::result_type<Function>::type const&
> >
{ {
public: public:
function_pointer_input_iterator() {} 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_) {} : f(f_), state(state_) {}
void increment() { void increment() {
@@ -105,14 +105,14 @@ namespace iterators {
++state; ++state;
} }
typename function_types::result_type<Function>::type const & typename function_types::result_type<Function>::type const&
dereference() const { dereference() const {
if (!value) if (!value)
value = (*f)(); value = (*f)();
return value.get(); 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; return f == other.f && state == other.state;
} }
@@ -138,30 +138,30 @@ namespace iterators {
impl::function_object_input_iterator<Function,Input> impl::function_object_input_iterator<Function,Input>
>::type base_type; >::type base_type;
public: public:
function_input_iterator(Function & f, Input i) function_input_iterator(Function& f, Input i)
: base_type(f, i) {} : base_type(f, i) {}
}; };
template <class Function, class Input> template <class Function, class Input>
inline function_input_iterator<Function, Input> inline function_input_iterator<Function, Input>
make_function_input_iterator(Function & f, Input state) { make_function_input_iterator(Function& f, Input state) {
typedef function_input_iterator<Function, Input> result_t; typedef function_input_iterator<Function, Input> result_t;
return result_t(f, state); return result_t(f, state);
} }
template <class Function, class Input> template <class Function, class Input>
inline function_input_iterator<Function*, Input> inline function_input_iterator<Function*, Input>
make_function_input_iterator(Function * f, Input state) { make_function_input_iterator(Function* f, Input state) {
typedef function_input_iterator<Function*, Input> result_t; typedef function_input_iterator<Function*, Input> result_t;
return result_t(f, state); return result_t(f, state);
} }
struct infinite struct infinite
{ {
infinite & operator++() { return *this; } infinite& operator++() { return *this; }
infinite & operator++(int) { return *this; } infinite& operator++(int) { return *this; }
bool operator==(infinite &) const { return false; }; bool operator==(infinite&) const { return false; };
bool operator==(infinite const &) const { return false; }; bool operator==(infinite const&) const { return false; };
}; };
} // namespace iterators } // namespace iterators

2
include/boost/iterator/iterator_adaptor.hpp
View File

@@ -204,7 +204,7 @@ namespace iterators {
public: public:
iterator_adaptor() {} iterator_adaptor() {}
explicit iterator_adaptor(Base const &iter) explicit iterator_adaptor(Base const& iter)
: m_iterator(iter) : m_iterator(iter)
{ {
} }

21
include/boost/iterator/iterator_facade.hpp
View File

@@ -8,7 +8,6 @@
#define BOOST_ITERATOR_FACADE_23022003THW_HPP #define BOOST_ITERATOR_FACADE_23022003THW_HPP
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/core/addressof.hpp>
#include <boost/iterator/interoperable.hpp> #include <boost/iterator/interoperable.hpp>
#include <boost/iterator/iterator_traits.hpp> #include <boost/iterator/iterator_traits.hpp>
@@ -171,7 +170,7 @@ namespace iterators {
// Provides (r++)->foo() // Provides (r++)->foo()
value_type* operator->() const value_type* operator->() const
{ {
return boost::addressof(stored_value); return std::addressof(stored_value);
} }
private: private:
@@ -271,7 +270,7 @@ namespace iterators {
// Provides (r++)->foo() // Provides (r++)->foo()
value_type* operator->() const value_type* operator->() const
{ {
return boost::addressof(dereference_proxy.stored_value); return std::addressof(dereference_proxy.stored_value);
} }
private: private:
@@ -372,15 +371,15 @@ namespace iterators {
{ {
struct proxy struct proxy
{ {
explicit proxy(Reference const & x) : m_ref(x) {} explicit proxy(Reference const& x) : m_ref(x) {}
Reference* operator->() { return boost::addressof(m_ref); } Reference* operator->() { return std::addressof(m_ref); }
// This function is needed for MWCW and BCC, which won't call // This function is needed for MWCW and BCC, which won't call
// operator-> again automatically per 13.3.1.2 para 8 // 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; Reference m_ref;
}; };
typedef proxy result_type; typedef proxy result_type;
static result_type apply(Reference const & x) static result_type apply(Reference const& x)
{ {
return result_type(x); return result_type(x);
} }
@@ -392,7 +391,7 @@ namespace iterators {
typedef Pointer result_type; typedef Pointer result_type;
static result_type apply(T& x) static result_type apply(T& x)
{ {
return boost::addressof(x); return std::addressof(x);
} }
}; };
@@ -459,7 +458,7 @@ namespace iterators {
template <class Iterator> template <class Iterator>
typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, std::false_type) typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, std::false_type)
{ {
return *iter; return *iter;
} }
struct choose_difference_type struct choose_difference_type
@@ -762,11 +761,11 @@ namespace iterators {
typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
operator[](difference_type n) const operator[](difference_type n) const
{ {
const auto use_proxy = boost::iterators::detail::use_operator_brackets_proxy<Value, Reference>::value; using use_proxy = boost::iterators::detail::use_operator_brackets_proxy<Value, Reference>;
return boost::iterators::detail::make_operator_brackets_result<Derived>( return boost::iterators::detail::make_operator_brackets_result<Derived>(
this->derived() + n this->derived() + n
, std::integral_constant<bool, use_proxy>{} , std::integral_constant<bool, use_proxy::value>{}
); );
} }

59
include/boost/iterator/new_iterator_tests.hpp
View File

@@ -45,28 +45,33 @@ namespace boost {
// Do separate tests for *i++ so we can treat, e.g., smart pointers, // Do separate tests for *i++ so we can treat, e.g., smart pointers,
// as readable and/or writable iterators. // as readable and/or writable iterators.
template <class Iterator, class T> template <class Iterator, class T>
void readable_iterator_traversal_test(Iterator i1, T v, std::true_type) { void readable_iterator_traversal_test(Iterator i1, T v, std::true_type)
T v2(*i1++); {
BOOST_TEST(v == v2); T v2(*i1++);
BOOST_TEST(v == v2);
} }
template <class Iterator, class T> template <class Iterator, class T>
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 <class Iterator, class T> template <class Iterator, class T>
void writable_iterator_traversal_test(Iterator i1, T v, std::true_type) { void writable_iterator_traversal_test(Iterator i1, T v, std::true_type)
++i1; // we just wrote into that position {
*i1++ = v; ++i1; // we just wrote into that position
Iterator x(i1++); *i1++ = v;
(void)x; Iterator x(i1++);
(void)x;
} }
template <class Iterator, class T> template <class Iterator, class T>
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 // Preconditions: *i == v
template <class Iterator, class T> template <class Iterator, class T>
void readable_iterator_test(const Iterator i1, T v) { void readable_iterator_test(const Iterator i1, T v)
{
Iterator i2(i1); // Copy Constructible Iterator i2(i1); // Copy Constructible
typedef typename std::iterator_traits<Iterator>::reference ref_t; typedef typename std::iterator_traits<Iterator>::reference ref_t;
ref_t r1 = *i1; ref_t r1 = *i1;
@@ -104,7 +109,9 @@ void writable_iterator_test(Iterator i, T v, T v2) {
#endif #endif
} }
template <class Iterator> void swappable_iterator_test(Iterator i, Iterator j) { template <class Iterator>
void swappable_iterator_test(Iterator i, Iterator j)
{
Iterator i2(i), j2(j); Iterator i2(i), j2(j);
typename std::iterator_traits<Iterator>::value_type bi = *i, bj = *j; typename std::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
iter_swap(i2, j2); iter_swap(i2, j2);
@@ -117,10 +124,10 @@ void constant_lvalue_iterator_test(Iterator i, T v1) {
Iterator i2(i); Iterator i2(i);
typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef typename std::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference; typedef typename std::iterator_traits<Iterator>::reference reference;
static_assert(std::is_same<const value_type &, reference>::value, static_assert(std::is_same<const value_type&, reference>::value,
"reference type must be the same as const value_type& for " "reference type must be the same as const value_type& for "
"constant lvalue iterator."); "constant lvalue iterator.");
const T &v2 = *i2; const T& v2 = *i2;
BOOST_TEST(v1 == v2); BOOST_TEST(v1 == v2);
#ifndef BOOST_NO_LVALUE_RETURN_DETECTION #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
static_assert(is_lvalue_iterator<Iterator>::value static_assert(is_lvalue_iterator<Iterator>::value
@@ -134,17 +141,17 @@ void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) {
Iterator i2(i); Iterator i2(i);
typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef typename std::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference; typedef typename std::iterator_traits<Iterator>::reference reference;
static_assert(std::is_same<value_type &, reference>::value, static_assert(std::is_same<value_type&, reference>::value,
"reference type must be the same as value_type& for " "reference type must be the same as value_type& for "
"non-constant lvalue iterator."); "non-constant lvalue iterator.");
T &v3 = *i2; T& v3 = *i2;
BOOST_TEST(v1 == v3); BOOST_TEST(v1 == v3);
// A non-const lvalue iterator is not necessarily writable, but we // A non-const lvalue iterator is not necessarily writable, but we
// are assuming the value_type is assignable here // are assuming the value_type is assignable here
*i = v2; *i = v2;
T &v4 = *i2; T& v4 = *i2;
BOOST_TEST(v2 == v4); BOOST_TEST(v2 == v4);
#ifndef BOOST_NO_LVALUE_RETURN_DETECTION #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
static_assert(is_lvalue_iterator<Iterator>::value, static_assert(is_lvalue_iterator<Iterator>::value,
@@ -155,7 +162,8 @@ void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) {
} }
template <class Iterator, class T> template <class Iterator, class T>
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 i2;
Iterator i3(i); Iterator i3(i);
i2 = i; i2 = i;
@@ -176,7 +184,8 @@ void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) {
} }
template <class Iterator, class T> template <class Iterator, class T>
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); forward_readable_iterator_test(i, j, val1, val2);
Iterator i2 = i; Iterator i2 = i;
++i2; ++i2;
@@ -186,7 +195,8 @@ void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) {
// bidirectional // bidirectional
// Preconditions: *i == v1, *++i == v2 // Preconditions: *i == v1, *++i == v2
template <class Iterator, class T> template <class Iterator, class T>
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); Iterator j(i);
++j; ++j;
forward_readable_iterator_test(i, j, v1, v2); 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 // random access
// Preconditions: [i,i+N) is a valid range // Preconditions: [i,i+N) is a valid range
template <class Iterator, class TrueVals> template <class Iterator, class TrueVals>
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]); bidirectional_readable_iterator_test(i, vals[0], vals[1]);
const Iterator j = i; const Iterator j = i;
int c; int c;
for (c = 0; c < N - 1; ++c) { for (c = 0; c < N - 1; ++c)
{
BOOST_TEST(i == j + c); BOOST_TEST(i == j + c);
BOOST_TEST(*i == vals[c]); BOOST_TEST(*i == vals[c]);
typename std::iterator_traits<Iterator>::value_type x = j[c]; typename std::iterator_traits<Iterator>::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; 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 == k - c);
BOOST_TEST(*i == vals[N - 1 - c]); BOOST_TEST(*i == vals[N - 1 - c]);
typename std::iterator_traits<Iterator>::value_type x = j[N - 1 - c]; typename std::iterator_traits<Iterator>::value_type x = j[N - 1 - c];

24
test/iterator_facade.cpp
View File

@@ -149,11 +149,11 @@ template <class I, class A>
struct abstract_iterator struct abstract_iterator
: boost::iterator_facade< : boost::iterator_facade<
abstract_iterator<I, A> abstract_iterator<I, A>
, A & , A&
// In order to be value type as a reference, traversal category has // In order to be value type as a reference, traversal category has
// to satisfy least forward traversal. // to satisfy least forward traversal.
, boost::forward_traversal_tag , boost::forward_traversal_tag
, A & , A&
> >
{ {
abstract_iterator(I iter) : iter(iter) {} abstract_iterator(I iter) : iter(iter) {}
@@ -161,7 +161,7 @@ struct abstract_iterator
void increment() void increment()
{ ++iter; } { ++iter; }
A & dereference() const A& dereference() const
{ return *iter; } { return *iter; }
bool equal(abstract_iterator const& y) const bool equal(abstract_iterator const& y) const
@@ -172,30 +172,30 @@ struct abstract_iterator
struct base struct base
{ {
virtual void assign(const base &) = 0; virtual void assign(const base&) = 0;
virtual bool equal(const base &) const = 0; virtual bool equal(const base&) const = 0;
}; };
struct derived : base struct derived : base
{ {
derived(int state) : state(state) { } derived(int state) : state(state) { }
derived(const derived &d) : state(d.state) { } derived(const derived& d) : state(d.state) { }
derived(const base &b) { derived::assign(b); } derived(const base& b) { derived::assign(b); }
virtual void assign(const base &b) virtual void assign(const base& b)
{ {
state = dynamic_cast<const derived &>(b).state; state = dynamic_cast<const derived& >(b).state;
} }
virtual bool equal(const base &b) const virtual bool equal(const base& b) const
{ {
return state == dynamic_cast<const derived &>(b).state; return state == dynamic_cast<const derived&>(b).state;
} }
int 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); return lhs.equal(rhs);
} }

2
test/static_assert_same.hpp
View File

@@ -7,7 +7,7 @@
#include <type_traits> #include <type_traits>
#define STATIC_ASSERT_SAME( T1,T2 ) static_assert(std::is_same<T1, T2>::value, "T1 ans T2 are expected to be the same types.") #define STATIC_ASSERT_SAME( T1,T2 ) static_assert(std::is_same<T1, T2>::value, "T1 and T2 are expected to be the same types.")
template <class T1, class T2> template <class T1, class T2>
struct static_assert_same struct static_assert_same