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

Fixes for concept checking; use destructors for checking classes, misc cleanup.

Browse Source 
[SVN r33862]
This commit is contained in:
Dave Abrahams
2006-04-29 20:27:14 +00:00
parent 28dd458088
commit f5b644e765
2 changed files with 171 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
include/boost/iterator/detail/facade_iterator_category.hpp
View File

@ -6,13 +6,12 @@
# include <boost/iterator/iterator_categories.hpp> # include <boost/iterator/iterator_categories.hpp>
# include <boost/static_assert.hpp>
# include <boost/mpl/or.hpp> // used in iterator_tag inheritance logic # include <boost/mpl/or.hpp> // used in iterator_tag inheritance logic
# include <boost/mpl/and.hpp> # include <boost/mpl/and.hpp>
# include <boost/mpl/if.hpp> # include <boost/mpl/if.hpp>
# include <boost/mpl/eval_if.hpp> # include <boost/mpl/eval_if.hpp>
# include <boost/mpl/identity.hpp> # include <boost/mpl/identity.hpp>
# include <boost/mpl/assert.hpp>
# include <boost/type_traits/is_same.hpp> # include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_const.hpp> # include <boost/type_traits/is_const.hpp>
@ -151,17 +150,17 @@ struct iterator_category_with_traversal
// Make sure this isn't used to build any categories where // Make sure this isn't used to build any categories where
// convertibility to Traversal is redundant. Should just use the // convertibility to Traversal is redundant. Should just use the
// Category element in that case. // Category element in that case.
BOOST_STATIC_ASSERT( BOOST_MPL_ASSERT_NOT((
!(is_convertible< is_convertible<
typename iterator_category_to_traversal<Category>::type typename iterator_category_to_traversal<Category>::type
, Traversal , Traversal
>::value)); >));
BOOST_STATIC_ASSERT(is_iterator_category<Category>::value); BOOST_MPL_ASSERT((is_iterator_category<Category>));
BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value); BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
BOOST_STATIC_ASSERT(!is_iterator_traversal<Category>::value); BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) # if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
BOOST_STATIC_ASSERT(is_iterator_traversal<Traversal>::value); BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
# endif # endif
# endif # endif
}; };
@ -172,7 +171,7 @@ template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl struct facade_iterator_category_impl
{ {
# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value); BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
# endif # endif
typedef typename iterator_facade_default_category< typedef typename iterator_facade_default_category<

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

@ -35,79 +35,74 @@
#include <algorithm> #include <algorithm>
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* = (Source*)0) {}
};
//=========================================================================== //===========================================================================
// Iterator Access Concepts // Iterator Access Concepts
template <typename Iterator> template <typename Iterator>
class ReadableIteratorConcept { struct ReadableIteratorConcept
public: : boost::AssignableConcept<Iterator>
typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type; , boost::CopyConstructibleConcept<Iterator>
void constraints() { {
boost::function_requires< boost::AssignableConcept<Iterator> >(); typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
boost::function_requires< boost::CopyConstructibleConcept<Iterator> >(); typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;
value_type v = *i; ~ReadableIteratorConcept()
boost::ignore_unused_variable_warning(v); {
}
Iterator i; value_type v = *i;
boost::ignore_unused_variable_warning(v);
}
private:
Iterator i;
}; };
template < template <
typename Iterator typename Iterator
, typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
> >
class WritableIteratorConcept { struct WritableIteratorConcept
public: : boost::CopyConstructibleConcept<Iterator>
{
void constraints() { ~WritableIteratorConcept()
boost::function_requires< boost::CopyConstructibleConcept<Iterator> >(); {
*i = v; *i = v;
} }
ValueType v; private:
Iterator i; ValueType v;
Iterator i;
}; };
template <typename Iterator> template <typename Iterator>
class SwappableIteratorConcept { struct SwappableIteratorConcept
public: {
~SwappableIteratorConcept()
void constraints() { {
std::iter_swap(i1, i2); std::iter_swap(i1, i2);
} }
Iterator i1; private:
Iterator i2; Iterator i1;
Iterator i2;
}; };
template <typename Iterator> template <typename Iterator>
class LvalueIteratorConcept struct LvalueIteratorConcept
{ {
public:
typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type; typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
void constraints()
~LvalueIteratorConcept()
{ {
value_type& r = const_cast<value_type&>(*i); value_type& r = const_cast<value_type&>(*i);
boost::ignore_unused_variable_warning(r); boost::ignore_unused_variable_warning(r);
} }
Iterator i; private:
Iterator i;
}; };
@ -115,119 +110,106 @@ namespace boost_concepts {
// Iterator Traversal Concepts // Iterator Traversal Concepts
template <typename Iterator> template <typename Iterator>
class IncrementableIteratorConcept { struct IncrementableIteratorConcept
public: : boost::AssignableConcept<Iterator>
typedef typename boost::iterator_traversal<Iterator>::type traversal_category; , boost::CopyConstructibleConcept<Iterator>
{
typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
void constraints() { ~IncrementableIteratorConcept()
boost::function_requires< boost::AssignableConcept<Iterator> >(); {
boost::function_requires< boost::CopyConstructibleConcept<Iterator> >(); BOOST_MPL_ASSERT((
boost::is_convertible<
traversal_category
, boost::incrementable_traversal_tag
> ));
BOOST_STATIC_ASSERT( ++i;
(boost::is_convertible< (void)i++;
traversal_category }
, boost::incrementable_traversal_tag private:
>::value Iterator i;
));
++i;
(void)i++;
}
Iterator i;
}; };
template <typename Iterator> template <typename Iterator>
class SinglePassIteratorConcept { struct SinglePassIteratorConcept
public: : IncrementableIteratorConcept<Iterator>
typedef typename boost::iterator_traversal<Iterator>::type traversal_category; , boost::EqualityComparableConcept<Iterator>
typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
void constraints() { {
boost::function_requires< IncrementableIteratorConcept<Iterator> >(); ~SinglePassIteratorConcept()
boost::function_requires< boost::EqualityComparableConcept<Iterator> >(); {
BOOST_MPL_ASSERT((
BOOST_STATIC_ASSERT( boost::is_convertible<
(boost::is_convertible< BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category
traversal_category , boost::single_pass_traversal_tag
, boost::single_pass_traversal_tag > ));
>::value }
));
}
}; };
template <typename Iterator> template <typename Iterator>
class ForwardTraversalConcept { struct ForwardTraversalConcept
public: : SinglePassIteratorConcept<Iterator>
typedef typename boost::iterator_traversal<Iterator>::type traversal_category; , boost::DefaultConstructibleConcept<Iterator>
typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type; {
typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
void constraints() {
boost::function_requires< SinglePassIteratorConcept<Iterator> >(); ~ForwardTraversalConcept()
boost::function_requires< {
boost::DefaultConstructibleConcept<Iterator> >(); BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
typedef boost::mpl::and_<
boost::is_integral<difference_type>, BOOST_MPL_ASSERT((
boost::mpl::bool_< std::numeric_limits<difference_type>::is_signed > boost::is_convertible<
> difference_type_is_signed_integral; BOOST_DEDUCED_TYPENAME ForwardTraversalConcept::traversal_category
, boost::forward_traversal_tag
BOOST_STATIC_ASSERT(difference_type_is_signed_integral::value); > ));
BOOST_STATIC_ASSERT(
(boost::is_convertible<
traversal_category
, boost::forward_traversal_tag
>::value
));
} }
}; };
template <typename Iterator> template <typename Iterator>
class BidirectionalTraversalConcept { struct BidirectionalTraversalConcept
public: : ForwardTraversalConcept<Iterator>
typedef typename boost::iterator_traversal<Iterator>::type traversal_category; {
~BidirectionalTraversalConcept()
void constraints() { {
boost::function_requires< ForwardTraversalConcept<Iterator> >(); BOOST_MPL_ASSERT((
boost::is_convertible<
BOOST_STATIC_ASSERT( BOOST_DEDUCED_TYPENAME BidirectionalTraversalConcept::traversal_category
(boost::is_convertible< , boost::bidirectional_traversal_tag
traversal_category > ));
, boost::bidirectional_traversal_tag
>::value --i;
)); (void)i--;
}
--i; private:
(void)i--; Iterator i;
}
Iterator i;
}; };
template <typename Iterator> template <typename Iterator>
class RandomAccessTraversalConcept { struct RandomAccessTraversalConcept
public: : BidirectionalTraversalConcept<Iterator>
typedef typename boost::iterator_traversal<Iterator>::type traversal_category; {
typedef typename boost::detail::iterator_traits<Iterator>::difference_type public:
difference_type; ~RandomAccessTraversalConcept()
{
void constraints() { BOOST_MPL_ASSERT((
boost::function_requires< BidirectionalTraversalConcept<Iterator> >(); boost::is_convertible<
BOOST_DEDUCED_TYPENAME RandomAccessTraversalConcept::traversal_category
BOOST_STATIC_ASSERT( , boost::random_access_traversal_tag
(boost::is_convertible< > ));
traversal_category
, boost::random_access_traversal_tag i += n;
>::value i = i + n;
)); i = n + i;
i -= n;
i = i - n;
n = i - j;
}
i += n; private:
i = i + n; typename BidirectionalTraversalConcept<Iterator>::difference_type n;
i = n + i; Iterator i, j;
i -= n;
i = i - n;
n = i - j;
}
difference_type n;
Iterator i, j;
}; };
//=========================================================================== //===========================================================================
@ -235,47 +217,52 @@ namespace boost_concepts {
namespace detail namespace detail
{ {
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2) void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
{ {
bool b; bool b;
b = i1 == i2; b = i1 == i2;
b = i1 != i2; b = i1 != i2;
b = i2 == i1; b = i2 == i1;
b = i2 != i1; b = i2 != i1;
boost::ignore_unused_variable_warning(b);
} }
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2, void interop_rand_access_constraints(
boost::random_access_traversal_tag, boost::random_access_traversal_tag) Iterator1 const& i1, Iterator2 const& i2,
boost::random_access_traversal_tag, boost::random_access_traversal_tag)
{ {
bool b; bool b;
typename boost::detail::iterator_traits<Iterator2>::difference_type n; typename boost::detail::iterator_traits<Iterator2>::difference_type n;
b = i1 < i2; b = i1 < i2;
b = i1 <= i2; b = i1 <= i2;
b = i1 > i2; b = i1 > i2;
b = i1 >= i2; b = i1 >= i2;
n = i1 - i2; n = i1 - i2;
b = i2 < i1; b = i2 < i1;
b = i2 <= i1; b = i2 <= i1;
b = i2 > i1; b = i2 > i1;
b = i2 >= i1; b = i2 >= i1;
n = i2 - i1; n = i2 - i1;
boost::ignore_unused_variable_warning(b);
boost::ignore_unused_variable_warning(n);
} }
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2, void interop_rand_access_constraints(
boost::single_pass_traversal_tag, boost::single_pass_traversal_tag) Iterator1 const&, Iterator2 const&,
boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
{ } { }
} // namespace detail } // namespace detail
template <typename Iterator, typename ConstIterator> template <typename Iterator, typename ConstIterator>
class InteroperableIteratorConcept struct InteroperableIteratorConcept
{ {
public: private:
typedef typename boost::detail::pure_traversal_tag< typedef typename boost::detail::pure_traversal_tag<
typename boost::iterator_traversal< typename boost::iterator_traversal<
Iterator Iterator
@ -287,17 +274,20 @@ namespace boost_concepts {
ConstIterator ConstIterator
>::type >::type
>::type const_traversal_category; >::type const_traversal_category;
void constraints() public:
~InteroperableIteratorConcept()
{ {
boost::function_requires< SinglePassIteratorConcept<Iterator> >(); BOOST_CONCEPT_ASSERT((SinglePassIteratorConcept<Iterator>));
boost::function_requires< SinglePassIteratorConcept<ConstIterator> >(); BOOST_CONCEPT_ASSERT((SinglePassIteratorConcept<ConstIterator>));
detail::interop_single_pass_constraints(i, ci); detail::interop_single_pass_constraints(i, ci);
detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category()); detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
ci = i; ci = i;
} }
private:
Iterator i; Iterator i;
ConstIterator ci; ConstIterator ci;
}; };