boostorg/iterator
1
0
Fork 1
mirror of https://github.com/boostorg/iterator.git synced 2025-07-29 20:37:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop' of https://github.com/boostorg/iterator into develop

Browse Source
This commit is contained in:
Edward Diener
2017-10-09 08:17:24 -04:00
parent b2585dda6a 8b5e92a0c4
commit 422ad12716
7 changed files with 129 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
doc/rst2html → doc/rst2html.sh Normal file → Executable file
View File

0
doc/rst2latex → doc/rst2latex.sh Normal file → Executable file
View File

56
include/boost/function_output_iterator.hpp
View File

@ -1,62 +1,14 @@
// (C) Copyright Jeremy Siek 2001.
// (C) Copyright Andrey Semashev 2017.
// 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)
// Revision History:
// 27 Feb 2001 Jeremy Siek
// Initial checkin.
#ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
#include <iterator>
// This is a deprecated header left for backward compatibility.
// Use boost/iterator/function_output_iterator.hpp instead.
namespace boost {
namespace iterators {
template <class UnaryFunction>
class function_output_iterator {
typedef function_output_iterator self;
public:
typedef std::output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
explicit function_output_iterator() {}
explicit function_output_iterator(const UnaryFunction& f)
: m_f(f) {}
struct output_proxy {
output_proxy(UnaryFunction& f) : m_f(f) { }
template <class T> output_proxy& operator=(const T& value) {
m_f(value);
return *this;
}
UnaryFunction& m_f;
};
output_proxy operator*() { return output_proxy(m_f); }
self& operator++() { return *this; }
self& operator++(int) { return *this; }
private:
UnaryFunction m_f;
};
template <class UnaryFunction>
inline function_output_iterator<UnaryFunction>
make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
return function_output_iterator<UnaryFunction>(f);
}
} // namespace iterators
using iterators::function_output_iterator;
using iterators::make_function_output_iterator;
} // namespace boost
#include <boost/iterator/function_output_iterator.hpp>
#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

62
include/boost/iterator/function_output_iterator.hpp Normal file
View File

@ -0,0 +1,62 @@
// (C) Copyright Jeremy Siek 2001.
// 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)
// Revision History:
// 27 Feb 2001 Jeremy Siek
// Initial checkin.
#ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
#define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
#include <iterator>
namespace boost {
namespace iterators {
template <class UnaryFunction>
class function_output_iterator {
typedef function_output_iterator self;
public:
typedef std::output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
explicit function_output_iterator() {}
explicit function_output_iterator(const UnaryFunction& f)
: m_f(f) {}
struct output_proxy {
output_proxy(UnaryFunction& f) : m_f(f) { }
template <class T> output_proxy& operator=(const T& value) {
m_f(value);
return *this;
}
UnaryFunction& m_f;
};
output_proxy operator*() { return output_proxy(m_f); }
self& operator++() { return *this; }
self& operator++(int) { return *this; }
private:
UnaryFunction m_f;
};
template <class UnaryFunction>
inline function_output_iterator<UnaryFunction>
make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
return function_output_iterator<UnaryFunction>(f);
}
} // namespace iterators
using iterators::function_output_iterator;
using iterators::make_function_output_iterator;
} // namespace boost
#endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP

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

@ -29,16 +29,18 @@
// (David Abrahams)
# include <iterator>
# include <boost/type_traits.hpp>
# include <boost/static_assert.hpp>
# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
# include <boost/pending/iterator_tests.hpp>
# include <boost/iterator/is_readable_iterator.hpp>
# include <boost/iterator/is_lvalue_iterator.hpp>
# include <boost/type_traits/is_same.hpp>
# include <boost/mpl/bool.hpp>
# include <boost/mpl/and.hpp>
# include <boost/iterator/detail/config_def.hpp>
# include <boost/detail/is_incrementable.hpp>
# include <boost/detail/lightweight_test.hpp>
# include <boost/core/lightweight_test.hpp>
namespace boost {

4
include/boost/iterator/transform_iterator.hpp
View File

@ -47,7 +47,11 @@ namespace iterators {
// the function.
typedef typename ia_dflt_help<
Reference
#ifdef BOOST_RESULT_OF_USE_TR1
, result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
#else
, result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)>
#endif
>::type reference;
// To get the default for Value: remove any reference on the

108
include/boost/pending/iterator_tests.hpp
View File

@ -20,12 +20,14 @@
// (David Abrahams)
# include <iterator>
# include <assert.h>
# include <boost/type_traits.hpp>
# include <boost/static_assert.hpp>
# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
# include <boost/implicit_cast.hpp>
# include <boost/core/ignore_unused.hpp>
# include <boost/core/lightweight_test.hpp>
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_pointer.hpp>
# include <boost/type_traits/is_reference.hpp>
namespace boost {
@ -51,28 +53,28 @@ template <class Iterator, class T>
void trivial_iterator_test(const Iterator i, const Iterator j, T val)
{
Iterator k;
assert(i == i);
assert(j == j);
assert(i != j);
BOOST_TEST(i == i);
BOOST_TEST(j == j);
BOOST_TEST(i != j);
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
T v = *i;
#else
typename std::iterator_traits<Iterator>::value_type v = *i;
#endif
assert(v == val);
BOOST_TEST(v == val);
boost::ignore_unused(v);
#if 0
// hmm, this will give a warning for transform_iterator... perhaps
// this should be separated out into a stand-alone test since there
// are several situations where it can't be used, like for
// integer_range::iterator.
assert(v == i->foo());
BOOST_TEST(v == i->foo());
#endif
k = i;
assert(k == k);
assert(k == i);
assert(k != j);
assert(*k == val);
BOOST_TEST(k == k);
BOOST_TEST(k == i);
BOOST_TEST(k != j);
BOOST_TEST(*k == val);
boost::ignore_unused(k);
}
@ -92,8 +94,8 @@ void input_iterator_test(Iterator i, T v1, T v2)
{
Iterator i1(i);
assert(i == i1);
assert(!(i != i1));
BOOST_TEST(i == i1);
BOOST_TEST(!(i != i1));
// I can see no generic way to create an input iterator
// that is in the domain of== of i and != i.
@ -102,24 +104,24 @@ void input_iterator_test(Iterator i, T v1, T v2)
//
// Iterator i2;
//
// assert(i != i2);
// assert(!(i == i2));
// BOOST_TEST(i != i2);
// BOOST_TEST(!(i == i2));
assert(*i1 == v1);
assert(*i == v1);
BOOST_TEST(*i1 == v1);
BOOST_TEST(*i == v1);
// we cannot test for equivalence of (void)++i & (void)i++
// as i is only guaranteed to be single pass.
assert(*i++ == v1);
BOOST_TEST(*i++ == v1);
boost::ignore_unused(i1);
i1 = i;
assert(i == i1);
assert(!(i != i1));
BOOST_TEST(i == i1);
BOOST_TEST(!(i != i1));
assert(*i1 == v2);
assert(*i == v2);
BOOST_TEST(*i1 == v2);
BOOST_TEST(*i == v2);
boost::ignore_unused(i1);
// i is dereferencable, so it must be incrementable.
@ -162,15 +164,15 @@ void forward_iterator_test(Iterator i, T v1, T v2)
Iterator i1 = i, i2 = i;
assert(i == i1++);
assert(i != ++i2);
BOOST_TEST(i == i1++);
BOOST_TEST(i != ++i2);
trivial_iterator_test(i, i1, v1);
trivial_iterator_test(i, i2, v1);
++i;
assert(i == i1);
assert(i == i2);
BOOST_TEST(i == i1);
BOOST_TEST(i == i2);
++i1;
++i2;
@ -192,15 +194,15 @@ void bidirectional_iterator_test(Iterator i, T v1, T v2)
Iterator i1 = i, i2 = i;
assert(i == i1--);
assert(i != --i2);
BOOST_TEST(i == i1--);
BOOST_TEST(i != --i2);
trivial_iterator_test(i, i1, v2);
trivial_iterator_test(i, i2, v2);
--i;
assert(i == i1);
assert(i == i2);
BOOST_TEST(i == i1);
BOOST_TEST(i == i2);
++i1;
++i2;
@ -224,30 +226,30 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
boost::ignore_unused<value_type>();
for (c = 0; c < N-1; ++c) {
assert(i == j + c);
assert(*i == vals[c]);
assert(*i == boost::implicit_cast<value_type>(j[c]));
assert(*i == *(j + c));
assert(*i == *(c + j));
BOOST_TEST(i == j + c);
BOOST_TEST(*i == vals[c]);
BOOST_TEST(*i == boost::implicit_cast<value_type>(j[c]));
BOOST_TEST(*i == *(j + c));
BOOST_TEST(*i == *(c + j));
++i;
assert(i > j);
assert(i >= j);
assert(j <= i);
assert(j < i);
BOOST_TEST(i > j);
BOOST_TEST(i >= j);
BOOST_TEST(j <= i);
BOOST_TEST(j < i);
}
Iterator k = j + N - 1;
for (c = 0; c < N-1; ++c) {
assert(i == k - c);
assert(*i == vals[N - 1 - c]);
assert(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
BOOST_TEST(i == k - c);
BOOST_TEST(*i == vals[N - 1 - c]);
BOOST_TEST(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
Iterator q = k - c;
boost::ignore_unused(q);
assert(*i == *q);
assert(i > j);
assert(i >= j);
assert(j <= i);
assert(j < i);
BOOST_TEST(*i == *q);
BOOST_TEST(i > j);
BOOST_TEST(i >= j);
BOOST_TEST(j <= i);
BOOST_TEST(j < i);
--i;
}
}
@ -256,16 +258,16 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
template <class Iterator, class ConstIterator>
void const_nonconst_iterator_test(Iterator i, ConstIterator j)
{
assert(i != j);
assert(j != i);
BOOST_TEST(i != j);
BOOST_TEST(j != i);
ConstIterator k(i);
assert(k == i);
assert(i == k);
BOOST_TEST(k == i);
BOOST_TEST(i == k);
k = i;
assert(k == i);
assert(i == k);
BOOST_TEST(k == i);
BOOST_TEST(i == k);
boost::ignore_unused(k);
}