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

cleanups, including endline-layout

Browse Source 
[SVN r1064]
This commit is contained in:
Dave Abrahams
2003-02-28 16:45:20 +00:00
parent 060f554fd9
commit 7706a8fffb
6 changed files with 34 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -71,8 +71,9 @@ namespace boost
// ... // ...
// //
// template <class OtherIterator> // template <class OtherIterator>
// adapted_iterator(OtherIterator const& it, // adapted_iterator(
// typename enable_if_convertible<OtherIterator, Iterator>::type* = 0); // OtherIterator const& it
// , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0);
// //
// ... // ...
// }; // };

18
include/boost/iterator/iterator_concepts.hpp
View File

@@ -196,8 +196,7 @@ namespace boost_concepts {
template <> template <>
struct Operations<boost::input_traversal_tag> struct Operations<boost::input_traversal_tag>
{ {
template <typename Iterator1, template <typename Iterator1, typename Iterator2>
typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) static void constraints(Iterator1 const& i1, Iterator2 const& i2)
{ {
i1 == i2; i1 == i2;
@@ -211,8 +210,7 @@ namespace boost_concepts {
template <> template <>
struct Operations<boost::output_traversal_tag> struct Operations<boost::output_traversal_tag>
{ {
template <typename Iterator1, template <typename Iterator1, typename Iterator2>
typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) static void constraints(Iterator1 const& i1, Iterator2 const& i2)
{ {
Operations<boost::input_traversal_tag>::constraints(i1, i2); Operations<boost::input_traversal_tag>::constraints(i1, i2);
@@ -222,8 +220,7 @@ namespace boost_concepts {
template <> template <>
struct Operations<boost::forward_traversal_tag> struct Operations<boost::forward_traversal_tag>
{ {
template <typename Iterator1, template <typename Iterator1, typename Iterator2>
typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) static void constraints(Iterator1 const& i1, Iterator2 const& i2)
{ {
Operations<boost::input_traversal_tag>::constraints(i1, i2); Operations<boost::input_traversal_tag>::constraints(i1, i2);
@@ -233,8 +230,7 @@ namespace boost_concepts {
template <> template <>
struct Operations<boost::bidirectional_traversal_tag> struct Operations<boost::bidirectional_traversal_tag>
{ {
template <typename Iterator1, template <typename Iterator1, typename Iterator2>
typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) static void constraints(Iterator1 const& i1, Iterator2 const& i2)
{ {
Operations<boost::forward_traversal_tag>::constraints(i1, i2); Operations<boost::forward_traversal_tag>::constraints(i1, i2);
@@ -244,8 +240,7 @@ namespace boost_concepts {
template <> template <>
struct Operations<boost::random_access_traversal_tag> struct Operations<boost::random_access_traversal_tag>
{ {
template <typename Iterator1, template <typename Iterator1, typename Iterator2>
typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) static void constraints(Iterator1 const& i1, Iterator2 const& i2)
{ {
Operations<boost::bidirectional_traversal_tag>::constraints(i1, i2); Operations<boost::bidirectional_traversal_tag>::constraints(i1, i2);
@@ -266,8 +261,7 @@ namespace boost_concepts {
} // namespace detail } // namespace detail
template <typename Iterator, template <typename Iterator, typename ConstIterator>
typename ConstIterator>
class InteroperableConcept class InteroperableConcept
{ {
public: public:

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

@@ -99,7 +99,7 @@ namespace boost
} }
template <class Facade1, class Facade2> template <class Facade1, class Facade2>
static bool equal(Facade1 const& f1, Facade2 const& f2, Facade1* = 0, Facade2* = 0) static bool equal(Facade1 const& f1, Facade2 const& f2)
{ {
return f1.equal(f2); return f1.equal(f2);
} }
@@ -111,10 +111,8 @@ namespace boost
} }
template <class Facade1, class Facade2> template <class Facade1, class Facade2>
static typename Facade1::difference_type distance_to(Facade1 const& f1, static typename Facade1::difference_type distance_to(
Facade2 const& f2, Facade1 const& f1, Facade2 const& f2)
Facade1* = 0,
Facade2* = 0)
{ {
return f1.distance_to(f2); return f1.distance_to(f2);
} }

253
include/boost/iterator/iterator_tests.hpp
View File

@@ -1,253 +0,0 @@
#ifndef BOOST_ITERATOR_TESTS_HPP
# define BOOST_ITERATOR_TESTS_HPP
// This is meant to be the beginnings of a comprehensive, generic
// test suite for STL concepts such as iterators and containers.
//
// Revision History:
// 28 Apr 2002 Fixed input iterator requirements.
// For a == b a++ == b++ is no longer required.
// See 24.1.1/3 for details.
// (Thomas Witt)
// 08 Feb 2001 Fixed bidirectional iterator test so that
// --i is no longer a precondition.
// (Jeremy Siek)
// 04 Feb 2001 Added lvalue test, corrected preconditions
// (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
namespace boost {
// use this for the value type
struct dummyT {
dummyT() { }
dummyT(detail::dummy_constructor) { }
dummyT(int x) : m_x(x) { }
int foo() const { return m_x; }
bool operator==(const dummyT& d) const { return m_x == d.m_x; }
int m_x;
};
// Tests whether type Iterator satisfies the requirements for a
// TrivialIterator.
// Preconditions: i != j, *i == val
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);
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
T v = *i;
#else
typename std::iterator_traits<Iterator>::value_type v = *i;
#endif
assert(v == val);
#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());
#endif
k = i;
assert(k == k);
assert(k == i);
assert(k != j);
assert(*k == val);
}
// Preconditions: i != j
template <class Iterator, class T>
void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)
{
*i = val;
trivial_iterator_test(i, j, val);
}
// Preconditions: *i == v1, *++i == v2
template <class Iterator, class T>
void input_iterator_test(Iterator i, T v1, T v2)
{
Iterator i1(i);
assert(i == i1);
assert(!(i != i1));
// I can see no generic way to create an input iterator
// that is in the domain of== of i and != i.
// The following works for istream_iterator but is not
// guaranteed to work for arbitrary input iterators.
//
// Iterator i2;
//
// assert(i != i2);
// assert(!(i == i2));
assert(*i1 == v1);
assert(*i == v1);
// we cannot test for equivalence of (void)++i & (void)i++
// as i is only guaranteed to be single pass.
assert(*i++ == v1);
i1 = i;
assert(i == i1);
assert(!(i != i1));
assert(*i1 == v2);
assert(*i == v2);
// i is dereferencable, so it must be incrementable.
++i;
// how to test for operator-> ?
}
// how to test output iterator?
template <bool is_pointer> struct lvalue_test
{
template <class Iterator> static void check(Iterator)
{
# ifndef BOOST_NO_STD_ITERATOR_TRAITS
typedef typename std::iterator_traits<Iterator>::reference reference;
typedef typename std::iterator_traits<Iterator>::value_type value_type;
# else
typedef typename Iterator::reference reference;
typedef typename Iterator::value_type value_type;
# endif
BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value
|| boost::is_same<reference,const value_type&>::value
));
}
};
# ifdef BOOST_NO_STD_ITERATOR_TRAITS
template <> struct lvalue_test<true> {
template <class T> static void check(T) {}
};
#endif
template <class Iterator, class T>
void forward_iterator_test(Iterator i, T v1, T v2)
{
input_iterator_test(i, v1, v2);
Iterator i1 = i, i2 = i;
assert(i == i1++);
assert(i != ++i2);
trivial_iterator_test(i, i1, v1);
trivial_iterator_test(i, i2, v1);
++i;
assert(i == i1);
assert(i == i2);
++i1;
++i2;
trivial_iterator_test(i, i1, v2);
trivial_iterator_test(i, i2, v2);
// borland doesn't allow non-type template parameters
# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
#endif
}
// Preconditions: *i == v1, *++i == v2
template <class Iterator, class T>
void bidirectional_iterator_test(Iterator i, T v1, T v2)
{
forward_iterator_test(i, v1, v2);
++i;
Iterator i1 = i, i2 = i;
assert(i == i1--);
assert(i != --i2);
trivial_iterator_test(i, i1, v2);
trivial_iterator_test(i, i2, v2);
--i;
assert(i == i1);
assert(i == i2);
++i1;
++i2;
trivial_iterator_test(i, i1, v1);
trivial_iterator_test(i, i2, v1);
}
// mutable_bidirectional_iterator_test
// Preconditions: [i,i+N) is a valid range
template <class Iterator, class TrueVals>
void random_access_iterator_test(Iterator i, int N, TrueVals vals)
{
bidirectional_iterator_test(i, vals[0], vals[1]);
const Iterator j = i;
int c;
for (c = 0; c < N-1; ++c) {
assert(i == j + c);
assert(*i == vals[c]);
assert(*i == j[c]);
assert(*i == *(j + c));
assert(*i == *(c + j));
++i;
assert(i > j);
assert(i >= j);
assert(j <= i);
assert(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 == j[N - 1 - c]);
Iterator q = k - c;
assert(*i == *q);
assert(i > j);
assert(i >= j);
assert(j <= i);
assert(j < i);
--i;
}
}
// Precondition: i != j
template <class Iterator, class ConstIterator>
void const_nonconst_iterator_test(Iterator i, ConstIterator j)
{
assert(i != j);
assert(j != i);
ConstIterator k(i);
assert(k == i);
assert(i == k);
k = i;
assert(k == i);
assert(i == k);
}
} // namespace boost
#endif // BOOST_ITERATOR_TESTS_HPP

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

@@ -305,8 +305,9 @@ template <bool is_pointer> struct lvalue_test
typedef typename Iterator::value_type value_type; typedef typename Iterator::value_type value_type;
# endif # endif
BOOST_STATIC_ASSERT(boost::is_reference<reference>::value); BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value BOOST_STATIC_ASSERT((
|| boost::is_same<reference,const value_type&>::value boost::is_same<reference,value_type&>::value
|| boost::is_same<reference,const value_type&>::value
)); ));
} }
}; };

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

@@ -23,12 +23,16 @@ namespace boost
// is the type used as its traits. // is the type used as its traits.
template <class AdaptableUnaryFunction, class Iterator> template <class AdaptableUnaryFunction, class Iterator>
struct transform_iterator_traits struct transform_iterator_traits
: iterator_traits_adaptor<Iterator : iterator_traits_adaptor<
,typename AdaptableUnaryFunction::result_type Iterator
,typename AdaptableUnaryFunction::result_type , typename AdaptableUnaryFunction::result_type
,typename AdaptableUnaryFunction::result_type* , typename AdaptableUnaryFunction::result_type
,iterator_tag< readable_iterator_tag, , typename AdaptableUnaryFunction::result_type*
typename traversal_category<Iterator>::type > > , iterator_tag<
readable_iterator_tag
, typename traversal_category<Iterator>::type
>
>
{ {
}; };
@@ -45,8 +49,8 @@ namespace boost
{ {
typedef iterator_adaptor< typedef iterator_adaptor<
transform_iterator<AdaptableUnaryFunction, Iterator> transform_iterator<AdaptableUnaryFunction, Iterator>
, Iterator , Iterator
, detail::transform_iterator_traits<AdaptableUnaryFunction,Iterator> , detail::transform_iterator_traits<AdaptableUnaryFunction,Iterator>
> super_t; > super_t;
friend class iterator_core_access; friend class iterator_core_access;
@@ -54,21 +58,22 @@ namespace boost
public: public:
transform_iterator() { } transform_iterator() { }
transform_iterator(Iterator const& x, transform_iterator(Iterator const& x, AdaptableUnaryFunction f)
AdaptableUnaryFunction f)
: super_t(x), m_f(f) { } : super_t(x), m_f(f) { }
template<class OtherIterator> template<class OtherIterator>
transform_iterator( transform_iterator(
transform_iterator<AdaptableUnaryFunction, OtherIterator> const& t transform_iterator<AdaptableUnaryFunction, OtherIterator> const& t
, typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
) )
: super_t(t.base()), m_f(t.functor()) {} : super_t(t.base()), m_f(t.functor()) {}
AdaptableUnaryFunction functor() const { return m_f; } AdaptableUnaryFunction functor() const
{ return m_f; }
private: private:
typename super_t::value_type dereference() const { return m_f(super_t::dereference()); } typename super_t::value_type dereference() const
{ return m_f(super_t::dereference()); }
// Probably should be the initial base class so it can be // Probably should be the initial base class so it can be
// optimized away via EBO if it is an empty class. // optimized away via EBO if it is an empty class.