1 // Copyright David Abrahams 2004. Use, modification and distribution is

     2 // subject to the Boost Software License, Version 1.0. (See accompanying

     3 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

     4 #ifndef IS_INCREMENTABLE_DWA200415_HPP

     5 # define IS_INCREMENTABLE_DWA200415_HPP

     6 

     7 # include <boost/type_traits/detail/template_arity_spec.hpp>

     8 # include <boost/type_traits/remove_cv.hpp>

     9 # include <boost/mpl/aux_/lambda_support.hpp>

    10 # include <boost/mpl/bool.hpp>

    11 # include <boost/detail/workaround.hpp>

    12 

    13 // Must be the last include

    14 # include <boost/type_traits/detail/bool_trait_def.hpp>

    15 

    16 namespace boost { namespace detail { 

    17 

    18 // is_incrementable<T> metafunction

    19 //

    20 // Requires: Given x of type T&, if the expression ++x is well-formed

    21 // it must have complete type; otherwise, it must neither be ambiguous

    22 // nor violate access.

    23 

    24 // This namespace ensures that ADL doesn't mess things up.

    25 namespace is_incrementable_

    26 {

    27   // a type returned from operator++ when no increment is found in the

    28   // type's own namespace

    29   struct tag {};

    30   

    31   // any soaks up implicit conversions and makes the following

    32   // operator++ less-preferred than any other such operator that

    33   // might be found via ADL.

    34   struct any { template <class T> any(T const&); };

    35 

    36   // This is a last-resort operator++ for when none other is found

    37 # if BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2

    38   

    39 }

    40 

    41 namespace is_incrementable_2

    42 {

    43   is_incrementable_::tag operator++(is_incrementable_::any const&);

    44   is_incrementable_::tag operator++(is_incrementable_::any const&,int);

    45 }

    46 using namespace is_incrementable_2;

    47 

    48 namespace is_incrementable_

    49 {

    50   

    51 # else

    52   

    53   tag operator++(any const&);

    54   tag operator++(any const&,int);

    55   

    56 # endif 

    57 

    58 # if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \

    59     || BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

    60 #  define BOOST_comma(a,b) (a)

    61 # else 

    62   // In case an operator++ is found that returns void, we'll use ++x,0

    63   tag operator,(tag,int);  

    64 #  define BOOST_comma(a,b) (a,b)

    65 # endif 

    66   

    67   // two check overloads help us identify which operator++ was picked

    68   char (& check(tag) )[2];

    69   

    70   template <class T>

    71   char check(T const&);

    72   

    73 

    74   template <class T>

    75   struct impl

    76   {

    77       static typename boost::remove_cv<T>::type& x;

    78 

    79       BOOST_STATIC_CONSTANT(

    80           bool

    81         , value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1

    82       );

    83   };

    84 

    85   template <class T>

    86   struct postfix_impl

    87   {

    88       static typename boost::remove_cv<T>::type& x;

    89 

    90       BOOST_STATIC_CONSTANT(

    91           bool

    92         , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1

    93       );

    94   };

    95 }

    96 

    97 # undef BOOST_comma

    98 

    99 template<typename T> 

   100 struct is_incrementable 

   101 BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl<T>::value)

   102 { 

   103     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::impl<T>::value)

   104     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_incrementable,(T))

   105 };

   106 

   107 template<typename T> 

   108 struct is_postfix_incrementable 

   109 BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl<T>::value)

   110 { 

   111     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::postfix_impl<T>::value)

   112     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T))

   113 };

   114 

   115 } // namespace detail

   116 

   117 BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_incrementable)

   118 BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_postfix_incrementable)

   119 

   120 } // namespace boost

   121 

   122 # include <boost/type_traits/detail/bool_trait_undef.hpp>

   123 

   124 #endif // IS_INCREMENTABLE_DWA200415_HPP