// (C) Copyright Jeremy Siek 2002. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef ACTIV_BOOST_ITERATOR_CONCEPTS_HPP #define ACTIV_BOOST_ITERATOR_CONCEPTS_HPP #include #include #include #include #include #include #include #include #include // Use boost/limits to work around missing limits headers on some compilers #include #include #include #include #include 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. //=========================================================================== // Iterator Access Concepts ACTIV_BOOST_concept(ReadableIterator,(Iterator)) : Boost::Assignable , Boost::CopyConstructible { typedef ACTIV_BOOST_DEDUCED_TYPENAME std::iterator_traits::value_type value_type; typedef ACTIV_BOOST_DEDUCED_TYPENAME std::iterator_traits::reference reference; ACTIV_BOOST_CONCEPT_USAGE(ReadableIterator) { value_type v = *i; Boost::ignore_unused_variable_warning(v); } private: Iterator i; }; template < typename Iterator , typename ValueType = ACTIV_BOOST_DEDUCED_TYPENAME std::iterator_traits::value_type > struct WritableIterator : Boost::CopyConstructible { ACTIV_BOOST_CONCEPT_USAGE(WritableIterator) { *i = v; } private: ValueType v; Iterator i; }; template < typename Iterator , typename ValueType = ACTIV_BOOST_DEDUCED_TYPENAME std::iterator_traits::value_type > struct WritableIteratorConcept : WritableIterator {}; ACTIV_BOOST_concept(SwappableIterator,(Iterator)) { ACTIV_BOOST_CONCEPT_USAGE(SwappableIterator) { std::iter_swap(i1, i2); } private: Iterator i1; Iterator i2; }; ACTIV_BOOST_concept(LvalueIterator,(Iterator)) { typedef typename std::iterator_traits::value_type value_type; ACTIV_BOOST_CONCEPT_USAGE(LvalueIterator) { value_type& r = const_cast(*i); Boost::ignore_unused_variable_warning(r); } private: Iterator i; }; //=========================================================================== // Iterator Traversal Concepts ACTIV_BOOST_concept(IncrementableIterator,(Iterator)) : Boost::Assignable , Boost::CopyConstructible { typedef typename Boost::iterator_traversal::type traversal_category; ACTIV_BOOST_CONCEPT_ASSERT(( Boost::Convertible< traversal_category , Boost::incrementable_traversal_tag >)); ACTIV_BOOST_CONCEPT_USAGE(IncrementableIterator) { ++i; (void)i++; } private: Iterator i; }; ACTIV_BOOST_concept(SinglePassIterator,(Iterator)) : IncrementableIterator , Boost::EqualityComparable { ACTIV_BOOST_CONCEPT_ASSERT(( Boost::Convertible< ACTIV_BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category , Boost::single_pass_traversal_tag > )); }; ACTIV_BOOST_concept(ForwardTraversal,(Iterator)) : SinglePassIterator , Boost::DefaultConstructible { typedef typename std::iterator_traits::difference_type difference_type; ACTIV_BOOST_MPL_ASSERT((Boost::is_integral)); ACTIV_BOOST_MPL_ASSERT_RELATION(std::numeric_limits::is_signed, ==, true); ACTIV_BOOST_CONCEPT_ASSERT(( Boost::Convertible< ACTIV_BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category , Boost::forward_traversal_tag > )); }; ACTIV_BOOST_concept(BidirectionalTraversal,(Iterator)) : ForwardTraversal { ACTIV_BOOST_CONCEPT_ASSERT(( Boost::Convertible< ACTIV_BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category , Boost::bidirectional_traversal_tag > )); ACTIV_BOOST_CONCEPT_USAGE(BidirectionalTraversal) { --i; (void)i--; } private: Iterator i; }; ACTIV_BOOST_concept(RandomAccessTraversal,(Iterator)) : BidirectionalTraversal { ACTIV_BOOST_CONCEPT_ASSERT(( Boost::Convertible< ACTIV_BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category , Boost::random_access_traversal_tag > )); ACTIV_BOOST_CONCEPT_USAGE(RandomAccessTraversal) { i += n; i = i + n; i = n + i; i -= n; i = i - n; n = i - j; } private: typename BidirectionalTraversal::difference_type n; Iterator i, j; }; //=========================================================================== // Iterator Interoperability 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; 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) { bool b; typename std::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&, Iterator2 const&, Boost::single_pass_traversal_tag, Boost::single_pass_traversal_tag) { } } // namespace detail ACTIV_BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator)) { private: typedef typename Boost::iterators::pure_iterator_traversal::type traversal_category; typedef typename Boost::iterators::pure_iterator_traversal::type const_traversal_category; public: ACTIV_BOOST_CONCEPT_ASSERT((SinglePassIterator)); ACTIV_BOOST_CONCEPT_ASSERT((SinglePassIterator)); ACTIV_BOOST_CONCEPT_USAGE(InteroperableIterator) { 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; }; } // namespace Boost_concepts #include #endif // ACTIV_BOOST_ITERATOR_CONCEPTS_HPP