ceph/src/boost/boost/lambda/detail/operators.hpp

   1 // Boost Lambda Library - operators.hpp --------------------------------------
   2
   3 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
   4 //
   5 // Distributed under the Boost Software License, Version 1.0. (See
   6 // accompanying file LICENSE_1_0.txt or copy at
   7 // http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // For more information, see www.boost.org
  10
  11 // ---------------------------------------------------------------
  12
  13 #ifndef BOOST_LAMBDA_OPERATORS_HPP
  14 #define BOOST_LAMBDA_OPERATORS_HPP
  15
  16 #include "boost/lambda/detail/is_instance_of.hpp"
  17
  18 namespace boost {
  19 namespace lambda {
  20
  21 #if defined BOOST_LAMBDA_BE1
  22 #error "Multiple defines of BOOST_LAMBDA_BE1"
  23 #endif
  24
  25   // For all BOOSTA_LAMBDA_BE* macros:
  26
  27   // CONSTA must be either 'A' or 'const A'
  28   // CONSTB must be either 'B' or 'const B'
  29
  30   // It is stupid to have the names A and B as macro arguments, but it avoids
  31   // the need to pass in emtpy macro arguments, which gives warnings on some
  32   // compilers
  33
  34 #define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
  35 template<class Arg, class B>                                                 \
  36 inline const                                                                 \
  37 lambda_functor<                                                              \
  38   lambda_functor_base<                                                       \
  39     ACTION,                                                                  \
  40     tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>  \
  41   >                                                                          \
  42 >                                                                            \
  43 OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) {                      \
  44   return                                                                     \
  45     lambda_functor_base<                                                     \
  46       ACTION,                                                                \
  47       tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
  48     >                                                                        \
  49    (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
  50 }
  51
  52
  53 #if defined BOOST_LAMBDA_BE2
  54 #error "Multiple defines of BOOST_LAMBDA_BE2"
  55 #endif
  56
  57 #define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
  58 template<class A, class Arg>                                                 \
  59 inline const                                                                 \
  60 lambda_functor<                                                              \
  61   lambda_functor_base<                                                       \
  62     ACTION,                                                                  \
  63     tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >        \
  64   >                                                                          \
  65 >                                                                            \
  66 OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) {                      \
  67   return                                                                     \
  68     lambda_functor_base<                                                     \
  69       ACTION,                                                                \
  70       tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >      \
  71     >                                                                        \
  72   (tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
  73 }
  74
  75
  76 #if defined BOOST_LAMBDA_BE3
  77 #error "Multiple defines of BOOST_LAMBDA_BE3"
  78 #endif
  79
  80 #define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)    \
  81 template<class ArgA, class ArgB>                                           \
  82 inline const                                                               \
  83 lambda_functor<                                                            \
  84   lambda_functor_base<                                                     \
  85     ACTION,                                                                \
  86     tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                     \
  87   >                                                                        \
  88 >                                                                          \
  89 OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \
  90   return                                                                   \
  91     lambda_functor_base<                                                   \
  92       ACTION,                                                              \
  93       tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                   \
  94     >                                                                      \
  95   (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b));              \
  96 }
  97
  98 #if defined BOOST_LAMBDA_BE
  99 #error "Multiple defines of BOOST_LAMBDA_BE"
 100 #endif
 101
 102 #define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
 103 BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
 104 BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
 105 BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
 106
 107 #define BOOST_LAMBDA_EMPTY()
 108
 109 BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
 110 BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
 111 BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
 112 BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
 113 BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
 114 BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
 115 BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
 116 BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
 117 BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
 118 BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
 119 BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
 120 BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
 121 BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
 122 BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
 123 BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
 124 BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
 125 BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
 126 BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
 127
 128 BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
 129 BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
 130 BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
 131 BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
 132 BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
 133 BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
 134 BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
 135 BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
 136 BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
 137 BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
 138
 139
 140 // A special trick for comma operator for correct preprocessing
 141 #if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME
 142 #error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME"
 143 #endif
 144
 145 #define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
 146
 147 BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
 148 BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
 149 BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
 150
 151
 152
 153 namespace detail {
 154
 155 // special cases for ostream& << Any and istream& >> Any ---------------
 156 // the actual stream classes may vary and thus a specialisation for,
 157 // say ostream& does not match (the general case above is chosen).
 158 // Therefore we specialise for non-const reference:
 159 // if the left argument is a stream, we store the stream as reference
 160 // if it is something else, we store a const plain by default
 161
 162 // Note that the overloading is const vs. non-const first argument
 163
 164
 165 template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
 166   typedef typename detail::IF<
 167                        is_instance_of_2<
 168                          T, std::basic_ostream
 169                        >::value,
 170                        T&,
 171                        typename const_copy_argument <T>::type
 172                      >::RET type;
 173 };
 174
 175 template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
 176   typedef typename detail::IF<
 177                        is_instance_of_2<
 178                          T, std::basic_istream
 179                        >::value,
 180                        T&,
 181                        typename const_copy_argument <T>::type
 182                      >::RET type;
 183 };
 184
 185 } // detail
 186
 187 BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
 188 BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)
 189
 190
 191 // special case for io_manipulators.
 192 // function references cannot be given as arguments to lambda operator
 193 // expressions in general. With << and >> the use of manipulators is
 194 // so common, that specializations are provided to make them work.
 195
 196 template<class Arg, class Ret, class ManipArg>
 197 inline const
 198 lambda_functor<
 199   lambda_functor_base<
 200     bitwise_action<leftshift_action>,
 201     tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
 202   >
 203 >
 204 operator<<(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
 205 {
 206   return
 207       lambda_functor_base<
 208         bitwise_action<leftshift_action>,
 209         tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
 210       >
 211     ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
 212 }
 213
 214 template<class Arg, class Ret, class ManipArg>
 215 inline const
 216 lambda_functor<
 217   lambda_functor_base<
 218     bitwise_action<rightshift_action>,
 219     tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
 220   >
 221 >
 222 operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
 223 {
 224   return
 225       lambda_functor_base<
 226         bitwise_action<rightshift_action>,
 227         tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
 228       >
 229     ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
 230 }
 231
 232
 233 // (+ and -) take their arguments as const references.
 234 // This has consquences with pointer artihmetic
 235 // E.g int a[]; ... *a = 1 works but not *(a+1) = 1.
 236 // the result of a+1 would be const
 237 // To make the latter work too,
 238 // non-const arrays are taken as non-const and stored as non-const as well.
 239 #if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E1
 240 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"
 241 #endif
 242
 243 #define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)           \
 244 template<class Arg, int N, class B>                                         \
 245 inline const                                                                \
 246 lambda_functor<                                                             \
 247   lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >    \
 248 >                                                                           \
 249 OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                     \
 250 {                                                                           \
 251   return                                                                    \
 252     lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >  \
 253   (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                         \
 254 }
 255
 256
 257 #if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E2
 258 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E2"
 259 #endif
 260
 261 #define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)           \
 262 template<int N, class A, class Arg>                                         \
 263 inline const                                                                \
 264 lambda_functor<                                                             \
 265   lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > >   \
 266 >                                                                           \
 267 OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b)                     \
 268 {                                                                           \
 269   return                                                                    \
 270     lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
 271     (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b));                      \
 272 }
 273
 274
 275 BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
 276 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
 277 BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
 278 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
 279
 280
 281 //BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
 282 // This is not needed, since the result of ptr-ptr is an rvalue anyway
 283
 284 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
 285 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
 286
 287
 288 #undef BOOST_LAMBDA_BE1
 289 #undef BOOST_LAMBDA_BE2
 290 #undef BOOST_LAMBDA_BE3
 291 #undef BOOST_LAMBDA_BE
 292 #undef BOOST_LAMBDA_COMMA_OPERATOR_NAME
 293
 294 #undef BOOST_LAMBDA_PTR_ARITHMETIC_E1
 295 #undef BOOST_LAMBDA_PTR_ARITHMETIC_E2
 296
 297
 298 // ---------------------------------------------------------------------
 299 // unary operators -----------------------------------------------------
 300 // ---------------------------------------------------------------------
 301
 302 #if defined BOOST_LAMBDA_UE
 303 #error "Multiple defines of BOOST_LAMBDA_UE"
 304 #endif
 305
 306 #define BOOST_LAMBDA_UE(OPER_NAME, ACTION)                                 \
 307 template<class Arg>                                                        \
 308 inline const                                                               \
 309 lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
 310 OPER_NAME (const lambda_functor<Arg>& a)                                   \
 311 {                                                                          \
 312   return                                                                   \
 313     lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \
 314     ( tuple<lambda_functor<Arg> >(a) );                                    \
 315 }
 316
 317
 318 BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
 319 BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
 320 BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
 321 BOOST_LAMBDA_UE(operator!, logical_action<not_action>)
 322 BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
 323 BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
 324 BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
 325 BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
 326
 327 #if defined BOOST_LAMBDA_POSTFIX_UE
 328 #error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"
 329 #endif
 330
 331 #define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION)                         \
 332 template<class Arg>                                                        \
 333 inline const                                                               \
 334 lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
 335 OPER_NAME (const lambda_functor<Arg>& a, int)                              \
 336 {                                                                          \
 337   return                                                                   \
 338     lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \
 339     ( tuple<lambda_functor<Arg> >(a) );                                    \
 340 }
 341
 342
 343 BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
 344 BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
 345
 346 #undef BOOST_LAMBDA_UE
 347 #undef BOOST_LAMBDA_POSTFIX_UE
 348
 349 } // namespace lambda
 350 } // namespace boost
 351
 352 #endif