untracked/sigc++/adaptors/lambda/base.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_LAMBDA_BASE_HPP_
   4 #define _SIGC_LAMBDA_BASE_HPP_
   5 #include <sigc++/adaptors/adaptor_trait.h>
   6 #include <sigc++/reference_wrapper.h>
   7 #include <type_traits>
   8
   9 #ifndef SIGCXX_DISABLE_DEPRECATED
  10
  11 namespace sigc {
  12
  13 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  14 // libsigc++'s lambda functions have been removed from the API.
  15 // Some code must be kept until we can break ABI.
  16 /** @defgroup lambdas Lambdas
  17  * libsigc++ ships with basic lambda functionality and the sigc::group adaptor,
  18  * which uses lambdas to transform a functor's parameter list.
  19  *
  20  * The lambda selectors sigc::_1, sigc::_2, ..., sigc::_7 are used to select the
  21  * first, second, ..., seventh argument from a list.
  22  *
  23  * @par Examples:
  24  * @code
  25  * std::cout << sigc::_1(10,20,30); // returns 10
  26  * std::cout << sigc::_2(10,20,30); // returns 20
  27  * @endcode
  28  *
  29  * Operators are defined so that, for example, lambda selectors can be used as
  30  * placeholders in arithmetic expressions.
  31  *
  32  * @par Examples:
  33  * @code
  34  * std::cout << (sigc::_1 + 5)(3); // returns (3 + 5)
  35  * std::cout << (sigc::_1 * sigc::_2)(7,10); // returns (7 * 10)
  36  * @endcode
  37  *
  38  * If your compiler supports C++11 lambda expressions, they are often a good
  39  * alternative to libsigc++'s lambda expressions. The following examples are
  40  * equivalent to the previous ones.
  41  * @code
  42  * [] (int x, int, int) -> int { return x; }(10,20,30); // returns 10
  43  * [] (int, int y, int) -> int { return y; }(10,20,30); // returns 20
  44  * [] (int x) -> int { return x + 5; }(3); // returns (3 + 5)
  45  * [] (int x, int y) -> int { return x * y; }(7,10); // returns (7 * 10)
  46  * @endcode
  47  *
  48  * @deprecated Use C++11 lambda expressions or %std::bind() instead.
  49  */
  50
  51 /** A hint to the compiler.
  52  * All lambda types publically inherit from this hint.
  53  *
  54  * @deprecated Use C++11 lambda expressions instead.
  55  *
  56  * @ingroup lambdas
  57  */
  58 struct lambda_base : public adaptor_base {};
  59
  60 // Forward declaration of lambda.
  61 template <class T_type> struct lambda;
  62
  63 namespace internal {
  64
  65 /** Abstracts lambda functionality.
  66  * Objects of this type store a value that may be of type lambda itself.
  67  * In this case, operator()() executes the lambda (a lambda is always a functor at the same time).
  68  * Otherwise, operator()() simply returns the stored value.
  69  *
  70  * @deprecated Use C++11 lambda expressions instead.
  71  *
  72  * @ingroup lambdas
  73  */
  74 template <class T_type, bool I_islambda = std::is_base_of<lambda_base, T_type>::value> struct lambda_core;
  75
  76 /** Abstracts lambda functionality (template specialization for lambda values).
  77  *
  78  * @deprecated Use C++11 lambda expressions instead.
  79  *
  80  * @ingroup lambdas
  81  */
  82 template <class T_type>
  83 struct lambda_core<T_type, true> : public lambda_base
  84 {
  85   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
  86   struct deduce_result_type
  87     { typedef typename T_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
  88   typedef typename T_type::result_type result_type;
  89   typedef T_type lambda_type;
  90
  91   result_type
  92   operator()() const;
  93
  94   template <class T_arg1>
  95   typename deduce_result_type<T_arg1>::type
  96   operator ()(T_arg1 _A_1) const
  97     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
  98              (_A_1);
  99     }
 100
 101   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 102   template <class T_arg1>
 103   typename deduce_result_type<T_arg1>::type
 104   sun_forte_workaround(T_arg1 _A_1) const
 105     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
 106              (_A_1);
 107     }
 108   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 109
 110   template <class T_arg1, class T_arg2>
 111   typename deduce_result_type<T_arg1, T_arg2>::type
 112   operator ()(T_arg1 _A_1, T_arg2 _A_2) const
 113     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
 114              (_A_1, _A_2);
 115     }
 116
 117   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 118   template <class T_arg1, class T_arg2>
 119   typename deduce_result_type<T_arg1, T_arg2>::type
 120   sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2) const
 121     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
 122              (_A_1, _A_2);
 123     }
 124   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 125
 126   template <class T_arg1, class T_arg2, class T_arg3>
 127   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 128   operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3) const
 129     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 130              (_A_1, _A_2, _A_3);
 131     }
 132
 133   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 134   template <class T_arg1, class T_arg2, class T_arg3>
 135   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 136   sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3) const
 137     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 138              (_A_1, _A_2, _A_3);
 139     }
 140   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 141
 142   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 143   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 144   operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const
 145     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 146              (_A_1, _A_2, _A_3, _A_4);
 147     }
 148
 149   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 150   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 151   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 152   sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const
 153     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 154              (_A_1, _A_2, _A_3, _A_4);
 155     }
 156   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 157
 158   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 159   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 160   operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const
 161     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 162              (_A_1, _A_2, _A_3, _A_4, _A_5);
 163     }
 164
 165   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 166   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 167   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 168   sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const
 169     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 170              (_A_1, _A_2, _A_3, _A_4, _A_5);
 171     }
 172   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 173
 174   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 175   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 176   operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const
 177     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 178              (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6);
 179     }
 180
 181   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 182   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 183   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 184   sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const
 185     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 186              (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6);
 187     }
 188   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 189
 190   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 191   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 192   operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const
 193     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
 194              (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7);
 195     }
 196
 197   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 198   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 199   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 200   sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const
 201     { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
 202              (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7);
 203     }
 204   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 205
 206   lambda_core() {}
 207
 208   explicit lambda_core(const T_type& v)
 209     : value_(v) {}
 210
 211   T_type value_;
 212 };
 213
 214
 215 } /* namespace internal */
 216
 217
 218 // forward declarations for lambda operators other<subscript> and other<assign>
 219 template <class T_type>
 220 struct other;
 221 struct subscript;
 222 struct assign;
 223
 224 template <class T_action, class T_type1, class T_type2>
 225 struct lambda_operator;
 226
 227 template <class T_type>
 228 struct unwrap_lambda_type;
 229
 230 /** Lambda type.
 231  * Objects of this type store a value that may be of type lambda itself.
 232  * In this case, operator()() executes the lambda (a lambda is always a functor at the same time).
 233  * Otherwise, operator()() simply returns the stored value.
 234  * The assign and subscript operators are defined to return a lambda operator.
 235  *
 236  * @deprecated Use C++11 lambda expressions instead.
 237  *
 238  * @ingroup lambdas
 239  */
 240 template <class T_type>
 241 struct lambda : public internal::lambda_core<T_type>
 242 {
 243   typedef lambda<T_type> self;
 244
 245   lambda()
 246     {}
 247
 248   lambda(typename type_trait<T_type>::take v)
 249     : internal::lambda_core<T_type>(v)
 250     {}
 251
 252   // operators for other<subscript>
 253   template <class T_arg>
 254   lambda<lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> >
 255   operator [] (const T_arg& a) const
 256     { typedef lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
 257       return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
 258
 259   // operators for other<assign>
 260   template <class T_arg>
 261   lambda<lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> >
 262   operator = (const T_arg& a) const
 263     { typedef lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
 264       return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
 265 };
 266 #endif // DOXYGEN_SHOULD_SKIP_THIS
 267
 268 } /* namespace sigc */
 269
 270 #endif // SIGCXX_DISABLE_DEPRECATED
 271
 272 #endif /* _SIGC_LAMBDA_BASE_HPP_ */