untracked/sigc++/adaptors/compose.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3
   4 #ifndef _SIGC_ADAPTORS_COMPOSE_H_
   5 #define _SIGC_ADAPTORS_COMPOSE_H_
   6 #include <sigc++/adaptors/adaptor_trait.h>
   7
   8 namespace sigc {
   9
  10 /** @defgroup compose compose()
  11  * sigc::compose() combines two or three arbitrary functors.
  12  * On invokation, parameters are passed on to one or two getter functor(s).
  13  * The return value(s) are then passed on to the setter function.
  14  *
  15  * @par Examples:
  16  * @code
  17  * float square_root(float a)  { return sqrtf(a); }
  18  * float sum(float a, float b) { return a+b; }
  19  * std::cout << sigc::compose(&square_root, &sum)(9, 16); // calls square_root(sum(3,6))
  20  * std::cout << sigc::compose(&sum, &square_root, &square_root)(9); // calls sum(square_root(9), square_root(9))
  21  * @endcode
  22  *
  23  * The functor sigc::compose() returns can be passed directly into
  24  * sigc::signal::connect().
  25  *
  26  * @par Example:
  27  * @code
  28  * sigc::signal<float,float,float> some_signal;
  29  * some_signal.connect(sigc::compose(&square_root, &sum));
  30  * @endcode
  31  *
  32  * @ingroup adaptors
  33  */
  34
  35 /** Adaptor that combines two functors.
  36  * Use the convenience function sigc::compose() to create an instance of sigc::compose1_functor.
  37  *
  38  * The following template arguments are used:
  39  * - @e T_setter Type of the setter functor to wrap.
  40  * - @e T_getter Type of the getter functor to wrap.
  41  *
  42  * @ingroup compose
  43  */
  44 template <class T_setter, class T_getter>
  45 struct compose1_functor : public adapts<T_setter>
  46 {
  47   typedef typename adapts<T_setter>::adaptor_type adaptor_type;
  48   typedef T_setter setter_type;
  49   typedef T_getter getter_type;
  50
  51 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  52   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>
  53   struct deduce_result_type
  54     { typedef typename adaptor_type::template deduce_result_type<
  55         sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
  56           >::type type; };
  57 #endif
  58   typedef typename adaptor_type::result_type  result_type;
  59
  60   result_type
  61   operator()();
  62
  63   template <class T_arg1>
  64   typename deduce_result_type<T_arg1>::type
  65   operator()(T_arg1 _A_a1)
  66     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1>>
  67         (get_(_A_a1));
  68     }
  69
  70   template <class T_arg1, class T_arg2>
  71   typename deduce_result_type<T_arg1, T_arg2>::type
  72   operator()(T_arg1 _A_a1, T_arg2 _A_a2)
  73     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2>>
  74         (get_(_A_a1, _A_a2));
  75     }
  76
  77   template <class T_arg1, class T_arg2, class T_arg3>
  78   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
  79   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
  80     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3>>
  81         (get_(_A_a1, _A_a2, _A_a3));
  82     }
  83
  84   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
  85   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
  86   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
  87     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4>>
  88         (get_(_A_a1, _A_a2, _A_a3, _A_a4));
  89     }
  90
  91   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
  92   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
  93   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
  94     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>>
  95         (get_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
  96     }
  97
  98   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
  99   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 100   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
 101     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>>
 102         (get_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
 103     }
 104
 105   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 106   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 107   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
 108     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>>
 109         (get_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
 110     }
 111
 112
 113   /** Constructs a compose1_functor object that combines the passed functors.
 114    * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2.
 115    * @param _A_getter Functor to invoke from operator()().
 116    */
 117   compose1_functor(const T_setter& _A_setter, const T_getter& _A_getter)
 118     : adapts<T_setter>(_A_setter), get_(_A_getter)
 119     {}
 120
 121   getter_type get_; // public, so that visit_each() can access it
 122 };
 123
 124 template <class T_setter, class T_getter>
 125 typename compose1_functor<T_setter, T_getter>::result_type
 126 compose1_functor<T_setter, T_getter>::operator()()
 127   { return this->functor_(get_()); }
 128
 129 /** Adaptor that combines three functors.
 130  * Use the convenience function sigc::compose() to create an instance of sigc::compose2_functor.
 131  *
 132  * The following template arguments are used:
 133  * - @e T_setter Type of the setter functor to wrap.
 134  * - @e T_getter1 Type of the first getter functor to wrap.
 135  * - @e T_getter2 Type of the second getter functor to wrap.
 136  *
 137  * @ingroup compose
 138  */
 139 template <class T_setter, class T_getter1, class T_getter2>
 140 struct compose2_functor : public adapts<T_setter>
 141 {
 142   typedef typename adapts<T_setter>::adaptor_type adaptor_type;
 143   typedef T_setter setter_type;
 144   typedef T_getter1 getter1_type;
 145   typedef T_getter2 getter2_type;
 146
 147 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 148   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>
 149   struct deduce_result_type
 150     { typedef typename adaptor_type::template deduce_result_type<
 151         typename sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>,
 152         typename sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 153           >::type result_type; };
 154 #endif
 155   typedef typename adaptor_type::result_type  result_type;
 156
 157   result_type
 158   operator()();
 159
 160   template <class T_arg1>
 161   typename deduce_result_type<T_arg1>::type
 162   operator()(T_arg1 _A_a1)
 163     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1>,
 164                                                          sigc::deduce_result_t<T_getter2, T_arg1>>
 165         (get1_(_A_a1), get2_(_A_a1));
 166     }
 167
 168   template <class T_arg1, class T_arg2>
 169   typename deduce_result_type<T_arg1, T_arg2>::type
 170   operator()(T_arg1 _A_a1, T_arg2 _A_a2)
 171     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2>,
 172                                                          sigc::deduce_result_t<T_getter2, T_arg1, T_arg2>>
 173         (get1_(_A_a1, _A_a2), get2_(_A_a1, _A_a2));
 174     }
 175
 176   template <class T_arg1, class T_arg2, class T_arg3>
 177   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 178   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
 179     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3>,
 180                                                          sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3>>
 181         (get1_(_A_a1, _A_a2, _A_a3), get2_(_A_a1, _A_a2, _A_a3));
 182     }
 183
 184   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 185   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 186   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
 187     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4>,
 188                                                          sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4>>
 189         (get1_(_A_a1, _A_a2, _A_a3, _A_a4), get2_(_A_a1, _A_a2, _A_a3, _A_a4));
 190     }
 191
 192   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 193   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 194   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
 195     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>,
 196                                                          sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>>
 197         (get1_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5), get2_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
 198     }
 199
 200   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 201   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 202   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
 203     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>,
 204                                                          sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>>
 205         (get1_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6), get2_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
 206     }
 207
 208   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 209   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 210   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
 211     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>,
 212                                                          sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>>
 213         (get1_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7), get2_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
 214     }
 215
 216
 217   /** Constructs a compose2_functor object that combines the passed functors.
 218    * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2.
 219    * @param _A_getter1 Functor to invoke from operator()().
 220    * @param _A_getter2 Functor to invoke from operator()().
 221    */
 222   compose2_functor(const T_setter& _A_setter,
 223                    const T_getter1& _A_getter1,
 224                    const T_getter2& _A_getter2)
 225     : adapts<T_setter>(_A_setter), get1_(_A_getter1), get2_(_A_getter2)
 226     {}
 227
 228   getter1_type get1_; // public, so that visit_each() can access it
 229   getter2_type get2_; // public, so that visit_each() can access it
 230 };
 231
 232 template <class T_setter, class T_getter1, class T_getter2>
 233 typename compose2_functor<T_setter, T_getter1, T_getter2>::result_type
 234 compose2_functor<T_setter, T_getter1, T_getter2>::operator()()
 235   { return this->functor_(get1_(), get2_()); }
 236
 237 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 238 //template specialization of visitor<>::do_visit_each<>(action, functor):
 239 /** Performs a functor on each of the targets of a functor.
 240  * The function overload for sigc::compose1_functor performs a functor on the
 241  * functors stored in the sigc::compose1_functor object.
 242  *
 243  * @ingroup compose
 244  */
 245 template <class T_setter, class T_getter>
 246 struct visitor<compose1_functor<T_setter, T_getter> >
 247 {
 248   template <class T_action>
 249   static void do_visit_each(const T_action& _A_action,
 250                             const compose1_functor<T_setter, T_getter>& _A_target)
 251   {
 252     sigc::visit_each(_A_action, _A_target.functor_);
 253     sigc::visit_each(_A_action, _A_target.get_);
 254   }
 255 };
 256
 257 //template specialization of visitor<>::do_visit_each<>(action, functor):
 258 /** Performs a functor on each of the targets of a functor.
 259  * The function overload for sigc::compose2_functor performs a functor on the
 260  * functors stored in the sigc::compose2_functor object.
 261  *
 262  * @ingroup compose
 263  */
 264 template <class T_setter, class T_getter1, class T_getter2>
 265 struct visitor<compose2_functor<T_setter, T_getter1, T_getter2> >
 266 {
 267   template <class T_action>
 268   static void do_visit_each(const T_action& _A_action,
 269                             const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
 270   {
 271     sigc::visit_each(_A_action, _A_target.functor_);
 272     sigc::visit_each(_A_action, _A_target.get1_);
 273     sigc::visit_each(_A_action, _A_target.get2_);
 274   }
 275 };
 276 #endif // DOXYGEN_SHOULD_SKIP_THIS
 277
 278 /** Creates an adaptor of type sigc::compose1_functor which combines two functors.
 279  *
 280  * @param _A_setter Functor that receives the return value of the invokation of @e _A_getter.
 281  * @param _A_getter Functor to invoke from operator()().
 282  * @return Adaptor that executes @e _A_setter with the value returned from invokation of @e _A_getter.
 283  *
 284  * @ingroup compose
 285  */
 286 template <class T_setter, class T_getter>
 287 inline compose1_functor<T_setter, T_getter>
 288 compose(const T_setter& _A_setter, const T_getter& _A_getter)
 289   { return compose1_functor<T_setter, T_getter>(_A_setter, _A_getter); }
 290
 291 /** Creates an adaptor of type sigc::compose2_functor which combines three functors.
 292  *
 293  * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2.
 294  * @param _A_getter1 Functor to invoke from operator()().
 295  * @param _A_getter2 Functor to invoke from operator()().
 296  * @return Adaptor that executes @e _A_setter with the values return from invokation of @e _A_getter1 and @e _A_getter2.
 297  *
 298  * @ingroup compose
 299  */
 300 template <class T_setter, class T_getter1, class T_getter2>
 301 inline compose2_functor<T_setter, T_getter1, T_getter2>
 302 compose(const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
 303   { return compose2_functor<T_setter, T_getter1, T_getter2>(_A_setter, _A_getter1, _A_getter2); }
 304
 305 } /* namespace sigc */
 306 #endif /* _SIGC_ADAPTORS_COMPOSE_H_ */