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

cleanup, works on more compilers

Browse Source 
[SVN r665]
This commit is contained in:
Dave Abrahams
2002-11-07 01:21:14 +00:00
parent 62f9e72e24
commit 7ee6923867
2 changed files with 44 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
include/boost/iterator/iterator_categories.hpp
View File

@@ -169,15 +169,14 @@ namespace boost {
template <class T>
type_traits::yes_type is_new_iter_cat(T*, typename T::traversal* = 0) { }
type_traits::yes_type is_new_iter_cat(T*, BOOST_DEDUCED_TYPENAME T::traversal* = 0);
type_traits::no_type is_new_iter_cat(...) { }
type_traits::no_type is_new_iter_cat(...);
template <class Tag>
struct is_new_iterator_tag
{
static Tag* t;
enum { value = sizeof(is_new_iter_cat(t)) == sizeof(type_traits::yes_type) };
enum { value = (sizeof(is_new_iter_cat((Tag*)0)) == sizeof(type_traits::yes_type)) };
};
#endif
@@ -209,23 +208,22 @@ namespace boost {
template <class CategoryTag, class Value>
struct return_category_tag
: mpl::apply_if<
is_new_iterator_tag<CategoryTag>
, get_return_category<CategoryTag>
, iter_category_to_return<CategoryTag, Value>
>
{
typedef typename
mpl::apply_if<
is_new_iterator_tag<CategoryTag>
, get_return_category<CategoryTag>
, iter_category_to_return<CategoryTag, Value>
>::type type;
};
template <class CategoryTag, class Value>
struct traversal_category_tag
{
typedef typename
mpl::apply_if<
: mpl::apply_if<
is_new_iterator_tag<CategoryTag>
, get_traversal_category<CategoryTag>
, iter_category_to_return<CategoryTag, Value>
>::type type;
>
{
};
} // namespace detail

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

@@ -12,11 +12,26 @@
#include <boost/type_traits/conversion_traits.hpp>
#include <boost/static_assert.hpp>
// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
#include <boost/detail/iterator.hpp>
namespace boost_concepts {
// Used a different namespace here (instead of "boost") so that the
// concept descriptions do not take for granted the names in
// namespace boost.
// We use this in place of STATIC_ASSERT((is_convertible<...>))
// because some compilers (CWPro7.x) can't detect convertibility.
//
// Of course, that just gets us a different error at the moment with
// some tests, since new iterator category deduction still depends
// on convertibility detection. We might need some specializations
// to support this compiler.
template <class Target, class Source>
struct static_assert_base_and_derived
{
static_assert_base_and_derived(Target* x = (Source*)0) {}
};
//===========================================================================
// Iterator Access Concepts
@@ -24,8 +39,8 @@ namespace boost_concepts {
template <typename Iterator>
class ReadableIteratorConcept {
public:
typedef typename std::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference;
typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
typedef typename boost::return_category<Iterator>::type return_category;
void constraints() {
@@ -33,9 +48,8 @@ namespace boost_concepts {
boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
boost::function_requires<
boost::DefaultConstructibleConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
boost::readable_iterator_tag*>::value));
static_assert_base_and_derived<boost::readable_iterator_tag, return_category>();
reference r = *i; // or perhaps read(x)
value_type v(r);
@@ -55,8 +69,7 @@ namespace boost_concepts {
boost::function_requires<
boost::DefaultConstructibleConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
boost::writable_iterator_tag*>::value));
static_assert_base_and_derived<boost::writable_iterator_tag, return_category>();
*i = v; // a good alternative could be something like write(x, v)
}
@@ -67,15 +80,14 @@ namespace boost_concepts {
template <typename Iterator>
class ConstantLvalueIteratorConcept {
public:
typedef typename std::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference;
typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
typedef typename boost::return_category<Iterator>::type return_category;
void constraints() {
boost::function_requires< ReadableIteratorConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
boost::constant_lvalue_iterator_tag*>::value));
static_assert_base_and_derived<boost::constant_lvalue_iterator_tag, return_category>();
BOOST_STATIC_ASSERT((boost::is_same<reference,
const value_type&>::value));
@@ -89,8 +101,8 @@ namespace boost_concepts {
template <typename Iterator>
class MutableLvalueIteratorConcept {
public:
typedef typename std::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference;
typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
typedef typename boost::return_category<Iterator>::type return_category;
void constraints() {
@@ -98,8 +110,7 @@ namespace boost_concepts {
boost::function_requires<
WritableIteratorConcept<Iterator, value_type> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
boost::mutable_lvalue_iterator_tag*>::value));
static_assert_base_and_derived<boost::mutable_lvalue_iterator_tag, return_category>();
BOOST_STATIC_ASSERT((boost::is_same<reference, value_type&>::value));
@@ -123,8 +134,8 @@ namespace boost_concepts {
boost::function_requires<
boost::DefaultConstructibleConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*,
boost::forward_traversal_tag*>::value));
static_assert_base_and_derived<boost::forward_traversal_tag, traversal_category>();
++i;
(void)i++;
}
@@ -139,8 +150,7 @@ namespace boost_concepts {
void constraints() {
boost::function_requires< ForwardTraversalConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*,
boost::bidirectional_traversal_tag*>::value));
static_assert_base_and_derived<boost::bidirectional_traversal_tag, traversal_category>();
--i;
(void)i--;
@@ -152,14 +162,14 @@ namespace boost_concepts {
class RandomAccessTraversalConcept {
public:
typedef typename boost::traversal_category<Iterator>::type traversal_category;
typedef typename std::iterator_traits<Iterator>::difference_type
typedef typename boost::detail::iterator_traits<Iterator>::difference_type
difference_type;
void constraints() {
boost::function_requires< BidirectionalTraversalConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*,
boost::random_access_traversal_tag*>::value));
static_assert_base_and_derived<boost::random_access_traversal_tag, traversal_category>();
i += n;
i = i + n;