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

Added traits:

Browse Source 
is_incrementable.hpp: checks whether ++x is well-formed

   pointee.hpp: value_type of iterators or smart pointers

   indirect_reference.hpp: reference type of iterators or smart pointers

indirect_iterator.hpp
indirect_iterator_member_types.cpp

   Use pointee/indirect_reference to select value/reference type.

iterator_concepts.hpp: Fixed interoperable test.  Hardly tests enough, but it's a start

minimum_category.hpp: Better error messages for vc6

indirect_iterator_test.cpp: Workarounds for compilers without SFINAE

static_assert_same.hpp: Informative error reports; added a macro.

zip_iterator_test.hpp: Added missing #include

Jamfile: made zip_iterator test pass with vc6/stlport


[SVN r21514]
This commit is contained in:
Dave Abrahams
2004-01-06 17:35:36 +00:00
parent f716d705c5
commit 20b31d1cca
9 changed files with 177 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/Jamfile
View File

@ -18,7 +18,13 @@ test-suite iterator
# compilation problems.
[ run is_convertible_fail.cpp ]
[ run zip_iterator_test.cpp ]
[ run zip_iterator_test.cpp
: : :
# stlport's debug mode generates long symbols which overwhelm
# vc6
<msvc-stlport><*><runtime-build>release
]
# These tests should work for just about everything.
[ compile is_lvalue_iterator.cpp ]

77
test/indirect_iterator_member_types.cpp
View File

@ -14,26 +14,44 @@
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/static_assert.hpp>
#include "static_assert_same.hpp"
#include <boost/type_traits/same_traits.hpp>
struct zow { };
struct my_ptr {
typedef zow value_type;
typedef const zow& reference;
typedef const zow* pointer;
typedef void difference_type;
typedef boost::no_traversal_tag iterator_category;
typedef zow const element_type;
// typedef const zow& reference;
// typedef const zow* pointer;
// typedef void difference_type;
// typedef boost::no_traversal_tag iterator_category;
};
BOOST_TT_BROKEN_COMPILER_SPEC(my_ptr)
BOOST_TT_BROKEN_COMPILER_SPEC(zow)
#ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
# define STATIC_ASSERT_SAME_POINTER(P1, P2) \
STATIC_ASSERT_SAME( \
boost::remove_const<boost::remove_pointer<P1>::type>::type \
, boost::remove_const<boost::remove_pointer<P2>::type>::type \
)
#else
# define STATIC_ASSERT_SAME_POINTER(P1, P2) STATIC_ASSERT_SAME(P1,P2)
#endif
int main()
{
{
typedef boost::indirect_iterator<int**> Iter;
BOOST_STATIC_ASSERT((boost::is_same<Iter::value_type, int>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::reference, int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::pointer, int*>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::difference_type, std::ptrdiff_t>::value));
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, int&);
STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
std::random_access_iterator_tag>::value));
@ -42,28 +60,34 @@ int main()
}
{
typedef boost::indirect_iterator<int const**> Iter;
BOOST_STATIC_ASSERT((boost::is_same<Iter::value_type, int>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::reference, const int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::pointer, const int*>::value));
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, const int&);
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // Borland drops const all over the place
STATIC_ASSERT_SAME_POINTER(Iter::pointer, const int*);
#endif
}
{
typedef boost::indirect_iterator<int**, int> Iter;
BOOST_STATIC_ASSERT((boost::is_same<Iter::value_type, int>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::reference, int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::pointer, int*>::value));
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, int&);
STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);
}
{
typedef boost::indirect_iterator<int**, const int> Iter;
BOOST_STATIC_ASSERT((boost::is_same<Iter::value_type, int>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::reference, const int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::pointer, const int*>::value));
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, const int&);
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // Borland drops const all over the place
STATIC_ASSERT_SAME_POINTER(Iter::pointer, const int*);
#endif
}
{
typedef boost::indirect_iterator<my_ptr*> Iter;
BOOST_STATIC_ASSERT((boost::is_same<Iter::value_type, zow>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::reference, const zow&>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::pointer, const zow*>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::difference_type, std::ptrdiff_t>::value));
STATIC_ASSERT_SAME(Iter::value_type, zow);
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // Borland drops const all over the place
STATIC_ASSERT_SAME(Iter::reference, const zow&);
STATIC_ASSERT_SAME_POINTER(Iter::pointer, const zow*);
#endif
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
std::random_access_iterator_tag>::value));
@ -72,9 +96,10 @@ int main()
}
{
typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;
BOOST_STATIC_ASSERT((boost::is_same<Iter::value_type, int>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::reference, long&>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::pointer, int*>::value));
BOOST_STATIC_ASSERT((boost::is_same<Iter::difference_type, short>::value));
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, long&);
STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::difference_type, short);
}
return 0;
}

15
test/indirect_iterator_test.cpp
View File

@ -26,6 +26,8 @@
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#include <boost/mpl/aux_/has_xxx.hpp>
#include <boost/type_traits/broken_compiler_spec.hpp>
#include <vector>
#include <stdlib.h>
@ -139,6 +141,10 @@ void more_indirect_iterator_tests()
assert(std::equal(db, de, store.begin()));
}
// element_type detector; defaults to true so the test passes when
// has_xxx isn't implemented
BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_element_type, element_type, true)
int
main()
{
@ -146,6 +152,10 @@ main()
dummyT(3), dummyT(4), dummyT(5) };
const int N = sizeof(array)/sizeof(dummyT);
# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
boost::shared_ptr<dummyT> zz((dummyT*)0); // Why? I don't know, but it suppresses a bad instantiation.
# endif
typedef std::vector<boost::shared_ptr<dummyT> > shared_t;
shared_t shared;
@ -154,9 +164,8 @@ main()
typedef boost::indirect_iterator<shared_t::iterator> iter_t;
BOOST_STATIC_ASSERT(
boost::detail::has_element_type<
boost::shared_ptr<dummyT>
// std::iterator_traits<shared_t::iterator>::value_type
has_element_type<
boost::detail::iterator_traits<shared_t::iterator>::value_type
>::value
);

5
test/static_assert_same.hpp
View File

@ -7,6 +7,7 @@
# define STATIC_ASSERT_SAME_DWA2003530_HPP
# include <boost/type.hpp>
# include <boost/static_assert.hpp>
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T, class U>
@ -32,4 +33,8 @@ struct static_assert_same
{};
#endif
#define STATIC_ASSERT_SAME( T1,T2 ) \
enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \
= static_assert_same<T1,T2>::value }
#endif // STATIC_ASSERT_SAME_DWA2003530_HPP

1
test/zip_iterator_test.cpp
View File

@ -46,6 +46,7 @@
#include <vector>
#include <list>
#include <set>
#include <functional>
#include <boost/tuple/tuple.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/iterator/is_readable_iterator.hpp>