boost/range/concepts.hpp

   1 // Boost.Range library concept checks
   2 //
   3 //  Copyright Daniel Walker 2006. Use, modification and distribution
   4 //  are subject to the Boost Software License, Version 1.0. (See
   5 //  accompanying file LICENSE_1_0.txt or copy at
   6 //  http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8 // For more information, see http://www.boost.org/libs/range/
   9 //
  10
  11 #ifndef BOOST_RANGE_CONCEPTS_HPP
  12 #define BOOST_RANGE_CONCEPTS_HPP
  13
  14 #include <boost/concept_check.hpp>
  15 #include <boost/iterator/iterator_concepts.hpp>
  16 #include <boost/range/begin.hpp>
  17 #include <boost/range/end.hpp>
  18
  19 /*!
  20  * \file
  21  * \brief Concept checks for the Boost Range library.
  22  *
  23  * The structures in this file may be used in conjunction with the
  24  * Boost Concept Check library to insure that the type of a function
  25  * parameter is compatible with a range concept. If not, a meaningful
  26  * compile time error is generated. Checks are provided for the range
  27  * concepts related to iterator traversal categories. For example, the
  28  * following line checks that the type T models the ForwardRange
  29  * concept.
  30  *
  31  * \code
  32  * function_requires<ForwardRangeConcept<T> >();
  33  * \endcode
  34  *
  35  * An additional concept check is required for the value access
  36  * property of the range. For example to check for a
  37  * ForwardReadableRange, the following code is required.
  38  *
  39  * \code
  40  * function_requires<ForwardRangeConcept<T> >();
  41  * function_requires<
  42  *     ReadableIteratorConcept<
  43  *         typename range_iterator<T>::type
  44  *     >
  45  * >();
  46  * \endcode
  47  *
  48  * \see http://www.boost.org/libs/range/doc/range.html for details
  49  * about range concepts.
  50  * \see http://www.boost.org/libs/iterator/doc/iterator_concepts.html
  51  * for details about iterator concepts.
  52  * \see http://www.boost.org/libs/concept_check/concept_check.htm for
  53  * details about concept checks.
  54  */
  55
  56 namespace boost {
  57
  58     //! Check if a type T models the SinglePassRange range concept.
  59     template<typename T>
  60     struct SinglePassRangeConcept
  61     {
  62         typedef typename range_iterator<T const>::type  range_const_iterator;
  63         typedef typename range_iterator<T>::type        range_iterator;
  64
  65         void constraints()
  66         {
  67             function_requires<
  68                 boost_concepts::SinglePassIteratorConcept<
  69                     range_iterator
  70                 >
  71             >();
  72             i = boost::begin(a);
  73             i = boost::end(a);
  74             const_constraints(a);
  75         }
  76
  77         void const_constraints(const T& a)
  78         {
  79             ci = boost::begin(a);
  80             ci = boost::end(a);
  81         }
  82         T a;
  83         range_iterator i;
  84         range_const_iterator ci;
  85     };
  86
  87     //! Check if a type T models the ForwardRange range concept.
  88     template<typename T>
  89     struct ForwardRangeConcept
  90     {
  91         void constraints()
  92         {
  93             function_requires<
  94                 SinglePassRangeConcept<T>
  95             >();
  96             function_requires<
  97                 boost_concepts::ForwardTraversalConcept<
  98                     typename range_iterator<T>::type
  99                 >
 100             >();
 101         }
 102     };
 103
 104     //! Check if a type T models the BidirectionalRange range concept.
 105     template<typename T>
 106     struct BidirectionalRangeConcept
 107     {
 108         void constraints()
 109         {
 110             function_requires<
 111                     ForwardRangeConcept<T>
 112             >();
 113             function_requires<
 114                 boost_concepts::BidirectionalTraversalConcept<
 115                     typename range_iterator<T>::type
 116                 >
 117             >();
 118         }
 119     };
 120
 121     //! Check if a type T models the RandomAccessRange range concept.
 122     template<typename T>
 123     struct RandomAccessRangeConcept
 124     {
 125         void constraints()
 126         {
 127             function_requires<
 128                 BidirectionalRangeConcept<T>
 129             >();
 130             function_requires<
 131                 boost_concepts::RandomAccessTraversalConcept<
 132                     typename range_iterator<T>::type
 133                 >
 134             >();
 135          }
 136     };
 137
 138 } // namespace boost
 139
 140 #endif // BOOST_RANGE_CONCEPTS_HPP