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

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

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

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

@@ -12,11 +12,26 @@
#include <boost/type_traits/conversion_traits.hpp> #include <boost/type_traits/conversion_traits.hpp>
#include <boost/static_assert.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 { namespace boost_concepts {
// Used a different namespace here (instead of "boost") so that the // Used a different namespace here (instead of "boost") so that the
// concept descriptions do not take for granted the names in // concept descriptions do not take for granted the names in
// namespace boost. // 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 // Iterator Access Concepts
@@ -24,8 +39,8 @@ namespace boost_concepts {
template <typename Iterator> template <typename Iterator>
class ReadableIteratorConcept { class ReadableIteratorConcept {
public: public:
typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference; typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
typedef typename boost::return_category<Iterator>::type return_category; typedef typename boost::return_category<Iterator>::type return_category;
void constraints() { void constraints() {
@@ -34,8 +49,7 @@ namespace boost_concepts {
boost::function_requires< boost::function_requires<
boost::DefaultConstructibleConcept<Iterator> >(); boost::DefaultConstructibleConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, static_assert_base_and_derived<boost::readable_iterator_tag, return_category>();
boost::readable_iterator_tag*>::value));
reference r = *i; // or perhaps read(x) reference r = *i; // or perhaps read(x)
value_type v(r); value_type v(r);
@@ -55,8 +69,7 @@ namespace boost_concepts {
boost::function_requires< boost::function_requires<
boost::DefaultConstructibleConcept<Iterator> >(); boost::DefaultConstructibleConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, static_assert_base_and_derived<boost::writable_iterator_tag, return_category>();
boost::writable_iterator_tag*>::value));
*i = v; // a good alternative could be something like write(x, v) *i = v; // a good alternative could be something like write(x, v)
} }
@@ -67,15 +80,14 @@ namespace boost_concepts {
template <typename Iterator> template <typename Iterator>
class ConstantLvalueIteratorConcept { class ConstantLvalueIteratorConcept {
public: public:
typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference; typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
typedef typename boost::return_category<Iterator>::type return_category; typedef typename boost::return_category<Iterator>::type return_category;
void constraints() { void constraints() {
boost::function_requires< ReadableIteratorConcept<Iterator> >(); boost::function_requires< ReadableIteratorConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, static_assert_base_and_derived<boost::constant_lvalue_iterator_tag, return_category>();
boost::constant_lvalue_iterator_tag*>::value));
BOOST_STATIC_ASSERT((boost::is_same<reference, BOOST_STATIC_ASSERT((boost::is_same<reference,
const value_type&>::value)); const value_type&>::value));
@@ -89,8 +101,8 @@ namespace boost_concepts {
template <typename Iterator> template <typename Iterator>
class MutableLvalueIteratorConcept { class MutableLvalueIteratorConcept {
public: public:
typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference; typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
typedef typename boost::return_category<Iterator>::type return_category; typedef typename boost::return_category<Iterator>::type return_category;
void constraints() { void constraints() {
@@ -98,8 +110,7 @@ namespace boost_concepts {
boost::function_requires< boost::function_requires<
WritableIteratorConcept<Iterator, value_type> >(); WritableIteratorConcept<Iterator, value_type> >();
BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, static_assert_base_and_derived<boost::mutable_lvalue_iterator_tag, return_category>();
boost::mutable_lvalue_iterator_tag*>::value));
BOOST_STATIC_ASSERT((boost::is_same<reference, value_type&>::value)); BOOST_STATIC_ASSERT((boost::is_same<reference, value_type&>::value));
@@ -123,8 +134,8 @@ namespace boost_concepts {
boost::function_requires< boost::function_requires<
boost::DefaultConstructibleConcept<Iterator> >(); boost::DefaultConstructibleConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, static_assert_base_and_derived<boost::forward_traversal_tag, traversal_category>();
boost::forward_traversal_tag*>::value));
++i; ++i;
(void)i++; (void)i++;
} }
@@ -139,8 +150,7 @@ namespace boost_concepts {
void constraints() { void constraints() {
boost::function_requires< ForwardTraversalConcept<Iterator> >(); boost::function_requires< ForwardTraversalConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, static_assert_base_and_derived<boost::bidirectional_traversal_tag, traversal_category>();
boost::bidirectional_traversal_tag*>::value));
--i; --i;
(void)i--; (void)i--;
@@ -152,14 +162,14 @@ namespace boost_concepts {
class RandomAccessTraversalConcept { class RandomAccessTraversalConcept {
public: public:
typedef typename boost::traversal_category<Iterator>::type traversal_category; 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; difference_type;
void constraints() { void constraints() {
boost::function_requires< BidirectionalTraversalConcept<Iterator> >(); boost::function_requires< BidirectionalTraversalConcept<Iterator> >();
BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, static_assert_base_and_derived<boost::random_access_traversal_tag, traversal_category>();
boost::random_access_traversal_tag*>::value));
i += n; i += n;
i = i + n; i = i + n;