3rdparty/boost/boost/next_prior.hpp

   1 //  Boost next_prior.hpp header file  ---------------------------------------//
   2
   3 //  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003.
   4 //  Copyright (c) Andrey Semashev 2017
   5 //
   6 //  Distributed under the Boost Software License, Version 1.0.
   7 //  (See accompanying file LICENSE_1_0.txt or copy at
   8 //  http://www.boost.org/LICENSE_1_0.txt)
   9
  10 //  See http://www.boost.org/libs/utility for documentation.
  11
  12 //  Revision History
  13 //  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
  14
  15 #ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
  16 #define BOOST_NEXT_PRIOR_HPP_INCLUDED
  17
  18 #include <iterator>
  19 #include <boost/config.hpp>
  20 #include <boost/core/enable_if.hpp>
  21 #include <boost/type_traits/has_plus.hpp>
  22 #include <boost/type_traits/has_plus_assign.hpp>
  23 #include <boost/type_traits/has_minus.hpp>
  24 #include <boost/type_traits/has_minus_assign.hpp>
  25 #include <boost/iterator/advance.hpp>
  26 #include <boost/iterator/reverse_iterator.hpp>
  27
  28 namespace boost {
  29
  30 //  Helper functions for classes like bidirectional iterators not supporting
  31 //  operator+ and operator-
  32 //
  33 //  Usage:
  34 //    const std::list<T>::iterator p = get_some_iterator();
  35 //    const std::list<T>::iterator prev = boost::prior(p);
  36 //    const std::list<T>::iterator next = boost::next(prev, 2);
  37
  38 //  Contributed by Dave Abrahams
  39
  40 namespace next_prior_detail {
  41
  42 // The trait attempts to detect if the T type is an iterator. Class-type iterators are assumed
  43 // to have the nested type iterator_category. Strictly speaking, this is not required to be the
  44 // case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
  45 // Still, this is a good heuristic in practice, and we can't do anything better anyway.
  46 // Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
  47 // required to be only present for iterators.
  48 template< typename T, typename Void = void >
  49 struct is_iterator_class
  50 {
  51     static BOOST_CONSTEXPR_OR_CONST bool value = false;
  52 };
  53
  54 template< typename T >
  55 struct is_iterator_class<
  56     T,
  57     typename enable_if_has_type<
  58 #if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
  59         typename std::iterator_traits< T >::iterator_category
  60 #else
  61         typename T::iterator_category
  62 #endif
  63     >::type
  64 >
  65 {
  66     static BOOST_CONSTEXPR_OR_CONST bool value = true;
  67 };
  68
  69 template< typename T >
  70 struct is_iterator :
  71     public is_iterator_class< T >
  72 {
  73 };
  74
  75 template< typename T >
  76 struct is_iterator< T* >
  77 {
  78     static BOOST_CONSTEXPR_OR_CONST bool value = true;
  79 };
  80
  81
  82 template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
  83 struct next_plus_impl;
  84
  85 template< typename T, typename Distance >
  86 struct next_plus_impl< T, Distance, true >
  87 {
  88     static T call(T x, Distance n)
  89     {
  90         return x + n;
  91     }
  92 };
  93
  94 template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
  95 struct next_plus_assign_impl :
  96     public next_plus_impl< T, Distance >
  97 {
  98 };
  99
 100 template< typename T, typename Distance >
 101 struct next_plus_assign_impl< T, Distance, true >
 102 {
 103     static T call(T x, Distance n)
 104     {
 105         x += n;
 106         return x;
 107     }
 108 };
 109
 110 template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
 111 struct next_advance_impl :
 112     public next_plus_assign_impl< T, Distance >
 113 {
 114 };
 115
 116 template< typename T, typename Distance >
 117 struct next_advance_impl< T, Distance, true >
 118 {
 119     static T call(T x, Distance n)
 120     {
 121         boost::iterators::advance(x, n);
 122         return x;
 123     }
 124 };
 125
 126
 127 template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
 128 struct prior_minus_impl;
 129
 130 template< typename T, typename Distance >
 131 struct prior_minus_impl< T, Distance, true >
 132 {
 133     static T call(T x, Distance n)
 134     {
 135         return x - n;
 136     }
 137 };
 138
 139 template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
 140 struct prior_minus_assign_impl :
 141     public prior_minus_impl< T, Distance >
 142 {
 143 };
 144
 145 template< typename T, typename Distance >
 146 struct prior_minus_assign_impl< T, Distance, true >
 147 {
 148     static T call(T x, Distance n)
 149     {
 150         x -= n;
 151         return x;
 152     }
 153 };
 154
 155 template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
 156 struct prior_advance_impl :
 157     public prior_minus_assign_impl< T, Distance >
 158 {
 159 };
 160
 161 template< typename T, typename Distance >
 162 struct prior_advance_impl< T, Distance, true >
 163 {
 164     static T call(T x, Distance n)
 165     {
 166         // Avoid negating n to sidestep possible integer overflow
 167         boost::iterators::reverse_iterator< T > rx(x);
 168         boost::iterators::advance(rx, n);
 169         return rx.base();
 170     }
 171 };
 172
 173 } // namespace next_prior_detail
 174
 175 template <class T>
 176 inline T next(T x) { return ++x; }
 177
 178 template <class T, class Distance>
 179 inline T next(T x, Distance n)
 180 {
 181     return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
 182 }
 183
 184 template <class T>
 185 inline T prior(T x) { return --x; }
 186
 187 template <class T, class Distance>
 188 inline T prior(T x, Distance n)
 189 {
 190     return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
 191 }
 192
 193 } // namespace boost
 194
 195 #endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED