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

Updated pointee and indirect_reference so that pointee represents the

Browse Source 
immutability of the pointed-to type via const qualification.  The
pointee of a proxy-based iterator will be const qualified unless a
mutable reference to the value_type can be bound to the returned
proxy.

Added a test for pointee

Fixed iterator_facade so operator[] result type computation didn't
cause a problem with abstract types.

Updated iterator_facade operator[] docs for accuracy.

Allowed Borland to simply fail the indirect_iterator_member_types test
because of its lame const-dropping, instead of trying to work around
it.


[SVN r21579]
This commit is contained in:
Dave Abrahams
2004-01-11 00:03:09 +00:00
parent dd5fb425fa
commit 6c62f31f0a
7 changed files with 150 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/Jamfile
View File

@@ -29,6 +29,7 @@ test-suite iterator
# These tests should work for just about everything.
[ compile is_lvalue_iterator.cpp ]
[ compile is_readable_iterator.cpp ]
[ compile pointee.cpp ]
[ run unit_tests.cpp ]
[ run concept_tests.cpp ]

36
test/indirect_iterator_member_types.cpp
View File

@@ -30,19 +30,8 @@ struct my_ptr {
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
// Borland 5.6.4 and earlier drop const all over the place, so this
// test will fail in the lines marked with (**)
int main()
{
@@ -50,7 +39,7 @@ int main()
typedef boost::indirect_iterator<int**> Iter;
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, int&);
STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
@@ -62,31 +51,26 @@ int main()
typedef boost::indirect_iterator<int const**> Iter;
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
STATIC_ASSERT_SAME(Iter::pointer, const int*); // (**)
}
{
typedef boost::indirect_iterator<int**, int> Iter;
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, int&);
STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::pointer, int*);
}
{
typedef boost::indirect_iterator<int**, const int> Iter;
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
STATIC_ASSERT_SAME(Iter::pointer, const int*); // (**)
}
{
typedef boost::indirect_iterator<my_ptr*> Iter;
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::reference, const zow&); // (**)
STATIC_ASSERT_SAME(Iter::pointer, const zow*); // (**)
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
@@ -98,7 +82,7 @@ int main()
typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;
STATIC_ASSERT_SAME(Iter::value_type, int);
STATIC_ASSERT_SAME(Iter::reference, long&);
STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::difference_type, short);
}
return 0;

72
test/pointee.cpp Executable file
View File

@@ -0,0 +1,72 @@
// Copyright David Abrahams 2004. Use, modification and distribution is
// subject to 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)
#include <boost/pointee.hpp>
#include <boost/type_traits/add_const.hpp>
#include "static_assert_same.hpp"
#include <memory>
#include <list>
template <class T, class Ref>
struct proxy_ptr
{
typedef T element_type;
struct proxy
{
operator Ref() const;
};
proxy operator*() const;
};
template <class T>
struct proxy_ref_ptr : proxy_ptr<T,T&>
{
};
template <class T>
struct proxy_value_ptr : proxy_ptr<T,T>
{
typedef typename boost::add_const<T>::type element_type;
};
struct X {
template <class T> X(T const&);
template <class T> operator T&() const;
};
BOOST_TT_BROKEN_COMPILER_SPEC(X)
int main()
{
STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int> >::type, int);
STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<X> >::type, X);
STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int const> >::type, int const);
STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<X const> >::type, X const);
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int> >::type, int const);
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X> >::type, X const);
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int const> >::type, int const);
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X const> >::type, X const);
STATIC_ASSERT_SAME(boost::pointee<int*>::type, int);
STATIC_ASSERT_SAME(boost::pointee<int const*>::type, int const);
STATIC_ASSERT_SAME(boost::pointee<X*>::type, X);
STATIC_ASSERT_SAME(boost::pointee<X const*>::type, X const);
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int> >::type, int);
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X> >::type, X);
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int const> >::type, int const);
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X const> >::type, X const);
STATIC_ASSERT_SAME(boost::pointee<std::list<int>::iterator >::type, int);
STATIC_ASSERT_SAME(boost::pointee<std::list<X>::iterator >::type, X);
STATIC_ASSERT_SAME(boost::pointee<std::list<int>::const_iterator >::type, int const);
STATIC_ASSERT_SAME(boost::pointee<std::list<X>::const_iterator >::type, X const);
return 0;
}