]> git.tdb.fi Git - ext/sigc++-2.0.git/blob - untracked/sigc++/adaptors/exception_catch.h
Import libsigc++ 2.10.8 sources
[ext/sigc++-2.0.git] / untracked / sigc++ / adaptors / exception_catch.h
1 // -*- c++ -*-
2 /* Do not edit! -- generated file */
3 #ifndef _SIGC_ADAPTORS_EXCEPTION_CATCH_H_
4 #define _SIGC_ADAPTORS_EXCEPTION_CATCH_H_
5 #include <sigc++/adaptors/adaptor_trait.h>
6
7 namespace sigc {
8
9 /*
10    functor adaptor:  exception_catch(functor, catcher)
11
12    usage:
13
14
15    Future directions:
16      The catcher should be told what type of return it needs to
17    return for multiple type functors,  to do this the user
18    will need to derive from catcher_base.
19 */
20 /** @defgroup exception_catch exception_catch()
21  * sigc::exception_catch() catches an exception thrown from within
22  * the wrapped functor and directs it to a catcher functor.
23  * This catcher can then rethrow the exception and catch it with the proper type.
24  *
25  * Note that the catcher is expected to return the same type
26  * as the wrapped functor so that normal flow can continue.
27  *
28  * Catchers can be cascaded to catch multiple types, because uncaught
29  * rethrown exceptions proceed to the next catcher adaptor.
30  *
31  * @par Examples:
32  * @code
33  * struct my_catch
34  * {
35  *   int operator()()
36  *   {
37  *     try { throw; }
38  *     catch (std::range_error e) // catch what types we know
39  *       { std::cerr << "caught " << e.what() << std::endl; }
40  *     return 1;
41  *   }
42  * }
43  * int foo(); // throws std::range_error
44  * sigc::exception_catch(&foo, my_catch())();
45  * @endcode
46  *
47  * The functor sigc::exception_catch() returns can be directly passed into
48  * sigc::signal::connect().
49  *
50  * @par Example:
51  * @code
52  * sigc::signal<int> some_signal;
53  * some_signal.connect(sigc::exception_catch(&foo, my_catch));
54  * @endcode
55  *
56  * @ingroup adaptors
57  */
58
59 template <class T_functor, class T_catcher, class T_return = typename adapts<T_functor>::result_type>
60 struct exception_catch_functor : public adapts<T_functor>
61 {
62   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
63
64 #ifndef DOXYGEN_SHOULD_SKIP_THIS
65   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>
66   struct deduce_result_type
67     { typedef typename adaptor_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; };
68 #endif
69   typedef T_return result_type;
70
71   result_type
72   operator()();
73
74   template <class T_arg1>
75   typename deduce_result_type<T_arg1>::type
76   operator()(T_arg1 _A_a1)
77     {
78       try
79         {
80           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
81             (_A_a1);
82         }
83       catch (...)
84         { return catcher_(); }
85     }
86
87   template <class T_arg1, class T_arg2>
88   typename deduce_result_type<T_arg1, T_arg2>::type
89   operator()(T_arg1 _A_a1, T_arg2 _A_a2)
90     {
91       try
92         {
93           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
94             (_A_a1, _A_a2);
95         }
96       catch (...)
97         { return catcher_(); }
98     }
99
100   template <class T_arg1, class T_arg2, class T_arg3>
101   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
102   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
103     {
104       try
105         {
106           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
107             (_A_a1, _A_a2, _A_a3);
108         }
109       catch (...)
110         { return catcher_(); }
111     }
112
113   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
114   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
115   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
116     {
117       try
118         {
119           return this->functor_.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>>
120             (_A_a1, _A_a2, _A_a3, _A_a4);
121         }
122       catch (...)
123         { return catcher_(); }
124     }
125
126   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
127   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
128   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
129     {
130       try
131         {
132           return this->functor_.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>>
133             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
134         }
135       catch (...)
136         { return catcher_(); }
137     }
138
139   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
140   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
141   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)
142     {
143       try
144         {
145           return this->functor_.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>>
146             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
147         }
148       catch (...)
149         { return catcher_(); }
150     }
151
152   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
153   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
154   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)
155     {
156       try
157         {
158           return this->functor_.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>>
159             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
160         }
161       catch (...)
162         { return catcher_(); }
163     }
164
165   exception_catch_functor(const T_functor& _A_func,
166                           const T_catcher& _A_catcher)
167     : adapts<T_functor>(_A_func), catcher_(_A_catcher)
168     {}
169
170   T_catcher catcher_;
171 };
172
173 template <class T_functor, class T_catcher, class T_return>
174 typename exception_catch_functor<T_functor, T_catcher, T_return>::result_type
175 exception_catch_functor<T_functor, T_catcher, T_return>::operator()()
176   {
177     try
178       { return this->functor_(); }
179     catch (...)
180       { return catcher_(); }
181   }
182
183 // void specialization
184 template <class T_functor, class T_catcher>
185 struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_functor>
186 {
187   typedef void result_type;
188   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
189
190 #ifndef DOXYGEN_SHOULD_SKIP_THIS
191   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>
192   struct deduce_result_type
193     { typedef typename adaptor_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; };
194 #endif
195
196   void
197   operator()();
198
199   template <class T_arg1>
200   typename deduce_result_type<T_arg1>::type
201   operator()(T_arg1 _A_a1)
202     {
203       try
204         {
205           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
206             (_A_a1);
207         }
208       catch (...)
209         { return catcher_(); }
210     }
211
212   template <class T_arg1, class T_arg2>
213   typename deduce_result_type<T_arg1, T_arg2>::type
214   operator()(T_arg1 _A_a1, T_arg2 _A_a2)
215     {
216       try
217         {
218           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
219             (_A_a1, _A_a2);
220         }
221       catch (...)
222         { return catcher_(); }
223     }
224
225   template <class T_arg1, class T_arg2, class T_arg3>
226   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
227   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
228     {
229       try
230         {
231           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
232             (_A_a1, _A_a2, _A_a3);
233         }
234       catch (...)
235         { return catcher_(); }
236     }
237
238   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
239   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
240   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
241     {
242       try
243         {
244           return this->functor_.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>>
245             (_A_a1, _A_a2, _A_a3, _A_a4);
246         }
247       catch (...)
248         { return catcher_(); }
249     }
250
251   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
252   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
253   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
254     {
255       try
256         {
257           return this->functor_.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>>
258             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
259         }
260       catch (...)
261         { return catcher_(); }
262     }
263
264   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
265   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
266   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)
267     {
268       try
269         {
270           return this->functor_.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>>
271             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
272         }
273       catch (...)
274         { return catcher_(); }
275     }
276
277   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
278   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
279   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)
280     {
281       try
282         {
283           return this->functor_.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>>
284             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
285         }
286       catch (...)
287         { return catcher_(); }
288     }
289
290   exception_catch_functor() {}
291   exception_catch_functor(const T_functor& _A_func,
292                           const T_catcher& _A_catcher)
293     : adapts<T_functor>(_A_func), catcher_(_A_catcher)
294     {}
295   ~exception_catch_functor() {}
296
297     T_catcher catcher_;
298 };
299
300 template <class T_functor, class T_catcher>
301 void exception_catch_functor<T_functor, T_catcher, void>::operator()()
302   {
303     try
304       { this->functor_(); } // I don't understand why void return doesn't work here (Martin)
305     catch (...)
306       { this->catcher_(); }
307   }
308
309 #ifndef DOXYGEN_SHOULD_SKIP_THIS
310 //template specialization of visitor<>::do_visit_each<>(action, functor):
311 template <class T_functor, class T_catcher, class T_return>
312 struct visitor<exception_catch_functor<T_functor, T_catcher, T_return> >
313 {
314   template <typename T_action>
315   static void do_visit_each(const T_action& _A_action,
316                             const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
317   {
318     sigc::visit_each(_A_action, _A_target.functor_);
319     sigc::visit_each(_A_action, _A_target.catcher_);
320   }
321 };
322 #endif // DOXYGEN_SHOULD_SKIP_THIS
323
324 template <class T_functor, class T_catcher>
325 inline exception_catch_functor<T_functor, T_catcher>
326 exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher)
327   { return exception_catch_functor<T_functor, T_catcher>(_A_func, _A_catcher); }
328
329 } /* namespace sigc */
330 #endif /* _SIGC_ADAPTORS_EXCEPTION_CATCH_H_ */