]> git.tdb.fi Git - ext/sigc++-2.0.git/blob - untracked/sigc++/adaptors/compose.h
Import libsigc++ 2.10.8 sources
[ext/sigc++-2.0.git] / 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_ */