1 // Boost Lambda Library - operator_lambda_func_base.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_OPERATOR_LAMBDA_FUNC_BASE_HPP 14 #define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP 15 16 namespace boost { 17 namespace lambda { 18 19 20 // These operators cannot be implemented as apply functions of action 21 // templates 22 23 24 // Specialization for comma. 25 template<class Args> 26 class lambda_functor_base<other_action<comma_action>, Args> { 27 public: 28 Args args; 29 public: lambda_functor_base(const Args & a)30 explicit lambda_functor_base(const Args& a) : args(a) {} 31 32 template<class RET, CALL_TEMPLATE_ARGS> call(CALL_FORMAL_ARGS) const33 RET call(CALL_FORMAL_ARGS) const { 34 return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS), 35 detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 36 } 37 38 39 template<class SigArgs> struct sig { 40 private: 41 typedef typename 42 detail::deduce_argument_types<Args, SigArgs>::type rets_t; 43 public: 44 typedef typename return_type_2_comma< // comma needs special handling 45 typename detail::element_or_null<0, rets_t>::type, 46 typename detail::element_or_null<1, rets_t>::type 47 >::type type; 48 }; 49 50 }; 51 52 namespace detail { 53 54 // helper traits to make the expression shorter, takes binary action 55 // bound argument tuple, open argument tuple and gives the return type 56 57 template<class Action, class Bound, class Open> class binary_rt { 58 private: 59 typedef typename 60 detail::deduce_argument_types<Bound, Open>::type rets_t; 61 public: 62 typedef typename return_type_2_prot< 63 Action, 64 typename detail::element_or_null<0, rets_t>::type, 65 typename detail::element_or_null<1, rets_t>::type 66 >::type type; 67 }; 68 69 70 // same for unary actions 71 template<class Action, class Bound, class Open> class unary_rt { 72 private: 73 typedef typename 74 detail::deduce_argument_types<Bound, Open>::type rets_t; 75 public: 76 typedef typename return_type_1_prot< 77 Action, 78 typename detail::element_or_null<0, rets_t>::type 79 >::type type; 80 }; 81 82 83 } // end detail 84 85 // Specialization for logical and (to preserve shortcircuiting) 86 // this could be done with a macro as the others, code used to be different 87 template<class Args> 88 class lambda_functor_base<logical_action<and_action>, Args> { 89 public: 90 Args args; 91 public: lambda_functor_base(const Args & a)92 explicit lambda_functor_base(const Args& a) : args(a) {} 93 94 template<class RET, CALL_TEMPLATE_ARGS> call(CALL_FORMAL_ARGS) const95 RET call(CALL_FORMAL_ARGS) const { 96 return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) && 97 detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 98 } 99 template<class SigArgs> struct sig { 100 typedef typename 101 detail::binary_rt<logical_action<and_action>, Args, SigArgs>::type type; 102 }; 103 }; 104 105 // Specialization for logical or (to preserve shortcircuiting) 106 // this could be done with a macro as the others, code used to be different 107 template<class Args> 108 class lambda_functor_base<logical_action< or_action>, Args> { 109 public: 110 Args args; 111 public: lambda_functor_base(const Args & a)112 explicit lambda_functor_base(const Args& a) : args(a) {} 113 114 template<class RET, CALL_TEMPLATE_ARGS> call(CALL_FORMAL_ARGS) const115 RET call(CALL_FORMAL_ARGS) const { 116 return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) || 117 detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 118 } 119 120 template<class SigArgs> struct sig { 121 typedef typename 122 detail::binary_rt<logical_action<or_action>, Args, SigArgs>::type type; 123 }; 124 }; 125 126 // Specialization for subscript 127 template<class Args> 128 class lambda_functor_base<other_action<subscript_action>, Args> { 129 public: 130 Args args; 131 public: lambda_functor_base(const Args & a)132 explicit lambda_functor_base(const Args& a) : args(a) {} 133 134 template<class RET, CALL_TEMPLATE_ARGS> call(CALL_FORMAL_ARGS) const135 RET call(CALL_FORMAL_ARGS) const { 136 return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) 137 [detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)]; 138 } 139 140 template<class SigArgs> struct sig { 141 typedef typename 142 detail::binary_rt<other_action<subscript_action>, Args, SigArgs>::type 143 type; 144 }; 145 }; 146 147 148 #define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS) \ 149 template<class Args> \ 150 class lambda_functor_base<ACTION_CLASS, Args> { \ 151 public: \ 152 Args args; \ 153 public: \ 154 explicit lambda_functor_base(const Args& a) : args(a) {} \ 155 \ 156 template<class RET, CALL_TEMPLATE_ARGS> \ 157 RET call(CALL_FORMAL_ARGS) const { \ 158 return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) \ 159 SYMBOL \ 160 detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \ 161 } \ 162 template<class SigArgs> struct sig { \ 163 typedef typename \ 164 detail::binary_rt<ACTION_CLASS, Args, SigArgs>::type type; \ 165 }; \ 166 }; 167 168 #define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \ 169 template<class Args> \ 170 class lambda_functor_base<ACTION_CLASS, Args> { \ 171 public: \ 172 Args args; \ 173 public: \ 174 explicit lambda_functor_base(const Args& a) : args(a) {} \ 175 \ 176 template<class RET, CALL_TEMPLATE_ARGS> \ 177 RET call(CALL_FORMAL_ARGS) const { \ 178 return SYMBOL \ 179 detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); \ 180 } \ 181 template<class SigArgs> struct sig { \ 182 typedef typename \ 183 detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \ 184 }; \ 185 }; 186 187 #define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \ 188 template<class Args> \ 189 class lambda_functor_base<ACTION_CLASS, Args> { \ 190 public: \ 191 Args args; \ 192 public: \ 193 explicit lambda_functor_base(const Args& a) : args(a) {} \ 194 \ 195 template<class RET, CALL_TEMPLATE_ARGS> \ 196 RET call(CALL_FORMAL_ARGS) const { \ 197 return \ 198 detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) SYMBOL; \ 199 } \ 200 template<class SigArgs> struct sig { \ 201 typedef typename \ 202 detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \ 203 }; \ 204 }; 205 206 BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>) 207 BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>) 208 BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>) 209 BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>) 210 BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>) 211 212 BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>) 213 BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>) 214 BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>) 215 BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>) 216 BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>) 217 218 BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>) 219 BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>) 220 BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>) 221 BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>) 222 BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>) 223 BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>) 224 225 BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>) 226 BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>) 227 BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>) 228 BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>) 229 BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>) 230 231 BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>) 232 BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>) 233 BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>) 234 BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>) 235 BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>) 236 237 BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>) 238 239 240 BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>) 241 BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>) 242 BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>) 243 BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>) 244 BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>) 245 BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>) 246 247 BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>) 248 BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>) 249 250 BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>) 251 BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>) 252 253 254 #undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION 255 #undef BOOST_LAMBDA_PREFIX_UNARY_ACTION 256 #undef BOOST_LAMBDA_BINARY_ACTION 257 258 } // namespace lambda 259 } // namespace boost 260 261 #endif 262 263 264 265 266 267 268 269 270 271 272