test: epoc32/include/stdapis/boost/lambda/detail/operators.hpp@837f303aceeb

     1 // Boost Lambda Library - operators.hpp --------------------------------------

     3 // Copyright (C) 1999, 2000 Jaakko Järvi (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

    11 // ---------------------------------------------------------------

    13 #ifndef BOOST_LAMBDA_OPERATORS_HPP

    14 #define BOOST_LAMBDA_OPERATORS_HPP

    16 #include "boost/lambda/detail/is_instance_of.hpp"

    18 namespace boost {

    19 namespace lambda {

    21 #if defined BOOST_LAMBDA_BE1

    22 #error "Multiple defines of BOOST_LAMBDA_BE1"

    23 #endif

    25   // For all BOOSTA_LAMBDA_BE* macros:

    27   // CONSTA must be either 'A' or 'const A'

    28   // CONSTB must be either 'B' or 'const B'

    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

    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 CONVERSION <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 CONVERSION <CONSTB>::type>       \

    48     >                                                                        \

    49    (tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>(a, b)); \

    50 }

    53 #if defined BOOST_LAMBDA_BE2

    54 #error "Multiple defines of BOOST_LAMBDA_BE2"

    55 #endif

    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 }

    76 #if defined BOOST_LAMBDA_BE3

    77 #error "Multiple defines of BOOST_LAMBDA_BE3"

    78 #endif

    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 }

    98 #if defined BOOST_LAMBDA_BE

    99 #error "Multiple defines of BOOST_LAMBDA_BE"

   100 #endif

   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)

   107 #define BOOST_LAMBDA_EMPTY()

   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)

   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)

   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

   145 #define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,

   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)

   153 namespace detail {

   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

   162 // Note that the overloading is const vs. non-const first argument

   164 #ifdef BOOST_NO_TEMPLATED_STREAMS

   165 template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {

   166   typedef typename detail::IF<

   167                        boost::is_convertible<T*, std::ostream*>::value,

   168                        T&,

   169                        typename const_copy_argument <T>::type

   170                      >::RET type;

   171 };

   173 template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {

   174   typedef typename detail::IF<

   175                        boost::is_convertible<T*, std::istream*>::value,

   176                        T&,

   177                        typename const_copy_argument <T>::type

   178                      >::RET type;

   179 };

   180 #else

   182 template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {

   183   typedef typename detail::IF<

   184                        is_instance_of_2<

   185                          T, std::basic_ostream

   186                        >::value,

   187                        T&,

   188                        typename const_copy_argument <T>::type

   189                      >::RET type;

   190 };

   192 template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {

   193   typedef typename detail::IF<

   194                        is_instance_of_2<

   195                          T, std::basic_istream

   196                        >::value,

   197                        T&,

   198                        typename const_copy_argument <T>::type

   199                      >::RET type;

   200 };

   201 #endif

   203 } // detail

   205 BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)

   206 BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)

   209 // special case for io_manipulators.

   210 // function references cannot be given as arguments to lambda operator

   211 // expressions in general. With << and >> the use of manipulators is

   212 // so common, that specializations are provided to make them work.

   214 template<class Arg, class Ret, class ManipArg>

   215 inline const

   216 lambda_functor<

   217   lambda_functor_base<

   218     bitwise_action<leftshift_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<leftshift_action>,

   227         tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>

   228       >

   229     ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );

   230 }

   232 template<class Arg, class Ret, class ManipArg>

   233 inline const

   234 lambda_functor<

   235   lambda_functor_base<

   236     bitwise_action<rightshift_action>,

   237     tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>

   238   >

   239 >

   240 operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))

   241 {

   242   return

   243       lambda_functor_base<

   244         bitwise_action<rightshift_action>,

   245         tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>

   246       >

   247     ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );

   248 }

   251 // (+ and -) take their arguments as const references.

   252 // This has consquences with pointer artihmetic

   253 // E.g int a[]; ... *a = 1 works but not *(a+1) = 1.

   254 // the result of a+1 would be const

   255 // To make the latter work too,

   256 // non-const arrays are taken as non-const and stored as non-const as well.

   257 #if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E1

   258 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"

   259 #endif

   261 #define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)            \

   262 template<class Arg, int N, class B>                                         \

   263 inline const                                                                \

   264 lambda_functor<                                                             \

   265   lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >   \

   266 >                                                                           \

   267 OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                    \

   268 {                                                                           \

   269   return lambda_functor<                                                    \

   270     lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \

   271   >(tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                       \

   272 }

   275 #if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E2

   276 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E2"

   277 #endif

   279 #define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)             \

   280 template<int N, class A, class Arg>                                          \

   281 inline const                                                                 \

   282 lambda_functor<                                                              \

   283   lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > >   \

   284 >                                                                            \

   285 OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b)                     \

   286 {                                                                            \

   287   return                                                                     \

   288     lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \

   289     (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b));                      \

   290 }

   293 BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)

   294 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)

   295 BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)

   296 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)

   299 //BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)

   300 // This is not needed, since the result of ptr-ptr is an rvalue anyway

   302 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)

   303 BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)

   306 #undef BOOST_LAMBDA_BE1

   307 #undef BOOST_LAMBDA_BE2

   308 #undef BOOST_LAMBDA_BE3

   309 #undef BOOST_LAMBDA_BE

   310 #undef BOOST_LAMBDA_COMMA_OPERATOR_NAME

   312 #undef BOOST_LAMBDA_PTR_ARITHMETIC_E1

   313 #undef BOOST_LAMBDA_PTR_ARITHMETIC_E2

   316 // ---------------------------------------------------------------------

   317 // unary operators -----------------------------------------------------

   318 // ---------------------------------------------------------------------

   320 #if defined BOOST_LAMBDA_UE

   321 #error "Multiple defines of BOOST_LAMBDA_UE"

   322 #endif

   324 #define BOOST_LAMBDA_UE(OPER_NAME, ACTION)                                 \

   325 template<class Arg>                                                        \

   326 inline const                                                               \

   327 lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \

   328 OPER_NAME (const lambda_functor<Arg>& a)                                   \

   329 {                                                                          \

   330   return                                                                   \

   331     lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \

   332     ( tuple<lambda_functor<Arg> >(a) );                                    \

   333 }

   336 BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)

   337 BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)

   338 BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)

   339 BOOST_LAMBDA_UE(operator!, logical_action<not_action>)

   340 BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)

   341 BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)

   342 BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)

   343 BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)

   345 #if defined BOOST_LAMBDA_POSTFIX_UE

   346 #error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"

   347 #endif

   349 #define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION)                         \

   350 template<class Arg>                                                        \

   351 inline const                                                               \

   352 lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \

   353 OPER_NAME (const lambda_functor<Arg>& a, int)                              \

   354 {                                                                          \

   355   return                                                                   \

   356     lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \

   357     ( tuple<lambda_functor<Arg> >(a) );                                    \

   358 }

   361 BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)

   362 BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)

   364 #undef BOOST_LAMBDA_UE

   365 #undef BOOST_LAMBDA_POSTFIX_UE

   367 } // namespace lambda

   368 } // namespace boost

   370 #endif

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:33:34 +0100
branch	Symbian3
changeset 4	837f303aceeb
parent 3	e1b950c65cb4
permissions	-rw-r--r--