From f5b644e765c3563c8fbded3b6eec48b6b8460064 Mon Sep 17 00:00:00 2001 From: Dave Abrahams Date: Sat, 29 Apr 2006 20:27:14 +0000 Subject: [PATCH] Fixes for concept checking; use destructors for checking classes, misc cleanup. [SVN r33862] --- .../detail/facade_iterator_category.hpp | 19 +- include/boost/iterator/iterator_concepts.hpp | 334 +++++++++--------- 2 files changed, 171 insertions(+), 182 deletions(-) diff --git a/include/boost/iterator/detail/facade_iterator_category.hpp b/include/boost/iterator/detail/facade_iterator_category.hpp index 6728700..f50aef0 100755 --- a/include/boost/iterator/detail/facade_iterator_category.hpp +++ b/include/boost/iterator/detail/facade_iterator_category.hpp @@ -6,13 +6,12 @@ # include -# include - # include // used in iterator_tag inheritance logic # include # include # include # include +# include # include # include @@ -151,17 +150,17 @@ struct iterator_category_with_traversal // Make sure this isn't used to build any categories where // convertibility to Traversal is redundant. Should just use the // Category element in that case. - BOOST_STATIC_ASSERT( - !(is_convertible< + BOOST_MPL_ASSERT_NOT(( + is_convertible< typename iterator_category_to_traversal::type , Traversal - >::value)); + >)); - BOOST_STATIC_ASSERT(is_iterator_category::value); - BOOST_STATIC_ASSERT(!is_iterator_category::value); - BOOST_STATIC_ASSERT(!is_iterator_traversal::value); + BOOST_MPL_ASSERT((is_iterator_category)); + BOOST_MPL_ASSERT_NOT((is_iterator_category)); + BOOST_MPL_ASSERT_NOT((is_iterator_traversal)); # if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) - BOOST_STATIC_ASSERT(is_iterator_traversal::value); + BOOST_MPL_ASSERT((is_iterator_traversal)); # endif # endif }; @@ -172,7 +171,7 @@ template struct facade_iterator_category_impl { # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - BOOST_STATIC_ASSERT(!is_iterator_category::value); + BOOST_MPL_ASSERT_NOT((is_iterator_category)); # endif typedef typename iterator_facade_default_category< diff --git a/include/boost/iterator/iterator_concepts.hpp b/include/boost/iterator/iterator_concepts.hpp index 4c27964..810e2c2 100644 --- a/include/boost/iterator/iterator_concepts.hpp +++ b/include/boost/iterator/iterator_concepts.hpp @@ -35,79 +35,74 @@ #include -namespace boost_concepts { +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 - struct static_assert_base_and_derived - { - static_assert_base_and_derived(Target* = (Source*)0) {} - }; - //=========================================================================== // Iterator Access Concepts template - class ReadableIteratorConcept { - public: - typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type value_type; + struct ReadableIteratorConcept + : boost::AssignableConcept + , boost::CopyConstructibleConcept - void constraints() { - boost::function_requires< boost::AssignableConcept >(); - boost::function_requires< boost::CopyConstructibleConcept >(); + { + typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type value_type; + typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::reference reference; - value_type v = *i; - boost::ignore_unused_variable_warning(v); - } - Iterator i; + ~ReadableIteratorConcept() + { + + value_type v = *i; + boost::ignore_unused_variable_warning(v); + } + private: + Iterator i; }; template < typename Iterator , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type > - class WritableIteratorConcept { - public: - - void constraints() { - boost::function_requires< boost::CopyConstructibleConcept >(); - *i = v; - } - ValueType v; - Iterator i; + struct WritableIteratorConcept + : boost::CopyConstructibleConcept + { + ~WritableIteratorConcept() + { + *i = v; + } + private: + ValueType v; + Iterator i; }; template - class SwappableIteratorConcept { - public: - - void constraints() { - std::iter_swap(i1, i2); - } - Iterator i1; - Iterator i2; + struct SwappableIteratorConcept + { + ~SwappableIteratorConcept() + { + std::iter_swap(i1, i2); + } + private: + Iterator i1; + Iterator i2; }; template - class LvalueIteratorConcept + struct LvalueIteratorConcept { - public: typedef typename boost::detail::iterator_traits::value_type value_type; - void constraints() + + ~LvalueIteratorConcept() { value_type& r = const_cast(*i); boost::ignore_unused_variable_warning(r); } - Iterator i; + private: + Iterator i; }; @@ -115,119 +110,106 @@ namespace boost_concepts { // Iterator Traversal Concepts template - class IncrementableIteratorConcept { - public: - typedef typename boost::iterator_traversal::type traversal_category; + struct IncrementableIteratorConcept + : boost::AssignableConcept + , boost::CopyConstructibleConcept + { + typedef typename boost::iterator_traversal::type traversal_category; - void constraints() { - boost::function_requires< boost::AssignableConcept >(); - boost::function_requires< boost::CopyConstructibleConcept >(); + ~IncrementableIteratorConcept() + { + BOOST_MPL_ASSERT(( + boost::is_convertible< + traversal_category + , boost::incrementable_traversal_tag + > )); - BOOST_STATIC_ASSERT( - (boost::is_convertible< - traversal_category - , boost::incrementable_traversal_tag - >::value - )); - - ++i; - (void)i++; - } - Iterator i; + ++i; + (void)i++; + } + private: + Iterator i; }; template - class SinglePassIteratorConcept { - public: - typedef typename boost::iterator_traversal::type traversal_category; - typedef typename boost::detail::iterator_traits::difference_type difference_type; + struct SinglePassIteratorConcept + : IncrementableIteratorConcept + , boost::EqualityComparableConcept - void constraints() { - boost::function_requires< IncrementableIteratorConcept >(); - boost::function_requires< boost::EqualityComparableConcept >(); - - BOOST_STATIC_ASSERT( - (boost::is_convertible< - traversal_category - , boost::single_pass_traversal_tag - >::value - )); - } + { + ~SinglePassIteratorConcept() + { + BOOST_MPL_ASSERT(( + boost::is_convertible< + BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category + , boost::single_pass_traversal_tag + > )); + } }; template - class ForwardTraversalConcept { - public: - typedef typename boost::iterator_traversal::type traversal_category; - typedef typename boost::detail::iterator_traits::difference_type difference_type; - - void constraints() { - boost::function_requires< SinglePassIteratorConcept >(); - boost::function_requires< - boost::DefaultConstructibleConcept >(); - - typedef boost::mpl::and_< - boost::is_integral, - boost::mpl::bool_< std::numeric_limits::is_signed > - > difference_type_is_signed_integral; - - BOOST_STATIC_ASSERT(difference_type_is_signed_integral::value); - BOOST_STATIC_ASSERT( - (boost::is_convertible< - traversal_category - , boost::forward_traversal_tag - >::value - )); + struct ForwardTraversalConcept + : SinglePassIteratorConcept + , boost::DefaultConstructibleConcept + { + typedef typename boost::detail::iterator_traits::difference_type difference_type; + + ~ForwardTraversalConcept() + { + BOOST_MPL_ASSERT((boost::is_integral)); + BOOST_MPL_ASSERT_RELATION(std::numeric_limits::is_signed, ==, true); + + BOOST_MPL_ASSERT(( + boost::is_convertible< + BOOST_DEDUCED_TYPENAME ForwardTraversalConcept::traversal_category + , boost::forward_traversal_tag + > )); } }; template - class BidirectionalTraversalConcept { - public: - typedef typename boost::iterator_traversal::type traversal_category; - - void constraints() { - boost::function_requires< ForwardTraversalConcept >(); - - BOOST_STATIC_ASSERT( - (boost::is_convertible< - traversal_category - , boost::bidirectional_traversal_tag - >::value - )); - - --i; - (void)i--; - } - Iterator i; + struct BidirectionalTraversalConcept + : ForwardTraversalConcept + { + ~BidirectionalTraversalConcept() + { + BOOST_MPL_ASSERT(( + boost::is_convertible< + BOOST_DEDUCED_TYPENAME BidirectionalTraversalConcept::traversal_category + , boost::bidirectional_traversal_tag + > )); + + --i; + (void)i--; + } + private: + Iterator i; }; template - class RandomAccessTraversalConcept { - public: - typedef typename boost::iterator_traversal::type traversal_category; - typedef typename boost::detail::iterator_traits::difference_type - difference_type; - - void constraints() { - boost::function_requires< BidirectionalTraversalConcept >(); - - BOOST_STATIC_ASSERT( - (boost::is_convertible< - traversal_category - , boost::random_access_traversal_tag - >::value - )); + struct RandomAccessTraversalConcept + : BidirectionalTraversalConcept + { + public: + ~RandomAccessTraversalConcept() + { + BOOST_MPL_ASSERT(( + boost::is_convertible< + BOOST_DEDUCED_TYPENAME RandomAccessTraversalConcept::traversal_category + , boost::random_access_traversal_tag + > )); + + i += n; + i = i + n; + i = n + i; + i -= n; + i = i - n; + n = i - j; + } - i += n; - i = i + n; - i = n + i; - i -= n; - i = i - n; - n = i - j; - } - difference_type n; - Iterator i, j; + private: + typename BidirectionalTraversalConcept::difference_type n; + Iterator i, j; }; //=========================================================================== @@ -235,47 +217,52 @@ namespace boost_concepts { namespace detail { - template void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2) { - bool b; - b = i1 == i2; - b = i1 != i2; - - b = i2 == i1; - b = i2 != i1; + bool b; + b = i1 == i2; + b = i1 != i2; + + b = i2 == i1; + b = i2 != i1; + boost::ignore_unused_variable_warning(b); } - + template - void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2, - boost::random_access_traversal_tag, boost::random_access_traversal_tag) + void interop_rand_access_constraints( + Iterator1 const& i1, Iterator2 const& i2, + boost::random_access_traversal_tag, boost::random_access_traversal_tag) { - bool b; - typename boost::detail::iterator_traits::difference_type n; - b = i1 < i2; - b = i1 <= i2; - b = i1 > i2; - b = i1 >= i2; - n = i1 - i2; - - b = i2 < i1; - b = i2 <= i1; - b = i2 > i1; - b = i2 >= i1; - n = i2 - i1; + bool b; + typename boost::detail::iterator_traits::difference_type n; + b = i1 < i2; + b = i1 <= i2; + b = i1 > i2; + b = i1 >= i2; + n = i1 - i2; + + b = i2 < i1; + b = i2 <= i1; + b = i2 > i1; + b = i2 >= i1; + n = i2 - i1; + boost::ignore_unused_variable_warning(b); + boost::ignore_unused_variable_warning(n); } + template - void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2, - boost::single_pass_traversal_tag, boost::single_pass_traversal_tag) + void interop_rand_access_constraints( + Iterator1 const&, Iterator2 const&, + boost::single_pass_traversal_tag, boost::single_pass_traversal_tag) { } } // namespace detail template - class InteroperableIteratorConcept + struct InteroperableIteratorConcept { - public: + private: typedef typename boost::detail::pure_traversal_tag< typename boost::iterator_traversal< Iterator @@ -287,17 +274,20 @@ namespace boost_concepts { ConstIterator >::type >::type const_traversal_category; - - void constraints() + + public: + ~InteroperableIteratorConcept() { - boost::function_requires< SinglePassIteratorConcept >(); - boost::function_requires< SinglePassIteratorConcept >(); + BOOST_CONCEPT_ASSERT((SinglePassIteratorConcept)); + BOOST_CONCEPT_ASSERT((SinglePassIteratorConcept)); detail::interop_single_pass_constraints(i, ci); detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category()); ci = i; } + + private: Iterator i; ConstIterator ci; };