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

made some changes to InteroperableIteratorConcept to match the current

Browse Source 
docs, as per suggestions from Dave and Thomas


[SVN r21718]
This commit is contained in:
Jeremy Siek
2004-01-14 03:44:45 +00:00
parent a0bb423311
commit 2d1e40bd20
2 changed files with 60 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -30,7 +30,8 @@ namespace boost {
struct no_traversal_tag {}; struct no_traversal_tag {};
struct incrementable_traversal_tag {}; struct incrementable_traversal_tag
: no_traversal_tag {};
struct single_pass_traversal_tag struct single_pass_traversal_tag
: incrementable_traversal_tag {}; : incrementable_traversal_tag {};

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

@ -253,78 +253,42 @@ namespace boost_concepts {
//=========================================================================== //===========================================================================
// Iterator Interoperability Concept // Iterator Interoperability Concept
namespace detail namespace detail
{
template <typename TraversalTag>
struct Operations;
template <>
struct Operations<boost::incrementable_traversal_tag>
{ {
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
{ {
// no interoperability constraints bool b;
} b = i1 == i2;
}; b = i1 != i2;
b = i2 == i1;
b = i2 != i1;
}
template <>
struct Operations<boost::single_pass_traversal_tag>
{
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2,
boost::random_access_traversal_tag, boost::random_access_traversal_tag)
{ {
Operations<boost::incrementable_traversal_tag>::constraints(i1, i2); bool b;
i1 == i2; typename boost::detail::iterator_traits<Iterator2>::difference_type n;
i1 != i2; b = i1 < i2;
b = i1 <= i2;
b = i1 > i2;
b = i1 >= i2;
n = i1 - i2;
i2 == i1; b = i2 < i1;
i2 != i1; b = i2 <= i1;
b = i2 > i1;
b = i2 >= i1;
n = i2 - i1;
} }
};
template <>
struct Operations<boost::forward_traversal_tag>
{
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2) void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2,
{ boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
Operations<boost::single_pass_traversal_tag>::constraints(i1, i2); { }
}
};
template <>
struct Operations<boost::bidirectional_traversal_tag>
{
template <typename Iterator1, typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2)
{
Operations<boost::forward_traversal_tag>::constraints(i1, i2);
}
};
template <>
struct Operations<boost::random_access_traversal_tag>
{
template <typename Iterator1, typename Iterator2>
static void constraints(Iterator1 const& i1, Iterator2 const& i2)
{
Operations<boost::bidirectional_traversal_tag>::constraints(i1, i2);
i1 < i2;
i1 <= i2;
i1 > i2;
i1 >= i2;
i1 - i2;
i2 < i1;
i2 <= i1;
i2 > i1;
i2 >= i1;
i2 - i1;
}
};
} // namespace detail } // namespace detail
@ -338,37 +302,21 @@ namespace detail
>::type >::type
>::type traversal_category; >::type traversal_category;
typedef typename
boost::detail::iterator_traits<Iterator>::difference_type
difference_type;
typedef typename boost::detail::pure_traversal_tag< typedef typename boost::detail::pure_traversal_tag<
typename boost::iterator_traversal< typename boost::iterator_traversal<
ConstIterator ConstIterator
>::type >::type
>::type const_traversal_category; >::type const_traversal_category;
typedef typename
boost::detail::iterator_traits<ConstIterator>::difference_type
const_difference_type;
void constraints() void constraints()
{ {
boost::function_requires< SinglePassIteratorConcept<Iterator> >(); boost::function_requires< SinglePassIteratorConcept<Iterator> >();
boost::function_requires< SinglePassIteratorConcept<ConstIterator> >(); boost::function_requires< SinglePassIteratorConcept<ConstIterator> >();
BOOST_STATIC_ASSERT( detail::interop_single_pass_constraints(i, ci);
(boost::is_same< difference_type, const_difference_type>::value) detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
);
BOOST_STATIC_ASSERT(
(boost::is_same< traversal_category, const_traversal_category>::value)
);
detail::Operations<traversal_category>::constraints(i, ci);
ci = i; ci = i;
} }
Iterator i; Iterator i;
ConstIterator ci; ConstIterator ci;