epoc32/include/stdapis/boost/iterator/iterator_concepts.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
     1 // (C) Copyright Jeremy Siek 2002.
     2 // Distributed under the Boost Software License, Version 1.0. (See
     3 // accompanying file LICENSE_1_0.txt or copy at
     4 // http://www.boost.org/LICENSE_1_0.txt)
     5 
     6 #ifndef BOOST_ITERATOR_CONCEPTS_HPP
     7 #define BOOST_ITERATOR_CONCEPTS_HPP
     8 
     9 //  Revision History
    10 //  26 Apr 2003 thw
    11 //       Adapted to new iterator concepts
    12 //  22 Nov 2002 Thomas Witt
    13 //       Added interoperable concept.
    14 
    15 #include <boost/concept_check.hpp>
    16 #include <boost/iterator/iterator_categories.hpp>
    17 
    18 // Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
    19 #include <boost/detail/iterator.hpp>
    20 
    21 #include <boost/type_traits/is_same.hpp>
    22 #include <boost/type_traits/is_integral.hpp>
    23 #include <boost/type_traits/is_convertible.hpp>
    24 
    25 #include <boost/mpl/bool.hpp>
    26 #include <boost/mpl/if.hpp>
    27 #include <boost/mpl/and.hpp>
    28 #include <boost/mpl/or.hpp>
    29 
    30 #include <boost/static_assert.hpp>
    31 
    32 // Use boost/limits to work around missing limits headers on some compilers
    33 #include <boost/limits.hpp>
    34 #include <boost/config.hpp>
    35 
    36 #include <algorithm>
    37 
    38 namespace boost_concepts {
    39   // Used a different namespace here (instead of "boost") so that the
    40   // concept descriptions do not take for granted the names in
    41   // namespace boost.
    42 
    43   // We use this in place of STATIC_ASSERT((is_convertible<...>))
    44   // because some compilers (CWPro7.x) can't detect convertibility.
    45   //
    46   // Of course, that just gets us a different error at the moment with
    47   // some tests, since new iterator category deduction still depends
    48   // on convertibility detection. We might need some specializations
    49   // to support this compiler.
    50   template <class Target, class Source>
    51   struct static_assert_base_and_derived
    52   {
    53       static_assert_base_and_derived(Target* = (Source*)0) {}
    54   };
    55 
    56   //===========================================================================
    57   // Iterator Access Concepts
    58 
    59   template <typename Iterator>
    60   class ReadableIteratorConcept {
    61   public:
    62     typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
    63 
    64     void constraints() {
    65       boost::function_requires< boost::AssignableConcept<Iterator> >();
    66       boost::function_requires< boost::CopyConstructibleConcept<Iterator> >();
    67 
    68       value_type v = *i;
    69       boost::ignore_unused_variable_warning(v);
    70     }
    71     Iterator i;
    72   };
    73   
    74   template <
    75       typename Iterator
    76     , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
    77   >
    78   class WritableIteratorConcept {
    79   public:
    80       
    81     void constraints() {
    82       boost::function_requires< boost::CopyConstructibleConcept<Iterator> >();
    83       *i = v;
    84     }
    85     ValueType v;
    86     Iterator i;
    87   };
    88   
    89   template <typename Iterator>
    90   class SwappableIteratorConcept {
    91   public:
    92 
    93     void constraints() {
    94       std::iter_swap(i1, i2);
    95     }
    96     Iterator i1;
    97     Iterator i2;
    98   };
    99 
   100   template <typename Iterator>
   101   class LvalueIteratorConcept
   102   {
   103    public:
   104       typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
   105       void constraints()
   106       {
   107         value_type& r = const_cast<value_type&>(*i);
   108         boost::ignore_unused_variable_warning(r);
   109       }
   110     Iterator i;
   111   };
   112 
   113   
   114   //===========================================================================
   115   // Iterator Traversal Concepts
   116 
   117   template <typename Iterator>
   118   class IncrementableIteratorConcept {
   119   public:
   120     typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
   121 
   122     void constraints() {
   123       boost::function_requires< boost::AssignableConcept<Iterator> >();
   124       boost::function_requires< boost::CopyConstructibleConcept<Iterator> >();
   125 
   126       BOOST_STATIC_ASSERT(
   127           (boost::is_convertible<
   128                 traversal_category
   129               , boost::incrementable_traversal_tag
   130            >::value
   131           ));
   132 
   133       ++i;
   134       (void)i++;
   135     }
   136     Iterator i;
   137   };
   138 
   139   template <typename Iterator>
   140   class SinglePassIteratorConcept {
   141   public:
   142     typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
   143     typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
   144 
   145     void constraints() {
   146       boost::function_requires< IncrementableIteratorConcept<Iterator> >();
   147       boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
   148 
   149       BOOST_STATIC_ASSERT(
   150           (boost::is_convertible<
   151                 traversal_category
   152               , boost::single_pass_traversal_tag
   153            >::value
   154           ));
   155     }
   156   };
   157 
   158   template <typename Iterator>
   159   class ForwardTraversalConcept {
   160   public:
   161     typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
   162     typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
   163 
   164     void constraints() {
   165       boost::function_requires< SinglePassIteratorConcept<Iterator> >();
   166       boost::function_requires< 
   167         boost::DefaultConstructibleConcept<Iterator> >();
   168 
   169       typedef boost::mpl::and_<
   170         boost::is_integral<difference_type>,
   171         boost::mpl::bool_< std::numeric_limits<difference_type>::is_signed >
   172         > difference_type_is_signed_integral;
   173 
   174       BOOST_STATIC_ASSERT(difference_type_is_signed_integral::value);
   175       BOOST_STATIC_ASSERT(
   176           (boost::is_convertible<
   177                 traversal_category
   178               , boost::forward_traversal_tag
   179            >::value
   180           ));
   181     }
   182   };
   183   
   184   template <typename Iterator>
   185   class BidirectionalTraversalConcept {
   186   public:
   187     typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
   188 
   189     void constraints() {
   190       boost::function_requires< ForwardTraversalConcept<Iterator> >();
   191       
   192       BOOST_STATIC_ASSERT(
   193           (boost::is_convertible<
   194                 traversal_category
   195               , boost::bidirectional_traversal_tag
   196            >::value
   197           ));
   198 
   199       --i;
   200       (void)i--;
   201     }
   202     Iterator i;
   203   };
   204 
   205   template <typename Iterator>
   206   class RandomAccessTraversalConcept {
   207   public:
   208     typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
   209     typedef typename boost::detail::iterator_traits<Iterator>::difference_type
   210       difference_type;
   211 
   212     void constraints() {
   213       boost::function_requires< BidirectionalTraversalConcept<Iterator> >();
   214 
   215       BOOST_STATIC_ASSERT(
   216           (boost::is_convertible<
   217                 traversal_category
   218               , boost::random_access_traversal_tag
   219            >::value
   220           ));
   221       
   222       i += n;
   223       i = i + n;
   224       i = n + i;
   225       i -= n;
   226       i = i - n;
   227       n = i - j;
   228     }
   229     difference_type n;
   230     Iterator i, j;
   231   };
   232 
   233   //===========================================================================
   234   // Iterator Interoperability Concept
   235 
   236   namespace detail
   237   {
   238 
   239     template <typename Iterator1, typename Iterator2>
   240     void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
   241     {
   242       bool b;
   243       b = i1 == i2;
   244       b = i1 != i2;
   245       
   246       b = i2 == i1;
   247       b = i2 != i1;
   248     }
   249     
   250     template <typename Iterator1, typename Iterator2>
   251     void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2,
   252                                          boost::random_access_traversal_tag, boost::random_access_traversal_tag)
   253     {
   254       bool b;
   255       typename boost::detail::iterator_traits<Iterator2>::difference_type n;
   256       b = i1 <  i2;
   257       b = i1 <= i2;
   258       b = i1 >  i2;
   259       b = i1 >= i2;
   260       n = i1 -  i2;
   261       
   262       b = i2 <  i1;
   263       b = i2 <= i1;
   264       b = i2 >  i1;
   265       b = i2 >= i1;
   266       n = i2 -  i1;
   267     }
   268     template <typename Iterator1, typename Iterator2>
   269     void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2,
   270                                          boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
   271     { }
   272 
   273   } // namespace detail
   274 
   275   template <typename Iterator, typename ConstIterator>
   276   class InteroperableIteratorConcept
   277   {
   278   public:
   279       typedef typename boost::detail::pure_traversal_tag<
   280           typename boost::iterator_traversal<
   281               Iterator
   282           >::type
   283       >::type traversal_category;
   284 
   285       typedef typename boost::detail::pure_traversal_tag<
   286           typename boost::iterator_traversal<
   287               ConstIterator
   288           >::type
   289       >::type const_traversal_category;
   290 
   291       void constraints()
   292       {
   293           boost::function_requires< SinglePassIteratorConcept<Iterator> >();
   294           boost::function_requires< SinglePassIteratorConcept<ConstIterator> >();
   295 
   296           detail::interop_single_pass_constraints(i, ci);
   297           detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
   298 
   299           ci = i;
   300       }
   301       Iterator      i;
   302       ConstIterator ci;
   303   };
   304 
   305 } // namespace boost_concepts
   306 
   307 
   308 #endif // BOOST_ITERATOR_CONCEPTS_HPP